/* Mach-O support for BFD.
- Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
- 2009, 2010, 2011, 2012
- Free Software Foundation, Inc.
+ Copyright (C) 1999-2017 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
#define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
#define FILE_ALIGN(off, algn) \
- (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
+ (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1U << (algn)))
+
+static bfd_boolean
+bfd_mach_o_read_dyld_content (bfd *abfd, bfd_mach_o_dyld_info_command *cmd);
unsigned int
bfd_mach_o_version (bfd *abfd)
{ ".debug_macro", "__debug_macro",
SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
BFD_MACH_O_S_ATTR_DEBUG, 0},
+ { ".debug_gdb_scripts", "__debug_gdb_scri",
+ SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
+ BFD_MACH_O_S_ATTR_DEBUG, 0},
{ NULL, NULL, 0, 0, 0, 0}
};
if (xlat)
{
len = strlen (xlat->bfd_name);
- res = bfd_alloc (abfd, len+1);
+ res = bfd_alloc (abfd, len + 1);
if (res == NULL)
return;
memcpy (res, xlat->bfd_name, len+1);
seglen = dot - name;
seclen = len - (dot + 1 - name);
- if (seglen < 16 && seclen < 16)
+ if (seglen <= BFD_MACH_O_SEGNAME_SIZE
+ && seclen <= BFD_MACH_O_SECTNAME_SIZE)
{
memcpy (section->segname, name, seglen);
section->segname[seglen] = 0;
return sec->size / elsz;
}
+/* Append command CMD to ABFD. Note that header.ncmds is not updated. */
+
+static void
+bfd_mach_o_append_command (bfd *abfd, bfd_mach_o_load_command *cmd)
+{
+ bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
+
+ if (mdata->last_command != NULL)
+ mdata->last_command->next = cmd;
+ else
+ mdata->first_command = cmd;
+ mdata->last_command = cmd;
+ cmd->next = NULL;
+}
/* Copy any private info we understand from the input symbol
to the output symbol. */
asymbol *osymbol)
{
bfd_mach_o_asymbol *os, *is;
+
os = (bfd_mach_o_asymbol *)osymbol;
is = (bfd_mach_o_asymbol *)isymbol;
os->n_type = is->n_type;
os->n_sect = is->n_sect;
os->n_desc = is->n_desc;
os->symbol.udata.i = is->symbol.udata.i;
+
return TRUE;
}
to the output section. */
bfd_boolean
-bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
- asection *isection,
- bfd *obfd ATTRIBUTE_UNUSED,
- asection *osection)
+bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd, asection *isection,
+ bfd *obfd, asection *osection)
{
- if (osection->used_by_bfd == NULL)
- osection->used_by_bfd = isection->used_by_bfd;
- else
- if (isection->used_by_bfd != NULL)
- memcpy (osection->used_by_bfd, isection->used_by_bfd,
- sizeof (bfd_mach_o_section));
+ bfd_mach_o_section *os = bfd_mach_o_get_mach_o_section (osection);
+ bfd_mach_o_section *is = bfd_mach_o_get_mach_o_section (isection);
+
+ if (ibfd->xvec->flavour != bfd_target_mach_o_flavour
+ || obfd->xvec->flavour != bfd_target_mach_o_flavour)
+ return TRUE;
- if (osection->used_by_bfd != NULL)
- ((bfd_mach_o_section *)osection->used_by_bfd)->bfdsection = osection;
+ BFD_ASSERT (is != NULL && os != NULL);
+
+ os->flags = is->flags;
+ os->reserved1 = is->reserved1;
+ os->reserved2 = is->reserved2;
+ os->reserved3 = is->reserved3;
return TRUE;
}
to the output bfd. */
bfd_boolean
-bfd_mach_o_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
+bfd_mach_o_bfd_copy_private_header_data (bfd *ibfd, bfd *obfd)
{
+ bfd_mach_o_data_struct *imdata;
+ bfd_mach_o_data_struct *omdata;
+ bfd_mach_o_load_command *icmd;
+
if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour
|| bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)
return TRUE;
BFD_ASSERT (bfd_mach_o_valid (ibfd));
BFD_ASSERT (bfd_mach_o_valid (obfd));
- /* FIXME: copy commands. */
+ imdata = bfd_mach_o_get_data (ibfd);
+ omdata = bfd_mach_o_get_data (obfd);
+
+ /* Copy header flags. */
+ omdata->header.flags = imdata->header.flags;
+
+ /* Copy commands. */
+ for (icmd = imdata->first_command; icmd != NULL; icmd = icmd->next)
+ {
+ bfd_mach_o_load_command *ocmd;
+
+ switch (icmd->type)
+ {
+ case BFD_MACH_O_LC_LOAD_DYLIB:
+ case BFD_MACH_O_LC_LOAD_DYLINKER:
+ case BFD_MACH_O_LC_DYLD_INFO:
+ /* Command is copied. */
+ ocmd = bfd_alloc (obfd, sizeof (bfd_mach_o_load_command));
+ if (ocmd == NULL)
+ return FALSE;
+
+ /* Copy common fields. */
+ ocmd->type = icmd->type;
+ ocmd->type_required = icmd->type_required;
+ ocmd->offset = 0;
+ ocmd->len = icmd->len;
+ break;
+
+ default:
+ /* Command is not copied. */
+ continue;
+ break;
+ }
+
+ switch (icmd->type)
+ {
+ case BFD_MACH_O_LC_LOAD_DYLIB:
+ {
+ bfd_mach_o_dylib_command *idy = &icmd->command.dylib;
+ bfd_mach_o_dylib_command *ody = &ocmd->command.dylib;
+
+ ody->name_offset = idy->name_offset;
+ ody->timestamp = idy->timestamp;
+ ody->current_version = idy->current_version;
+ ody->compatibility_version = idy->compatibility_version;
+ ody->name_str = idy->name_str;
+ }
+ break;
+
+ case BFD_MACH_O_LC_LOAD_DYLINKER:
+ {
+ bfd_mach_o_dylinker_command *idy = &icmd->command.dylinker;
+ bfd_mach_o_dylinker_command *ody = &ocmd->command.dylinker;
+
+ ody->name_offset = idy->name_offset;
+ ody->name_str = idy->name_str;
+ }
+ break;
+
+ case BFD_MACH_O_LC_DYLD_INFO:
+ {
+ bfd_mach_o_dyld_info_command *idy = &icmd->command.dyld_info;
+ bfd_mach_o_dyld_info_command *ody = &ocmd->command.dyld_info;
+
+ if (bfd_mach_o_read_dyld_content (ibfd, idy))
+ {
+ ody->rebase_size = idy->rebase_size;
+ ody->rebase_content = idy->rebase_content;
+
+ ody->bind_size = idy->bind_size;
+ ody->bind_content = idy->bind_content;
+
+ ody->weak_bind_size = idy->weak_bind_size;
+ ody->weak_bind_content = idy->weak_bind_content;
+
+ ody->lazy_bind_size = idy->lazy_bind_size;
+ ody->lazy_bind_content = idy->lazy_bind_content;
+
+ ody->export_size = idy->export_size;
+ ody->export_content = idy->export_content;
+ }
+ /* PR 17512L: file: 730e492d. */
+ else
+ {
+ ody->rebase_size =
+ ody->bind_size =
+ ody->weak_bind_size =
+ ody->lazy_bind_size =
+ ody->export_size = 0;
+ ody->rebase_content =
+ ody->bind_content =
+ ody->weak_bind_content =
+ ody->lazy_bind_content =
+ ody->export_content = NULL;
+ }
+ }
+ break;
+
+ default:
+ /* That command should be handled. */
+ abort ();
+ }
+
+ /* Insert command. */
+ bfd_mach_o_append_command (obfd, ocmd);
+ }
return TRUE;
}
if (!bfd_mach_o_read_symtab_symbols (abfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
return 0;
}
bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
bfd_mach_o_symtab_command *symtab = mdata->symtab;
asymbol *s;
+ char * s_start;
+ char * s_end;
unsigned long count, i, j, n;
size_t size;
char *names;
char *nul_name;
+ const char stub [] = "$stub";
*ret = NULL;
/* Stop now if no symbols or no indirect symbols. */
- if (dysymtab == NULL || symtab == NULL || symtab->symbols == NULL)
- return 0;
-
- if (dysymtab->nindirectsyms == 0)
+ if (dysymtab == NULL || dysymtab->nindirectsyms == 0
+ || symtab == NULL || symtab->symbols == NULL)
return 0;
/* We need to allocate a bfd symbol for every indirect symbol and to
for (j = 0; j < count; j++)
{
+ const char * strng;
unsigned int isym = dysymtab->indirect_syms[j];
/* Some indirect symbols are anonymous. */
- if (isym < symtab->nsyms && symtab->symbols[isym].symbol.name)
- size += strlen (symtab->symbols[isym].symbol.name) + sizeof ("$stub");
+ if (isym < symtab->nsyms && (strng = symtab->symbols[isym].symbol.name))
+ /* PR 17512: file: f5b8eeba. */
+ size += strnlen (strng, symtab->strsize - (strng - symtab->strtab)) + sizeof (stub);
}
- s = *ret = (asymbol *) bfd_malloc (size);
+ s_start = bfd_malloc (size);
+ s = *ret = (asymbol *) s_start;
if (s == NULL)
return -1;
names = (char *) (s + count);
nul_name = names;
*names++ = 0;
+ s_end = s_start + size;
n = 0;
for (i = 0; i < mdata->nsects; i++)
last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
addr = sec->addr;
entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
+
+ /* PR 17512: file: 08e15eec. */
+ if (first >= count || last >= count || first > last)
+ goto fail;
+
for (j = first; j < last; j++)
{
unsigned int isym = dysymtab->indirect_syms[j];
+ /* PR 17512: file: 04d64d9b. */
+ if (((char *) s) + sizeof (* s) > s_end)
+ goto fail;
+
s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
s->section = sec->bfdsection;
s->value = addr - sec->addr;
s->name = names;
len = strlen (sym);
+ /* PR 17512: file: 47dfd4d2. */
+ if (names + len >= s_end)
+ goto fail;
memcpy (names, sym, len);
names += len;
- memcpy (names, "$stub", sizeof ("$stub"));
- names += sizeof ("$stub");
+ /* PR 17512: file: 18f340a4. */
+ if (names + sizeof (stub) >= s_end)
+ goto fail;
+ memcpy (names, stub, sizeof (stub));
+ names += sizeof (stub);
}
else
s->name = nul_name;
}
return n;
+
+ fail:
+ free (s_start);
+ * ret = NULL;
+ return -1;
}
void
*type = bfd_arch_powerpc;
*subtype = bfd_mach_ppc64;
break;
+ case BFD_MACH_O_CPU_TYPE_ARM64:
+ *type = bfd_arch_aarch64;
+ *subtype = bfd_mach_aarch64;
+ break;
default:
*type = bfd_arch_unknown;
break;
}
}
+/* Write n NUL bytes to ABFD so that LEN + n is a multiple of 4. Return the
+ number of bytes written or -1 in case of error. */
+
+static int
+bfd_mach_o_pad4 (bfd *abfd, unsigned int len)
+{
+ if (len % 4 != 0)
+ {
+ char pad[4] = {0,0,0,0};
+ unsigned int padlen = 4 - (len % 4);
+
+ if (bfd_bwrite (pad, padlen, abfd) != padlen)
+ return -1;
+
+ return padlen;
+ }
+ else
+ return 0;
+}
+
+/* Likewise, but for a command. */
+
+static int
+bfd_mach_o_pad_command (bfd *abfd, unsigned int len)
+{
+ unsigned int align = bfd_mach_o_wide_p (abfd) ? 8 : 4;
+
+ if (len % align != 0)
+ {
+ char pad[8] = {0};
+ unsigned int padlen = align - (len % align);
+
+ if (bfd_bwrite (pad, padlen, abfd) != padlen)
+ return -1;
+
+ return padlen;
+ }
+ else
+ return 0;
+}
+
static bfd_boolean
bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
{
return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_thread_command *cmd = &command->command.thread;
BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
|| (command->type == BFD_MACH_O_LC_UNIXTHREAD));
- offset = 8;
+ offset = BFD_MACH_O_LC_SIZE;
for (i = 0; i < cmd->nflavours; i++)
{
BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
|| bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ return FALSE;
offset += cmd->flavours[i].size + sizeof (raw);
}
- return 0;
+ return TRUE;
+}
+
+static bfd_boolean
+bfd_mach_o_write_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
+{
+ bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
+ struct mach_o_str_command_external raw;
+ unsigned int namelen;
+
+ bfd_h_put_32 (abfd, cmd->name_offset, raw.str);
+
+ if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
+ || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
+
+ namelen = strlen (cmd->name_str) + 1;
+ if (bfd_bwrite (cmd->name_str, namelen, abfd) != namelen)
+ return FALSE;
+
+ if (bfd_mach_o_pad_command (abfd, namelen) < 0)
+ return FALSE;
+
+ return TRUE;
+}
+
+static bfd_boolean
+bfd_mach_o_write_dylib (bfd *abfd, bfd_mach_o_load_command *command)
+{
+ bfd_mach_o_dylib_command *cmd = &command->command.dylib;
+ struct mach_o_dylib_command_external raw;
+ unsigned int namelen;
+
+ bfd_h_put_32 (abfd, cmd->name_offset, raw.name);
+ bfd_h_put_32 (abfd, cmd->timestamp, raw.timestamp);
+ bfd_h_put_32 (abfd, cmd->current_version, raw.current_version);
+ bfd_h_put_32 (abfd, cmd->compatibility_version, raw.compatibility_version);
+
+ if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
+ || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
+
+ namelen = strlen (cmd->name_str) + 1;
+ if (bfd_bwrite (cmd->name_str, namelen, abfd) != namelen)
+ return FALSE;
+
+ if (bfd_mach_o_pad_command (abfd, namelen) < 0)
+ return FALSE;
+
+ return TRUE;
+}
+
+static bfd_boolean
+bfd_mach_o_write_main (bfd *abfd, bfd_mach_o_load_command *command)
+{
+ bfd_mach_o_main_command *cmd = &command->command.main;
+ struct mach_o_entry_point_command_external raw;
+
+ bfd_h_put_64 (abfd, cmd->entryoff, raw.entryoff);
+ bfd_h_put_64 (abfd, cmd->stacksize, raw.stacksize);
+
+ if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
+ || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
+
+ return TRUE;
+}
+
+static bfd_boolean
+bfd_mach_o_write_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
+{
+ bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
+ struct mach_o_dyld_info_command_external raw;
+
+ bfd_h_put_32 (abfd, cmd->rebase_off, raw.rebase_off);
+ bfd_h_put_32 (abfd, cmd->rebase_size, raw.rebase_size);
+ bfd_h_put_32 (abfd, cmd->bind_off, raw.bind_off);
+ bfd_h_put_32 (abfd, cmd->bind_size, raw.bind_size);
+ bfd_h_put_32 (abfd, cmd->weak_bind_off, raw.weak_bind_off);
+ bfd_h_put_32 (abfd, cmd->weak_bind_size, raw.weak_bind_size);
+ bfd_h_put_32 (abfd, cmd->lazy_bind_off, raw.lazy_bind_off);
+ bfd_h_put_32 (abfd, cmd->lazy_bind_size, raw.lazy_bind_size);
+ bfd_h_put_32 (abfd, cmd->export_off, raw.export_off);
+ bfd_h_put_32 (abfd, cmd->export_size, raw.export_size);
+
+ if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
+ || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
+
+ if (cmd->rebase_size != 0)
+ if (bfd_seek (abfd, cmd->rebase_off, SEEK_SET) != 0
+ || (bfd_bwrite (cmd->rebase_content, cmd->rebase_size, abfd) !=
+ cmd->rebase_size))
+ return FALSE;
+
+ if (cmd->bind_size != 0)
+ if (bfd_seek (abfd, cmd->bind_off, SEEK_SET) != 0
+ || (bfd_bwrite (cmd->bind_content, cmd->bind_size, abfd) !=
+ cmd->bind_size))
+ return FALSE;
+
+ if (cmd->weak_bind_size != 0)
+ if (bfd_seek (abfd, cmd->weak_bind_off, SEEK_SET) != 0
+ || (bfd_bwrite (cmd->weak_bind_content, cmd->weak_bind_size, abfd) !=
+ cmd->weak_bind_size))
+ return FALSE;
+
+ if (cmd->lazy_bind_size != 0)
+ if (bfd_seek (abfd, cmd->lazy_bind_off, SEEK_SET) != 0
+ || (bfd_bwrite (cmd->lazy_bind_content, cmd->lazy_bind_size, abfd) !=
+ cmd->lazy_bind_size))
+ return FALSE;
+
+ if (cmd->export_size != 0)
+ if (bfd_seek (abfd, cmd->export_off, SEEK_SET) != 0
+ || (bfd_bwrite (cmd->export_content, cmd->export_size, abfd) !=
+ cmd->export_size))
+ return FALSE;
+
+ return TRUE;
}
long
/* In addition to the need to byte-swap the symbol number, the bit positions
of the fields in the relocation information vary per target endian-ness. */
-static void
+void
bfd_mach_o_swap_in_non_scattered_reloc (bfd *abfd, bfd_mach_o_reloc_info *rel,
unsigned char *fields)
{
}
}
-static int
-bfd_mach_o_canonicalize_one_reloc (bfd *abfd,
- struct mach_o_reloc_info_external *raw,
- arelent *res, asymbol **syms)
+/* Set syms_ptr_ptr and addend of RES. */
+
+bfd_boolean
+bfd_mach_o_canonicalize_non_scattered_reloc (bfd *abfd,
+ bfd_mach_o_reloc_info *reloc,
+ arelent *res, asymbol **syms)
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
- bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
- bfd_mach_o_reloc_info reloc;
- bfd_vma addr;
+ unsigned int num;
asymbol **sym;
+ /* Non-scattered relocation. */
+ reloc->r_scattered = 0;
+ res->addend = 0;
+
+ num = reloc->r_value;
+
+ if (reloc->r_extern)
+ {
+ /* PR 17512: file: 8396-1185-0.004. */
+ if (num >= (unsigned) bfd_mach_o_count_symbols (abfd))
+ sym = bfd_und_section_ptr->symbol_ptr_ptr;
+ else if (syms == NULL)
+ sym = bfd_und_section_ptr->symbol_ptr_ptr;
+ else
+ /* An external symbol number. */
+ sym = syms + num;
+ }
+ else if (num == 0x00ffffff || num == 0)
+ {
+ /* The 'symnum' in a non-scattered PAIR is 0x00ffffff. But as this
+ is generic code, we don't know wether this is really a PAIR.
+ This value is almost certainly not a valid section number, hence
+ this specific case to avoid an assertion failure.
+ Target specific swap_reloc_in routine should adjust that. */
+ sym = bfd_abs_section_ptr->symbol_ptr_ptr;
+ }
+ else
+ {
+ /* PR 17512: file: 006-2964-0.004. */
+ if (num > mdata->nsects)
+ return FALSE;
+
+ /* A section number. */
+ sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
+ /* For a symbol defined in section S, the addend (stored in the
+ binary) contains the address of the section. To comply with
+ bfd convention, subtract the section address.
+ Use the address from the header, so that the user can modify
+ the vma of the section. */
+ res->addend = -mdata->sections[num - 1]->addr;
+ }
+
+ /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
+ in the lower 16bits of the address value. So we have to find the
+ 'symbol' from the preceding reloc. We do this even though the
+ section symbol is probably not needed here, because NULL symbol
+ values cause an assert in generic BFD code. This must be done in
+ the PPC swap_reloc_in routine. */
+ res->sym_ptr_ptr = sym;
+
+ return TRUE;
+}
+
+/* Do most of the work for canonicalize_relocs on RAW: create internal
+ representation RELOC and set most fields of RES using symbol table SYMS.
+ Each target still has to set the howto of RES and possibly adjust other
+ fields.
+ Previously the Mach-O hook point was simply swap_in, but some targets
+ (like arm64) don't follow the generic rules (symnum is a value for the
+ non-scattered relocation ADDEND). */
+
+bfd_boolean
+bfd_mach_o_pre_canonicalize_one_reloc (bfd *abfd,
+ struct mach_o_reloc_info_external *raw,
+ bfd_mach_o_reloc_info *reloc,
+ arelent *res, asymbol **syms)
+{
+ bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
+ bfd_vma addr;
+
addr = bfd_get_32 (abfd, raw->r_address);
res->sym_ptr_ptr = NULL;
res->addend = 0;
bfd_vma symnum = bfd_get_32 (abfd, raw->r_symbolnum);
/* Scattered relocation, can't be extern. */
- reloc.r_scattered = 1;
- reloc.r_extern = 0;
+ reloc->r_scattered = 1;
+ reloc->r_extern = 0;
/* Extract section and offset from r_value (symnum). */
- reloc.r_value = symnum;
+ reloc->r_value = symnum;
/* FIXME: This breaks when a symbol in a reloc exactly follows the
end of the data for the section (e.g. in a calculation of section
data length). At present, the symbol will end up associated with
}
/* Extract the info and address fields from r_address. */
- reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr);
- reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
- reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL;
- reloc.r_address = BFD_MACH_O_GET_SR_TYPE (addr);
+ reloc->r_type = BFD_MACH_O_GET_SR_TYPE (addr);
+ reloc->r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
+ reloc->r_pcrel = addr & BFD_MACH_O_SR_PCREL;
+ reloc->r_address = BFD_MACH_O_GET_SR_TYPE (addr);
res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
}
else
{
- unsigned int num;
-
/* Non-scattered relocation. */
- reloc.r_scattered = 0;
+ reloc->r_scattered = 0;
+ reloc->r_address = addr;
+ res->address = addr;
/* The value and info fields have to be extracted dependent on target
endian-ness. */
- bfd_mach_o_swap_in_non_scattered_reloc (abfd, &reloc, raw->r_symbolnum);
- num = reloc.r_value;
+ bfd_mach_o_swap_in_non_scattered_reloc (abfd, reloc, raw->r_symbolnum);
- if (reloc.r_extern)
- {
- /* An external symbol number. */
- sym = syms + num;
- }
- else if (num == 0x00ffffff)
- {
- /* The 'symnum' in a non-scattered PAIR is 0x00ffffff. But as this
- is generic code, we don't know wether this is really a PAIR.
- This value is almost certainly not a valid section number, hence
- this specific case to avoid an assertion failure.
- Target specific swap_reloc_in routine should adjust that. */
- sym = bfd_abs_section_ptr->symbol_ptr_ptr;
- }
- else
- {
- /* A section number. */
- BFD_ASSERT (num != 0);
- BFD_ASSERT (num <= mdata->nsects);
-
- sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
- /* For a symbol defined in section S, the addend (stored in the
- binary) contains the address of the section. To comply with
- bfd convention, subtract the section address.
- Use the address from the header, so that the user can modify
- the vma of the section. */
- res->addend = -mdata->sections[num - 1]->addr;
- }
- /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
- in the lower 16bits of the address value. So we have to find the
- 'symbol' from the preceding reloc. We do this even though the
- section symbol is probably not needed here, because NULL symbol
- values cause an assert in generic BFD code. This must be done in
- the PPC swap_reloc_in routine. */
- res->sym_ptr_ptr = sym;
-
- /* The 'address' is just r_address.
- ??? maybe this should be masked with 0xffffff for safety. */
- res->address = addr;
- reloc.r_address = addr;
+ if (!bfd_mach_o_canonicalize_non_scattered_reloc (abfd, reloc,
+ res, syms))
+ return FALSE;
}
/* We have set up a reloc with all the information present, so the swapper
can modify address, value and addend fields, if necessary, to convey
information in the generic BFD reloc that is mach-o specific. */
- if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))
- return -1;
- return 0;
+ return TRUE;
}
static int
unsigned long count,
arelent *res, asymbol **syms)
{
+ bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
unsigned long i;
struct mach_o_reloc_info_external *native_relocs;
bfd_size_type native_size;
/* Allocate and read relocs. */
native_size = count * BFD_MACH_O_RELENT_SIZE;
+
+ /* PR 17512: file: 09477b57. */
+ if (native_size < count)
+ return -1;
+
native_relocs =
(struct mach_o_reloc_info_external *) bfd_malloc (native_size);
if (native_relocs == NULL)
for (i = 0; i < count; i++)
{
- if (bfd_mach_o_canonicalize_one_reloc (abfd, &native_relocs[i],
- &res[i], syms) < 0)
+ if (!(*bed->_bfd_mach_o_canonicalize_one_reloc)(abfd, &native_relocs[i],
+ &res[i], syms))
goto err;
}
free (native_relocs);
return 0;
/* No need to go further if we don't know how to read relocs. */
- if (bed->_bfd_mach_o_swap_reloc_in == NULL)
+ if (bed->_bfd_mach_o_canonicalize_one_reloc == NULL)
return 0;
if (asect->relocation == NULL)
{
+ if (asect->reloc_count * sizeof (arelent) < asect->reloc_count)
+ return -1;
res = bfd_malloc (asect->reloc_count * sizeof (arelent));
if (res == NULL)
return -1;
return 0;
/* No need to go further if we don't know how to read relocs. */
- if (bed->_bfd_mach_o_swap_reloc_in == NULL)
+ if (bed->_bfd_mach_o_canonicalize_one_reloc == NULL)
return 0;
if (mdata->dyn_reloc_cache == NULL)
{
+ if ((dysymtab->nextrel + dysymtab->nlocrel) * sizeof (arelent)
+ < (dysymtab->nextrel + dysymtab->nlocrel))
+ return -1;
+
res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel)
* sizeof (arelent));
if (res == NULL)
v = BFD_MACH_O_SR_SCATTERED
| (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
- | BFD_MACH_O_SET_SR_LENGTH(pinfo->r_length)
- | BFD_MACH_O_SET_SR_TYPE(pinfo->r_type)
- | BFD_MACH_O_SET_SR_ADDRESS(pinfo->r_address);
+ | BFD_MACH_O_SET_SR_LENGTH (pinfo->r_length)
+ | BFD_MACH_O_SET_SR_TYPE (pinfo->r_type)
+ | BFD_MACH_O_SET_SR_ADDRESS (pinfo->r_address);
/* Note: scattered relocs have field in reverse order... */
bfd_put_32 (abfd, v, raw.r_address);
bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
{
struct mach_o_section_32_external raw;
if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
!= BFD_MACH_O_SECTION_SIZE)
- return -1;
+ return FALSE;
- return 0;
+ return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
{
struct mach_o_section_64_external raw;
if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
!= BFD_MACH_O_SECTION_64_SIZE)
- return -1;
+ return FALSE;
- return 0;
+ return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
{
struct mach_o_segment_command_32_external raw;
for (sec = seg->sect_head; sec != NULL; sec = sec->next)
if (!bfd_mach_o_write_relocs (abfd, sec))
- return -1;
+ return FALSE;
memcpy (raw.segname, seg->segname, 16);
bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
|| bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ return FALSE;
for (sec = seg->sect_head; sec != NULL; sec = sec->next)
- if (bfd_mach_o_write_section_32 (abfd, sec))
- return -1;
+ if (!bfd_mach_o_write_section_32 (abfd, sec))
+ return FALSE;
- return 0;
+ return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
{
struct mach_o_segment_command_64_external raw;
for (sec = seg->sect_head; sec != NULL; sec = sec->next)
if (!bfd_mach_o_write_relocs (abfd, sec))
- return -1;
+ return FALSE;
memcpy (raw.segname, seg->segname, 16);
bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
|| bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ return FALSE;
for (sec = seg->sect_head; sec != NULL; sec = sec->next)
- if (bfd_mach_o_write_section_64 (abfd, sec))
- return -1;
+ if (!bfd_mach_o_write_section_64 (abfd, sec))
+ return FALSE;
- return 0;
+ return TRUE;
}
static bfd_boolean
-bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_write_symtab_content (bfd *abfd, bfd_mach_o_symtab_command *sym)
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
- bfd_mach_o_symtab_command *sym = &command->command.symtab;
unsigned long i;
unsigned int wide = bfd_mach_o_wide_p (abfd);
- unsigned int symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
struct bfd_strtab_hash *strtab;
asymbol **symbols = bfd_get_outsymbols (abfd);
-
- BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
+ int padlen;
/* Write the symbols first. */
- mdata->filelen = FILE_ALIGN(mdata->filelen, wide ? 3 : 2);
- sym->symoff = mdata->filelen;
if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
return FALSE;
- sym->nsyms = bfd_get_symcount (abfd);
- mdata->filelen += sym->nsyms * symlen;
-
strtab = _bfd_stringtab_init ();
if (strtab == NULL)
return FALSE;
sym->stroff = mdata->filelen;
mdata->filelen += sym->strsize;
- if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
+ if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0)
goto err;
- _bfd_stringtab_free (strtab);
- /* The command. */
- {
- struct mach_o_symtab_command_external raw;
-
- bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
- bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
- bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
- bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
+ if (!_bfd_stringtab_emit (abfd, strtab))
+ goto err;
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
- return FALSE;
- }
+ /* Pad string table. */
+ padlen = bfd_mach_o_pad4 (abfd, sym->strsize);
+ if (padlen < 0)
+ return FALSE;
+ mdata->filelen += padlen;
+ sym->strsize += padlen;
return TRUE;
err:
_bfd_stringtab_free (strtab);
+ sym->strsize = 0;
return FALSE;
}
+static bfd_boolean
+bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
+{
+ bfd_mach_o_symtab_command *sym = &command->command.symtab;
+ struct mach_o_symtab_command_external raw;
+
+ BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
+
+ /* The command. */
+ bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
+ bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
+ bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
+ bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
+
+ if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
+ || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
+
+ return TRUE;
+}
+
+/* Count the number of indirect symbols in the image.
+ Requires that the sections are in their final order. */
+
+static unsigned int
+bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
+{
+ unsigned int i;
+ unsigned int nisyms = 0;
+
+ for (i = 0; i < mdata->nsects; ++i)
+ {
+ bfd_mach_o_section *sec = mdata->sections[i];
+
+ switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
+ {
+ case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
+ case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
+ case BFD_MACH_O_S_SYMBOL_STUBS:
+ nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
+ break;
+ default:
+ break;
+ }
+ }
+ return nisyms;
+}
+
+/* Create the dysymtab. */
+
+static bfd_boolean
+bfd_mach_o_build_dysymtab (bfd *abfd, bfd_mach_o_dysymtab_command *cmd)
+{
+ bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
+
+ /* TODO:
+ We are not going to try and fill these in yet and, moreover, we are
+ going to bail if they are already set. */
+ if (cmd->nmodtab != 0
+ || cmd->ntoc != 0
+ || cmd->nextrefsyms != 0)
+ {
+ _bfd_error_handler (_("sorry: modtab, toc and extrefsyms are not yet"
+ " implemented for dysymtab commands."));
+ return FALSE;
+ }
+
+ cmd->ilocalsym = 0;
+
+ if (bfd_get_symcount (abfd) > 0)
+ {
+ asymbol **symbols = bfd_get_outsymbols (abfd);
+ unsigned long i;
+
+ /* Count the number of each kind of symbol. */
+ for (i = 0; i < bfd_get_symcount (abfd); ++i)
+ {
+ bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
+ if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
+ break;
+ }
+ cmd->nlocalsym = i;
+ cmd->iextdefsym = i;
+ for (; i < bfd_get_symcount (abfd); ++i)
+ {
+ bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
+ if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
+ break;
+ }
+ cmd->nextdefsym = i - cmd->nlocalsym;
+ cmd->iundefsym = cmd->nextdefsym + cmd->iextdefsym;
+ cmd->nundefsym = bfd_get_symcount (abfd)
+ - cmd->nlocalsym
+ - cmd->nextdefsym;
+ }
+ else
+ {
+ cmd->nlocalsym = 0;
+ cmd->iextdefsym = 0;
+ cmd->nextdefsym = 0;
+ cmd->iundefsym = 0;
+ cmd->nundefsym = 0;
+ }
+
+ cmd->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
+ if (cmd->nindirectsyms > 0)
+ {
+ unsigned i;
+ unsigned n;
+
+ mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
+ cmd->indirectsymoff = mdata->filelen;
+ mdata->filelen += cmd->nindirectsyms * 4;
+
+ if (cmd->nindirectsyms * 4 < cmd->nindirectsyms)
+ return FALSE;
+ cmd->indirect_syms = bfd_zalloc (abfd, cmd->nindirectsyms * 4);
+ if (cmd->indirect_syms == NULL)
+ return FALSE;
+
+ n = 0;
+ for (i = 0; i < mdata->nsects; ++i)
+ {
+ bfd_mach_o_section *sec = mdata->sections[i];
+
+ switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
+ {
+ case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
+ case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
+ case BFD_MACH_O_S_SYMBOL_STUBS:
+ {
+ unsigned j, num;
+ bfd_mach_o_asymbol **isyms = sec->indirect_syms;
+
+ num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
+ if (isyms == NULL || num == 0)
+ break;
+ /* Record the starting index in the reserved1 field. */
+ sec->reserved1 = n;
+ for (j = 0; j < num; j++, n++)
+ {
+ if (isyms[j] == NULL)
+ cmd->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
+ else if (isyms[j]->symbol.section == bfd_abs_section_ptr
+ && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
+ cmd->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
+ | BFD_MACH_O_INDIRECT_SYM_ABS;
+ else
+ cmd->indirect_syms[n] = isyms[j]->symbol.udata.i;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ return TRUE;
+}
+
/* Write a dysymtab command.
TODO: Possibly coalesce writes of smaller objects. */
&& s->symbol.section != bfd_com_section_ptr)
|| ((s->n_type & BFD_MACH_O_N_STAB) != 0
&& s->symbol.name == NULL))
- s->n_sect = s->symbol.section->target_index;
+ s->n_sect = s->symbol.section->output_section->target_index;
/* Number to preserve order for local and debug syms. */
s->symbol.udata.i = i;
&& (mdata->nsects == 0 || mdata->sections != NULL))
return TRUE;
+ /* We need to check that this can be done... */
+ if (nsect > 255)
+ {
+ _bfd_error_handler (_("mach-o: there are too many sections (%u)"
+ " maximum is 255,\n"), nsect);
+ return FALSE;
+ }
+
mdata->nsects = nsect;
- mdata->sections = bfd_alloc (abfd,
- mdata->nsects * sizeof (bfd_mach_o_section *));
+ mdata->sections = bfd_alloc2 (abfd,
+ mdata->nsects, sizeof (bfd_mach_o_section *));
if (mdata->sections == NULL)
return FALSE;
- /* We need to check that this can be done... */
- if (nsect > 255)
- (*_bfd_error_handler) (_("mach-o: there are too many sections (%d)"
- " maximum is 255,\n"), nsect);
-
/* Create Mach-O sections.
Section type, attribute and align should have been set when the
section was created - either read in or specified. */
bfd_boolean
bfd_mach_o_write_contents (bfd *abfd)
{
- unsigned int i;
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
+ bfd_mach_o_load_command *cmd;
+ bfd_mach_o_symtab_command *symtab = NULL;
+ bfd_mach_o_dysymtab_command *dysymtab = NULL;
+ bfd_mach_o_segment_command *linkedit = NULL;
/* Make the commands, if not already present. */
- if (mdata->header.ncmds == 0)
- if (!bfd_mach_o_build_commands (abfd))
- return FALSE;
+ if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
+ return FALSE;
+ abfd->output_has_begun = TRUE;
+ /* Write the header. */
if (!bfd_mach_o_write_header (abfd, &mdata->header))
return FALSE;
- for (i = 0; i < mdata->header.ncmds; i++)
+ /* First pass: allocate the linkedit segment. */
+ for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
+ switch (cmd->type)
+ {
+ case BFD_MACH_O_LC_SEGMENT_64:
+ case BFD_MACH_O_LC_SEGMENT:
+ if (strcmp (cmd->command.segment.segname, "__LINKEDIT") == 0)
+ linkedit = &cmd->command.segment;
+ break;
+ case BFD_MACH_O_LC_SYMTAB:
+ symtab = &cmd->command.symtab;
+ break;
+ case BFD_MACH_O_LC_DYSYMTAB:
+ dysymtab = &cmd->command.dysymtab;
+ break;
+ case BFD_MACH_O_LC_DYLD_INFO:
+ {
+ bfd_mach_o_dyld_info_command *di = &cmd->command.dyld_info;
+
+ if (di->rebase_size != 0)
+ {
+ di->rebase_off = mdata->filelen;
+ mdata->filelen += di->rebase_size;
+ }
+ if (di->bind_size != 0)
+ {
+ di->bind_off = mdata->filelen;
+ mdata->filelen += di->bind_size;
+ }
+ if (di->weak_bind_size != 0)
+ {
+ di->weak_bind_off = mdata->filelen;
+ mdata->filelen += di->weak_bind_size;
+ }
+ if (di->lazy_bind_size != 0)
+ {
+ di->lazy_bind_off = mdata->filelen;
+ mdata->filelen += di->lazy_bind_size;
+ }
+ if (di->export_size != 0)
+ {
+ di->export_off = mdata->filelen;
+ mdata->filelen += di->export_size;
+ }
+ }
+ break;
+ case BFD_MACH_O_LC_LOAD_DYLIB:
+ case BFD_MACH_O_LC_LOAD_DYLINKER:
+ case BFD_MACH_O_LC_MAIN:
+ /* Nothing to do. */
+ break;
+ default:
+ _bfd_error_handler
+ (_("unable to allocate data for load command 0x%lx"),
+ (unsigned long) cmd->type);
+ break;
+ }
+
+ /* Specially handle symtab and dysymtab. */
+
+ /* Pre-allocate the symbol table (but not the string table). The reason
+ is that the dysymtab is after the symbol table but before the string
+ table (required by the native strip tool). */
+ if (symtab != NULL)
+ {
+ unsigned int symlen;
+ unsigned int wide = bfd_mach_o_wide_p (abfd);
+
+ symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
+
+ /* Align for symbols. */
+ mdata->filelen = FILE_ALIGN (mdata->filelen, wide ? 3 : 2);
+ symtab->symoff = mdata->filelen;
+
+ symtab->nsyms = bfd_get_symcount (abfd);
+ mdata->filelen += symtab->nsyms * symlen;
+ }
+
+ /* Build the dysymtab. */
+ if (dysymtab != NULL)
+ if (!bfd_mach_o_build_dysymtab (abfd, dysymtab))
+ return FALSE;
+
+ /* Write symtab and strtab. */
+ if (symtab != NULL)
+ if (!bfd_mach_o_write_symtab_content (abfd, symtab))
+ return FALSE;
+
+ /* Adjust linkedit size. */
+ if (linkedit != NULL)
+ {
+ /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
+
+ linkedit->vmsize = mdata->filelen - linkedit->fileoff;
+ /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
+ linkedit->filesize = mdata->filelen - linkedit->fileoff;
+
+ linkedit->initprot = BFD_MACH_O_PROT_READ;
+ linkedit->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
+ | BFD_MACH_O_PROT_EXECUTE;
+ }
+
+ /* Second pass: write commands. */
+ for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
{
struct mach_o_load_command_external raw;
- bfd_mach_o_load_command *cur = &mdata->commands[i];
unsigned long typeflag;
- typeflag = cur->type | (cur->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
+ typeflag = cmd->type | (cmd->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
bfd_h_put_32 (abfd, typeflag, raw.cmd);
- bfd_h_put_32 (abfd, cur->len, raw.cmdsize);
+ bfd_h_put_32 (abfd, cmd->len, raw.cmdsize);
- if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0
+ if (bfd_seek (abfd, cmd->offset, SEEK_SET) != 0
|| bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
return FALSE;
- switch (cur->type)
+ switch (cmd->type)
{
case BFD_MACH_O_LC_SEGMENT:
- if (bfd_mach_o_write_segment_32 (abfd, cur) != 0)
+ if (!bfd_mach_o_write_segment_32 (abfd, cmd))
return FALSE;
break;
case BFD_MACH_O_LC_SEGMENT_64:
- if (bfd_mach_o_write_segment_64 (abfd, cur) != 0)
+ if (!bfd_mach_o_write_segment_64 (abfd, cmd))
return FALSE;
break;
case BFD_MACH_O_LC_SYMTAB:
- if (!bfd_mach_o_write_symtab (abfd, cur))
+ if (!bfd_mach_o_write_symtab (abfd, cmd))
return FALSE;
break;
case BFD_MACH_O_LC_DYSYMTAB:
- if (!bfd_mach_o_write_dysymtab (abfd, cur))
+ if (!bfd_mach_o_write_dysymtab (abfd, cmd))
return FALSE;
break;
- case BFD_MACH_O_LC_SYMSEG:
- break;
case BFD_MACH_O_LC_THREAD:
case BFD_MACH_O_LC_UNIXTHREAD:
- if (bfd_mach_o_write_thread (abfd, cur) != 0)
+ if (!bfd_mach_o_write_thread (abfd, cmd))
return FALSE;
break;
- case BFD_MACH_O_LC_LOADFVMLIB:
- case BFD_MACH_O_LC_IDFVMLIB:
- case BFD_MACH_O_LC_IDENT:
- case BFD_MACH_O_LC_FVMFILE:
- case BFD_MACH_O_LC_PREPAGE:
case BFD_MACH_O_LC_LOAD_DYLIB:
- case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
- case BFD_MACH_O_LC_ID_DYLIB:
- case BFD_MACH_O_LC_REEXPORT_DYLIB:
- case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
+ if (!bfd_mach_o_write_dylib (abfd, cmd))
+ return FALSE;
+ break;
case BFD_MACH_O_LC_LOAD_DYLINKER:
- case BFD_MACH_O_LC_ID_DYLINKER:
- case BFD_MACH_O_LC_PREBOUND_DYLIB:
- case BFD_MACH_O_LC_ROUTINES:
- case BFD_MACH_O_LC_SUB_FRAMEWORK:
+ if (!bfd_mach_o_write_dylinker (abfd, cmd))
+ return FALSE;
+ break;
+ case BFD_MACH_O_LC_MAIN:
+ if (!bfd_mach_o_write_main (abfd, cmd))
+ return FALSE;
+ break;
+ case BFD_MACH_O_LC_DYLD_INFO:
+ if (!bfd_mach_o_write_dyld_info (abfd, cmd))
+ return FALSE;
break;
default:
- (*_bfd_error_handler) (_("unable to write unknown load command 0x%lx"),
- (unsigned long) cur->type);
+ _bfd_error_handler
+ (_("unable to write unknown load command 0x%lx"),
+ (unsigned long) cmd->type);
return FALSE;
}
}
static void
bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
- asection *sec)
+ bfd_mach_o_section *s)
{
- bfd_mach_o_section *s = (bfd_mach_o_section *)sec->used_by_bfd;
if (seg->sect_head == NULL)
seg->sect_head = s;
else
/* Create section Mach-O flags from BFD flags. */
static void
-bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
+bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED,
+ asection *sec)
{
flagword bfd_flags;
bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
s->flags = BFD_MACH_O_S_REGULAR;
}
-/* Count the number of sections in the list for the segment named.
-
- The special case of NULL or "" for the segment name is valid for
- an MH_OBJECT file and means 'all sections available'.
-
- Requires that the sections table in mdata be filled in.
-
- Returns the number of sections (0 is valid).
- Any number > 255 signals an invalid section count, although we will,
- perhaps, allow the file to be written (in line with Darwin tools up
- to XCode 4).
-
- A section count of (unsigned long) -1 signals a definite error. */
-
-static unsigned long
-bfd_mach_o_count_sections_for_seg (const char *segment,
- bfd_mach_o_data_struct *mdata)
-{
- unsigned i,j;
- if (mdata == NULL || mdata->sections == NULL)
- return (unsigned long) -1;
-
- /* The MH_OBJECT case, all sections are considered; Although nsects is
- is an unsigned long, the maximum valid section count is 255 and this
- will have been checked already by mangle_sections. */
- if (segment == NULL || segment[0] == '\0')
- return mdata->nsects;
-
- /* Count the number of sections we see in this segment. */
- j = 0;
- for (i = 0; i < mdata->nsects; ++i)
- {
- bfd_mach_o_section *s = mdata->sections[i];
- if (strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
- j++;
- }
- return j;
-}
-
static bfd_boolean
-bfd_mach_o_build_seg_command (const char *segment,
- bfd_mach_o_data_struct *mdata,
- bfd_mach_o_segment_command *seg)
+bfd_mach_o_build_obj_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
{
- unsigned i;
- int is_mho = (segment == NULL || segment[0] == '\0');
-
- /* Fill segment command. */
- if (is_mho)
- memset (seg->segname, 0, sizeof (seg->segname));
- else
- strncpy (seg->segname, segment, sizeof (seg->segname));
+ bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
+ unsigned int i, j;
- /* TODO: fix this up for non-MH_OBJECT cases. */
seg->vmaddr = 0;
- seg->vmsize = 0;
-
seg->fileoff = mdata->filelen;
- seg->filesize = 0;
- seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
- | BFD_MACH_O_PROT_EXECUTE;
- seg->initprot = seg->maxprot;
- seg->flags = 0;
- seg->sect_head = NULL;
- seg->sect_tail = NULL;
+ seg->initprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
+ | BFD_MACH_O_PROT_EXECUTE;
+ seg->maxprot = seg->initprot;
/* Append sections to the segment.
sections after all the rest. This forces us to do the calculation of
total vmsize in three passes so that any alignment increments are
properly accounted. */
-
for (i = 0; i < mdata->nsects; ++i)
{
bfd_mach_o_section *s = mdata->sections[i];
asection *sec = s->bfdsection;
- /* If we're not making an MH_OBJECT, check whether this section is from
- our segment, and skip if not. Otherwise, just add all sections. */
- if (! is_mho
- && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
- continue;
-
/* Although we account for zerofill section sizes in vm order, they are
placed in the file in source sequence. */
- bfd_mach_o_append_section_to_segment (seg, sec);
+ bfd_mach_o_append_section_to_segment (seg, s);
s->offset = 0;
- /* Zerofill sections have zero file size & offset,
- and are not written. */
+ /* Zerofill sections have zero file size & offset, the only content
+ written to the file is the symbols. */
if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
- || (s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
- == BFD_MACH_O_S_GB_ZEROFILL)
+ || ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
+ == BFD_MACH_O_S_GB_ZEROFILL))
continue;
+ /* The Darwin system tools (in MH_OBJECT files, at least) always account
+ sections, even those with zero size. */
if (s->size > 0)
- {
+ {
seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
seg->vmsize += s->size;
- seg->filesize = FILE_ALIGN (seg->filesize, s->align);
+ /* MH_OBJECT files have unaligned content. */
+ if (1)
+ {
+ seg->filesize = FILE_ALIGN (seg->filesize, s->align);
+ mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
+ }
seg->filesize += s->size;
- mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
+ /* The system tools write even zero-sized sections with an offset
+ field set to the current file position. */
s->offset = mdata->filelen;
- }
+ }
sec->filepos = s->offset;
mdata->filelen += s->size;
}
- /* Now pass through again, for zerofill, only now we just update the vmsize. */
- for (i = 0; i < mdata->nsects; ++i)
+ /* Now pass through again, for zerofill, only now we just update the
+ vmsize, and then for zerofill_GB. */
+ for (j = 0; j < 2; j++)
{
- bfd_mach_o_section *s = mdata->sections[i];
+ unsigned int stype;
- if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL)
- continue;
-
- if (! is_mho
- && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
- continue;
+ if (j == 0)
+ stype = BFD_MACH_O_S_ZEROFILL;
+ else
+ stype = BFD_MACH_O_S_GB_ZEROFILL;
- if (s->size > 0)
+ for (i = 0; i < mdata->nsects; ++i)
{
- seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
- seg->vmsize += s->size;
- }
- }
-
- /* Now pass through again, for zerofill_GB. */
- for (i = 0; i < mdata->nsects; ++i)
- {
- bfd_mach_o_section *s = mdata->sections[i];
+ bfd_mach_o_section *s = mdata->sections[i];
- if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_GB_ZEROFILL)
- continue;
-
- if (! is_mho
- && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
- continue;
+ if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != stype)
+ continue;
- if (s->size > 0)
- {
- seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
- seg->vmsize += s->size;
+ if (s->size > 0)
+ {
+ seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
+ seg->vmsize += s->size;
+ }
}
}
/* Allocate space for the relocations. */
- mdata->filelen = FILE_ALIGN(mdata->filelen, 2);
+ mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
for (i = 0; i < mdata->nsects; ++i)
{
bfd_mach_o_section *ms = mdata->sections[i];
asection *sec = ms->bfdsection;
- if ((ms->nreloc = sec->reloc_count) == 0)
+ ms->nreloc = sec->reloc_count;
+ if (ms->nreloc == 0)
{
+ /* Clear nreloc and reloff if there is no relocs. */
ms->reloff = 0;
continue;
}
return TRUE;
}
-/* Count the number of indirect symbols in the image.
- Requires that the sections are in their final order. */
-
-static unsigned int
-bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
+static bfd_boolean
+bfd_mach_o_build_exec_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
{
+ bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
unsigned int i;
- unsigned int nisyms = 0;
+ bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1;
+ bfd_vma vma;
+ bfd_mach_o_section *s;
+ seg->vmsize = 0;
+
+ seg->fileoff = mdata->filelen;
+ seg->maxprot = 0;
+ seg->initprot = 0;
+ seg->flags = 0;
+
+ /* Append sections to the segment. We assume they are properly ordered
+ by vma (but we check that). */
+ vma = 0;
for (i = 0; i < mdata->nsects; ++i)
{
- bfd_mach_o_section *sec = mdata->sections[i];
+ s = mdata->sections[i];
- switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
+ /* Consider only sections for this segment. */
+ if (strcmp (seg->segname, s->segname) != 0)
+ continue;
+
+ bfd_mach_o_append_section_to_segment (seg, s);
+
+ if (s->addr < vma)
{
- case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
- case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
- case BFD_MACH_O_S_SYMBOL_STUBS:
- nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
- break;
- default:
- break;
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("section address (%lx) below start of segment (%lx)"),
+ (unsigned long) s->addr, (unsigned long) vma);
+ return FALSE;
+ }
+
+ vma = s->addr + s->size;
+ }
+
+ /* Set segment file offset: make it page aligned. */
+ vma = seg->sect_head->addr;
+ seg->vmaddr = vma & ~pagemask;
+ if ((mdata->filelen & pagemask) > (vma & pagemask))
+ mdata->filelen += pagemask + 1;
+ seg->fileoff = mdata->filelen & ~pagemask;
+ mdata->filelen = seg->fileoff + (vma & pagemask);
+
+ /* Set section file offset. */
+ for (s = seg->sect_head; s != NULL; s = s->next)
+ {
+ asection *sec = s->bfdsection;
+ flagword flags = bfd_get_section_flags (abfd, sec);
+
+ /* Adjust segment size. */
+ seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
+ seg->vmsize += s->size;
+
+ /* File offset and length. */
+ seg->filesize = FILE_ALIGN (seg->filesize, s->align);
+
+ if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL
+ && ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
+ != BFD_MACH_O_S_GB_ZEROFILL))
+ {
+ mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
+
+ s->offset = mdata->filelen;
+ s->bfdsection->filepos = s->offset;
+
+ seg->filesize += s->size;
+ mdata->filelen += s->size;
+ }
+ else
+ {
+ s->offset = 0;
+ s->bfdsection->filepos = 0;
+ }
+
+ /* Set protection. */
+ if (flags & SEC_LOAD)
+ {
+ if (flags & SEC_CODE)
+ seg->initprot |= BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_EXECUTE;
+ if ((flags & (SEC_DATA | SEC_READONLY)) == SEC_DATA)
+ seg->initprot |= BFD_MACH_O_PROT_WRITE | BFD_MACH_O_PROT_READ;
}
+
+ /* Relocs shouldn't appear in non-object files. */
+ if (s->bfdsection->reloc_count != 0)
+ return FALSE;
}
- return nisyms;
+
+ /* Set maxprot. */
+ if (seg->initprot != 0)
+ seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
+ | BFD_MACH_O_PROT_EXECUTE;
+ else
+ seg->maxprot = 0;
+
+ /* Round segment size (and file size). */
+ seg->vmsize = (seg->vmsize + pagemask) & ~pagemask;
+ seg->filesize = (seg->filesize + pagemask) & ~pagemask;
+ mdata->filelen = (mdata->filelen + pagemask) & ~pagemask;
+
+ return TRUE;
}
+/* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
+ fields in header. */
+
static bfd_boolean
-bfd_mach_o_build_dysymtab_command (bfd *abfd,
- bfd_mach_o_data_struct *mdata,
- bfd_mach_o_load_command *cmd)
+bfd_mach_o_layout_commands (bfd_mach_o_data_struct *mdata)
{
- bfd_mach_o_dysymtab_command *dsym = &cmd->command.dysymtab;
-
- /* TODO:
- We are not going to try and fill these in yet and, moreover, we are
- going to bail if they are already set. */
- if (dsym->nmodtab != 0
- || dsym->ntoc != 0
- || dsym->nextrefsyms != 0)
- {
- (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
- " implemented for dysymtab commands."));
- return FALSE;
- }
-
- dsym->ilocalsym = 0;
+ unsigned wide = mach_o_wide_p (&mdata->header);
+ unsigned int hdrlen;
+ ufile_ptr offset;
+ bfd_mach_o_load_command *cmd;
+ unsigned int align;
+ bfd_boolean ret = TRUE;
+
+ hdrlen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
+ align = wide ? 8 - 1 : 4 - 1;
+ offset = hdrlen;
+ mdata->header.ncmds = 0;
- if (bfd_get_symcount (abfd) > 0)
+ for (cmd = mdata->first_command; cmd; cmd = cmd->next)
{
- asymbol **symbols = bfd_get_outsymbols (abfd);
- unsigned long i;
+ mdata->header.ncmds++;
+ cmd->offset = offset;
- /* Count the number of each kind of symbol. */
- for (i = 0; i < bfd_get_symcount (abfd); ++i)
- {
- bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
- if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
- break;
- }
- dsym->nlocalsym = i;
- dsym->iextdefsym = i;
- for (; i < bfd_get_symcount (abfd); ++i)
+ switch (cmd->type)
{
- bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
- if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
- break;
+ case BFD_MACH_O_LC_SEGMENT_64:
+ cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
+ + BFD_MACH_O_SECTION_64_SIZE * cmd->command.segment.nsects;
+ break;
+ case BFD_MACH_O_LC_SEGMENT:
+ cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
+ + BFD_MACH_O_SECTION_SIZE * cmd->command.segment.nsects;
+ break;
+ case BFD_MACH_O_LC_SYMTAB:
+ cmd->len = sizeof (struct mach_o_symtab_command_external)
+ + BFD_MACH_O_LC_SIZE;
+ break;
+ case BFD_MACH_O_LC_DYSYMTAB:
+ cmd->len = sizeof (struct mach_o_dysymtab_command_external)
+ + BFD_MACH_O_LC_SIZE;
+ break;
+ case BFD_MACH_O_LC_LOAD_DYLIB:
+ cmd->len = sizeof (struct mach_o_dylib_command_external)
+ + BFD_MACH_O_LC_SIZE;
+ cmd->command.dylib.name_offset = cmd->len;
+ cmd->len += strlen (cmd->command.dylib.name_str);
+ cmd->len = (cmd->len + align) & ~align;
+ break;
+ case BFD_MACH_O_LC_LOAD_DYLINKER:
+ cmd->len = sizeof (struct mach_o_str_command_external)
+ + BFD_MACH_O_LC_SIZE;
+ cmd->command.dylinker.name_offset = cmd->len;
+ cmd->len += strlen (cmd->command.dylinker.name_str);
+ cmd->len = (cmd->len + align) & ~align;
+ break;
+ case BFD_MACH_O_LC_MAIN:
+ cmd->len = sizeof (struct mach_o_entry_point_command_external)
+ + BFD_MACH_O_LC_SIZE;
+ break;
+ case BFD_MACH_O_LC_DYLD_INFO:
+ cmd->len = sizeof (struct mach_o_dyld_info_command_external)
+ + BFD_MACH_O_LC_SIZE;
+ break;
+ default:
+ _bfd_error_handler
+ (_("unable to layout unknown load command 0x%lx"),
+ (unsigned long) cmd->type);
+ ret = FALSE;
+ break;
}
- dsym->nextdefsym = i - dsym->nlocalsym;
- dsym->iundefsym = dsym->nextdefsym + dsym->iextdefsym;
- dsym->nundefsym = bfd_get_symcount (abfd)
- - dsym->nlocalsym
- - dsym->nextdefsym;
- }
- else
- {
- dsym->nlocalsym = 0;
- dsym->iextdefsym = 0;
- dsym->nextdefsym = 0;
- dsym->iundefsym = 0;
- dsym->nundefsym = 0;
+
+ BFD_ASSERT (cmd->len % (align + 1) == 0);
+ offset += cmd->len;
}
+ mdata->header.sizeofcmds = offset - hdrlen;
+ mdata->filelen = offset;
- dsym->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
- if (dsym->nindirectsyms > 0)
- {
- unsigned i;
- unsigned n;
+ return ret;
+}
- mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
- dsym->indirectsymoff = mdata->filelen;
- mdata->filelen += dsym->nindirectsyms * 4;
+/* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
+ segment. */
- dsym->indirect_syms = bfd_zalloc (abfd, dsym->nindirectsyms * 4);
- if (dsym->indirect_syms == NULL)
- return FALSE;
+static void
+bfd_mach_o_init_segment (bfd_mach_o_data_struct *mdata,
+ bfd_mach_o_load_command *cmd,
+ const char *segname, unsigned int nbr_sect)
+{
+ bfd_mach_o_segment_command *seg = &cmd->command.segment;
+ unsigned wide = mach_o_wide_p (&mdata->header);
- n = 0;
- for (i = 0; i < mdata->nsects; ++i)
- {
- bfd_mach_o_section *sec = mdata->sections[i];
+ /* Init segment command. */
+ cmd->type = wide ? BFD_MACH_O_LC_SEGMENT_64 : BFD_MACH_O_LC_SEGMENT;
+ cmd->type_required = FALSE;
- switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
- {
- case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
- case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
- case BFD_MACH_O_S_SYMBOL_STUBS:
- {
- unsigned j, num;
- bfd_mach_o_asymbol **isyms = sec->indirect_syms;
+ strcpy (seg->segname, segname);
+ seg->nsects = nbr_sect;
- num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
- if (isyms == NULL || num == 0)
- break;
- /* Record the starting index in the reserved1 field. */
- sec->reserved1 = n;
- for (j = 0; j < num; j++, n++)
- {
- if (isyms[j] == NULL)
- dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
- else if (isyms[j]->symbol.section == bfd_abs_section_ptr
- && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
- dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
- | BFD_MACH_O_INDIRECT_SYM_ABS;
- else
- dsym->indirect_syms[n] = isyms[j]->symbol.udata.i;
- }
- }
- break;
- default:
- break;
- }
- }
- }
+ seg->vmaddr = 0;
+ seg->vmsize = 0;
- return TRUE;
+ seg->fileoff = 0;
+ seg->filesize = 0;
+ seg->maxprot = 0;
+ seg->initprot = 0;
+ seg->flags = 0;
+ seg->sect_head = NULL;
+ seg->sect_tail = NULL;
}
/* Build Mach-O load commands (currently assuming an MH_OBJECT file).
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
unsigned wide = mach_o_wide_p (&mdata->header);
- int segcmd_idx = -1;
+ unsigned int nbr_segcmd = 0;
+ bfd_mach_o_load_command *commands;
+ unsigned int nbr_commands;
int symtab_idx = -1;
int dysymtab_idx = -1;
- unsigned long base_offset = 0;
+ int main_idx = -1;
+ unsigned int i;
- /* Return now if commands are already present. */
- if (mdata->header.ncmds)
- return FALSE;
+ /* Return now if already built. */
+ if (mdata->header.ncmds != 0)
+ return TRUE;
/* Fill in the file type, if not already set. */
-
if (mdata->header.filetype == 0)
{
if (abfd->flags & EXEC_P)
if (!bfd_mach_o_mangle_symbols (abfd))
return FALSE;
- /* Very simple command set (only really applicable to MH_OBJECTs):
- All the commands are optional - present only when there is suitable data.
- (i.e. it is valid to have an empty file)
+ /* Segment commands. */
+ if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
+ {
+ /* Only one segment for all the sections. But the segment is
+ optional if there is no sections. */
+ nbr_segcmd = (mdata->nsects > 0) ? 1 : 0;
+ }
+ else
+ {
+ bfd_mach_o_section *prev_sect = NULL;
- a command (segment) to contain all the sections,
- command for the symbol table,
- a command for the dysymtab.
+ /* One pagezero segment and one linkedit segment. */
+ nbr_segcmd = 2;
- ??? maybe we should assert that this is an MH_OBJECT? */
+ /* Create one segment for associated segment name in sections.
+ Assume that sections with the same segment name are consecutive. */
+ for (i = 0; i < mdata->nsects; i++)
+ {
+ bfd_mach_o_section *this_sect = mdata->sections[i];
- if (mdata->nsects > 0)
- {
- segcmd_idx = 0;
- mdata->header.ncmds = 1;
+ if (prev_sect == NULL
+ || strcmp (prev_sect->segname, this_sect->segname) != 0)
+ {
+ nbr_segcmd++;
+ prev_sect = this_sect;
+ }
+ }
}
+ nbr_commands = nbr_segcmd;
+
+ /* One command for the symbol table (only if there are symbols. */
if (bfd_get_symcount (abfd) > 0)
- {
- mdata->header.ncmds++;
- symtab_idx = segcmd_idx + 1; /* 0 if the seg command is absent. */
- }
+ symtab_idx = nbr_commands++;
/* FIXME:
This is a rather crude test for whether we should build a dysymtab. */
if (bfd_mach_o_should_emit_dysymtab ()
&& bfd_get_symcount (abfd))
{
- mdata->header.ncmds++;
/* If there should be a case where a dysymtab could be emitted without
a symtab (seems improbable), this would need amending. */
- dysymtab_idx = symtab_idx + 1;
+ dysymtab_idx = nbr_commands++;
}
- if (wide)
- base_offset = BFD_MACH_O_HEADER_64_SIZE;
- else
- base_offset = BFD_MACH_O_HEADER_SIZE;
+ /* Add an entry point command. */
+ if (mdata->header.filetype == BFD_MACH_O_MH_EXECUTE
+ && bfd_get_start_address (abfd) != 0)
+ main_idx = nbr_commands++;
/* Well, we must have a header, at least. */
- mdata->filelen = base_offset;
+ mdata->filelen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
/* A bit unusual, but no content is valid;
as -n empty.s -o empty.o */
- if (mdata->header.ncmds == 0)
- return TRUE;
+ if (nbr_commands == 0)
+ {
+ /* Layout commands (well none...) and set headers command fields. */
+ return bfd_mach_o_layout_commands (mdata);
+ }
- mdata->commands = bfd_zalloc (abfd, mdata->header.ncmds
- * sizeof (bfd_mach_o_load_command));
- if (mdata->commands == NULL)
+ /* Create commands for segments (and symtabs), prepend them. */
+ commands = bfd_zalloc (abfd, nbr_commands * sizeof (bfd_mach_o_load_command));
+ if (commands == NULL)
return FALSE;
-
- if (segcmd_idx >= 0)
+ for (i = 0; i < nbr_commands - 1; i++)
+ commands[i].next = &commands[i + 1];
+ commands[nbr_commands - 1].next = mdata->first_command;
+ if (mdata->first_command == NULL)
+ mdata->last_command = &commands[nbr_commands - 1];
+ mdata->first_command = &commands[0];
+
+ if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT && nbr_segcmd != 0)
{
- bfd_mach_o_load_command *cmd = &mdata->commands[segcmd_idx];
- bfd_mach_o_segment_command *seg = &cmd->command.segment;
+ /* For object file, there is only one segment. */
+ bfd_mach_o_init_segment (mdata, &commands[0], "", mdata->nsects);
+ }
+ else if (nbr_segcmd != 0)
+ {
+ bfd_mach_o_load_command *cmd;
- /* Count the segctions in the special blank segment used for MH_OBJECT. */
- seg->nsects = bfd_mach_o_count_sections_for_seg (NULL, mdata);
- if (seg->nsects == (unsigned long) -1)
- return FALSE;
+ BFD_ASSERT (nbr_segcmd >= 2);
- /* Init segment command. */
- cmd->offset = base_offset;
- if (wide)
- {
- cmd->type = BFD_MACH_O_LC_SEGMENT_64;
- cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
- + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
- }
- else
+ /* The pagezero. */
+ cmd = &commands[0];
+ bfd_mach_o_init_segment (mdata, cmd, "__PAGEZERO", 0);
+
+ /* Segments from sections. */
+ cmd++;
+ for (i = 0; i < mdata->nsects;)
{
- cmd->type = BFD_MACH_O_LC_SEGMENT;
- cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
- + BFD_MACH_O_SECTION_SIZE * seg->nsects;
+ const char *segname = mdata->sections[i]->segname;
+ unsigned int nbr_sect = 1;
+
+ /* Count number of sections for this segment. */
+ for (i++; i < mdata->nsects; i++)
+ if (strcmp (mdata->sections[i]->segname, segname) == 0)
+ nbr_sect++;
+ else
+ break;
+
+ bfd_mach_o_init_segment (mdata, cmd, segname, nbr_sect);
+ cmd++;
}
- cmd->type_required = FALSE;
- mdata->header.sizeofcmds = cmd->len;
- mdata->filelen += cmd->len;
+ /* The linkedit. */
+ bfd_mach_o_init_segment (mdata, cmd, "__LINKEDIT", 0);
}
if (symtab_idx >= 0)
{
/* Init symtab command. */
- bfd_mach_o_load_command *cmd = &mdata->commands[symtab_idx];
+ bfd_mach_o_load_command *cmd = &commands[symtab_idx];
cmd->type = BFD_MACH_O_LC_SYMTAB;
- cmd->offset = base_offset;
- if (segcmd_idx >= 0)
- cmd->offset += mdata->commands[segcmd_idx].len;
-
- cmd->len = sizeof (struct mach_o_symtab_command_external)
- + BFD_MACH_O_LC_SIZE;
cmd->type_required = FALSE;
- mdata->header.sizeofcmds += cmd->len;
- mdata->filelen += cmd->len;
}
/* If required, setup symtab command, see comment above about the quality
of this test. */
if (dysymtab_idx >= 0)
{
- bfd_mach_o_load_command *cmd = &mdata->commands[dysymtab_idx];
+ bfd_mach_o_load_command *cmd = &commands[dysymtab_idx];
cmd->type = BFD_MACH_O_LC_DYSYMTAB;
- if (symtab_idx >= 0)
- cmd->offset = mdata->commands[symtab_idx].offset
- + mdata->commands[symtab_idx].len;
- else if (segcmd_idx >= 0)
- cmd->offset = mdata->commands[segcmd_idx].offset
- + mdata->commands[segcmd_idx].len;
- else
- cmd->offset = base_offset;
-
cmd->type_required = FALSE;
- cmd->len = sizeof (struct mach_o_dysymtab_command_external)
- + BFD_MACH_O_LC_SIZE;
+ }
+
+ /* Create the main command. */
+ if (main_idx >= 0)
+ {
+ bfd_mach_o_load_command *cmd = &commands[main_idx];
+
+ cmd->type = BFD_MACH_O_LC_MAIN;
+ cmd->type_required = TRUE;
- mdata->header.sizeofcmds += cmd->len;
- mdata->filelen += cmd->len;
+ cmd->command.main.entryoff = 0;
+ cmd->command.main.stacksize = 0;
}
+ /* Layout commands. */
+ if (! bfd_mach_o_layout_commands (mdata))
+ return FALSE;
+
/* So, now we have sized the commands and the filelen set to that.
Now we can build the segment command and set the section file offsets. */
- if (segcmd_idx >= 0
- && ! bfd_mach_o_build_seg_command
- (NULL, mdata, &mdata->commands[segcmd_idx].command.segment))
- return FALSE;
+ if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
+ {
+ for (i = 0; i < nbr_segcmd; i++)
+ if (!bfd_mach_o_build_obj_seg_command
+ (abfd, &commands[i].command.segment))
+ return FALSE;
+ }
+ else
+ {
+ bfd_vma maxvma = 0;
- /* If we're doing a dysymtab, cmd points to its load command. */
- if (dysymtab_idx >= 0
- && ! bfd_mach_o_build_dysymtab_command (abfd, mdata,
- &mdata->commands[dysymtab_idx]))
- return FALSE;
+ /* Skip pagezero and linkedit segments. */
+ for (i = 1; i < nbr_segcmd - 1; i++)
+ {
+ bfd_mach_o_segment_command *seg = &commands[i].command.segment;
+
+ if (!bfd_mach_o_build_exec_seg_command (abfd, seg))
+ return FALSE;
+
+ if (seg->vmaddr + seg->vmsize > maxvma)
+ maxvma = seg->vmaddr + seg->vmsize;
+ }
+
+ /* Set the size of __PAGEZERO. */
+ commands[0].command.segment.vmsize =
+ commands[1].command.segment.vmaddr;
+
+ /* Set the vma and fileoff of __LINKEDIT. */
+ commands[nbr_segcmd - 1].command.segment.vmaddr = maxvma;
+ commands[nbr_segcmd - 1].command.segment.fileoff = mdata->filelen;
+
+ /* Set entry point (once segments have been laid out). */
+ if (main_idx >= 0)
+ commands[main_idx].command.main.entryoff =
+ bfd_get_start_address (abfd) - commands[1].command.segment.vmaddr;
+ }
- /* The symtab command is filled in when the symtab is written. */
return TRUE;
}
/* Trying to write the first section contents will trigger the creation of
the load commands if they are not already present. */
- if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
+ if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
return FALSE;
if (count == 0)
}
static bfd_boolean
-bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
+bfd_mach_o_read_header (bfd *abfd, file_ptr hdr_off, bfd_mach_o_header *header)
{
struct mach_o_header_external raw;
unsigned int size;
bfd_vma (*get32) (const void *) = NULL;
/* Just read the magic number. */
- if (bfd_seek (abfd, 0, SEEK_SET) != 0
+ if (bfd_seek (abfd, hdr_off, SEEK_SET) != 0
|| bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
return FALSE;
size = mach_o_wide_p (header) ?
BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
- if (bfd_seek (abfd, 0, SEEK_SET) != 0
+ if (bfd_seek (abfd, hdr_off, SEEK_SET) != 0
|| bfd_bread (&raw, size, abfd) != size)
return FALSE;
s->flags = xlat->macho_sectype | xlat->macho_secattr;
s->align = xlat->sectalign > bfdalign ? xlat->sectalign
: bfdalign;
- bfd_set_section_alignment (abfd, sec, s->align);
+ (void) bfd_set_section_alignment (abfd, sec, s->align);
bfd_flags = bfd_get_section_flags (abfd, sec);
if (bfd_flags == SEC_NO_FLAGS)
bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
}
static asection *
-bfd_mach_o_read_section_32 (bfd *abfd,
- unsigned int offset,
- unsigned long prot)
+bfd_mach_o_read_section_32 (bfd *abfd, unsigned long prot)
{
struct mach_o_section_32_external raw;
asection *sec;
bfd_mach_o_section *section;
- if (bfd_seek (abfd, offset, SEEK_SET) != 0
- || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
- != BFD_MACH_O_SECTION_SIZE))
+ if (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
+ != BFD_MACH_O_SECTION_SIZE)
return NULL;
sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
section->size = bfd_h_get_32 (abfd, raw.size);
section->offset = bfd_h_get_32 (abfd, raw.offset);
section->align = bfd_h_get_32 (abfd, raw.align);
+ /* PR 17512: file: 0017eb76. */
+ if (section->align > 64)
+ {
+ _bfd_error_handler
+ (_("bfd_mach_o_read_section_32: overlarge alignment value: 0x%x, "
+ "using 32 instead"), section->align);
+ section->align = 32;
+ }
section->reloff = bfd_h_get_32 (abfd, raw.reloff);
section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
section->flags = bfd_h_get_32 (abfd, raw.flags);
}
static asection *
-bfd_mach_o_read_section_64 (bfd *abfd,
- unsigned int offset,
- unsigned long prot)
+bfd_mach_o_read_section_64 (bfd *abfd, unsigned long prot)
{
struct mach_o_section_64_external raw;
asection *sec;
bfd_mach_o_section *section;
- if (bfd_seek (abfd, offset, SEEK_SET) != 0
- || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
- != BFD_MACH_O_SECTION_64_SIZE))
+ if (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
+ != BFD_MACH_O_SECTION_64_SIZE)
return NULL;
sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
section->size = bfd_h_get_64 (abfd, raw.size);
section->offset = bfd_h_get_32 (abfd, raw.offset);
section->align = bfd_h_get_32 (abfd, raw.align);
+ if (section->align > 64)
+ {
+ _bfd_error_handler
+ (_("bfd_mach_o_read_section_64: overlarge alignment value: 0x%x, "
+ "using 32 instead"), section->align);
+ section->align = 32;
+ }
section->reloff = bfd_h_get_32 (abfd, raw.reloff);
section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
section->flags = bfd_h_get_32 (abfd, raw.flags);
}
static asection *
-bfd_mach_o_read_section (bfd *abfd,
- unsigned int offset,
- unsigned long prot,
- unsigned int wide)
+bfd_mach_o_read_section (bfd *abfd, unsigned long prot, unsigned int wide)
{
if (wide)
- return bfd_mach_o_read_section_64 (abfd, offset, prot);
+ return bfd_mach_o_read_section_64 (abfd, prot);
else
- return bfd_mach_o_read_section_32 (abfd, offset, prot);
+ return bfd_mach_o_read_section_32 (abfd, prot);
}
static bfd_boolean
if (bfd_seek (abfd, symoff, SEEK_SET) != 0
|| bfd_bread (&raw, symwidth, abfd) != symwidth)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
symwidth, (unsigned long) symoff);
return FALSE;
if (stroff >= sym->strsize)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
(unsigned long) stroff,
(unsigned long) sym->strsize);
/* Mach-O uses 0 to mean "no section"; not an error. */
if (section != 0)
{
- (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
- "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
- s->symbol.name, section, mdata->nsects);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("bfd_mach_o_read_symtab_symbol: "
+ "symbol \"%s\" specified invalid section %d (max %lu): "
+ "setting to undefined"),
+ s->symbol.name, section, mdata->nsects);
}
s->symbol.section = bfd_und_section_ptr;
}
s->symbol.value = 0;
break;
default:
- (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
- "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
- s->symbol.name, symtype);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("bfd_mach_o_read_symtab_symbol: "
+ "symbol \"%s\" specified invalid type field 0x%x: "
+ "setting to undefined"), s->symbol.name, symtype);
s->symbol.section = bfd_und_section_ptr;
break;
}
}
else
{
- sym->strtab = bfd_alloc (abfd, sym->strsize);
+ sym->strtab = bfd_alloc (abfd, sym->strsize + 1);
if (sym->strtab == NULL)
return FALSE;
if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
|| bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
{
+ /* PR 17512: file: 10888-1609-0.004. */
+ bfd_release (abfd, sym->strtab);
+ sym->strtab = NULL;
bfd_set_error (bfd_error_file_truncated);
return FALSE;
}
+ /* Zero terminate the string table. */
+ sym->strtab[sym->strsize] = 0;
}
return TRUE;
unsigned long i;
if (sym == NULL || sym->symbols)
- {
- /* Return now if there are no symbols or if already loaded. */
- return TRUE;
- }
-
- sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
+ /* Return now if there are no symbols or if already loaded. */
+ return TRUE;
+ sym->symbols = bfd_alloc2 (abfd, sym->nsyms, sizeof (bfd_mach_o_asymbol));
if (sym->symbols == NULL)
{
- (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
+ _bfd_error_handler (_("bfd_mach_o_read_symtab_symbols: "
+ "unable to allocate memory for symbols"));
+ sym->nsyms = 0;
return FALSE;
}
if (!bfd_mach_o_read_symtab_strtab (abfd))
- return FALSE;
+ goto fail;
for (i = 0; i < sym->nsyms; i++)
- {
- if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
- return FALSE;
- }
+ if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
+ goto fail;
return TRUE;
+
+ fail:
+ bfd_release (abfd, sym->symbols);
+ sym->symbols = NULL;
+ sym->nsyms = 0;
+ return FALSE;
}
static const char *
}
}
-static int
+static bfd_boolean
bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
struct mach_o_str_command_external raw;
unsigned int nameoff;
+ unsigned int namelen;
- BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
- || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
-
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
nameoff = bfd_h_get_32 (abfd, raw.str);
- cmd->name_offset = command->offset + nameoff;
- cmd->name_len = command->len - nameoff;
- cmd->name_str = bfd_alloc (abfd, cmd->name_len);
+ cmd->name_offset = nameoff;
+ namelen = command->len - nameoff;
+ nameoff += command->offset;
+ cmd->name_str = bfd_alloc (abfd, namelen);
if (cmd->name_str == NULL)
- return -1;
- if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
- || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
- return -1;
- return 0;
+ return FALSE;
+ if (bfd_seek (abfd, nameoff, SEEK_SET) != 0
+ || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
+ return FALSE;
+ return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
{
+ bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
bfd_mach_o_dylib_command *cmd = &command->command.dylib;
struct mach_o_dylib_command_external raw;
unsigned int nameoff;
+ unsigned int namelen;
switch (command->type)
{
case BFD_MACH_O_LC_LOAD_DYLIB:
+ case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
case BFD_MACH_O_LC_ID_DYLIB:
case BFD_MACH_O_LC_REEXPORT_DYLIB:
break;
default:
BFD_FAIL ();
- return -1;
+ return FALSE;
}
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
nameoff = bfd_h_get_32 (abfd, raw.name);
cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
cmd->name_offset = command->offset + nameoff;
- cmd->name_len = command->len - nameoff;
- cmd->name_str = bfd_alloc (abfd, cmd->name_len);
+ namelen = command->len - nameoff;
+ cmd->name_str = bfd_alloc (abfd, namelen);
if (cmd->name_str == NULL)
- return -1;
- if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
- || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
- return -1;
- return 0;
+ return FALSE;
+ if (bfd_seek (abfd, mdata->hdr_offset + cmd->name_offset, SEEK_SET) != 0
+ || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
+ return FALSE;
+ return TRUE;
}
-static int
-bfd_mach_o_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
- bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
+static bfd_boolean
+bfd_mach_o_read_prebound_dylib (bfd *abfd,
+ bfd_mach_o_load_command *command)
{
- /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
+ bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib;
+ struct mach_o_prebound_dylib_command_external raw;
+ unsigned int nameoff;
+ unsigned int modoff;
+ unsigned int str_len;
+ unsigned char *str;
- BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
- return 0;
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
+
+ nameoff = bfd_h_get_32 (abfd, raw.name);
+ modoff = bfd_h_get_32 (abfd, raw.linked_modules);
+ if (nameoff > command->len || modoff > command->len)
+ return FALSE;
+
+ str_len = command->len - sizeof (raw);
+ str = bfd_alloc (abfd, str_len);
+ if (str == NULL)
+ return FALSE;
+ if (bfd_bread (str, str_len, abfd) != str_len)
+ return FALSE;
+
+ cmd->name_offset = command->offset + nameoff;
+ cmd->nmodules = bfd_h_get_32 (abfd, raw.nmodules);
+ cmd->linked_modules_offset = command->offset + modoff;
+
+ cmd->name_str = (char *)str + nameoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
+ cmd->linked_modules = str + modoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
+ return TRUE;
}
-static int
+static bfd_boolean
+bfd_mach_o_read_prebind_cksum (bfd *abfd,
+ bfd_mach_o_load_command *command)
+{
+ bfd_mach_o_prebind_cksum_command *cmd = &command->command.prebind_cksum;
+ struct mach_o_prebind_cksum_command_external raw;
+
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
+
+ cmd->cksum = bfd_get_32 (abfd, raw.cksum);
+ return TRUE;
+}
+
+static bfd_boolean
+bfd_mach_o_read_twolevel_hints (bfd *abfd,
+ bfd_mach_o_load_command *command)
+{
+ bfd_mach_o_twolevel_hints_command *cmd = &command->command.twolevel_hints;
+ struct mach_o_twolevel_hints_command_external raw;
+
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
+
+ cmd->offset = bfd_get_32 (abfd, raw.offset);
+ cmd->nhints = bfd_get_32 (abfd, raw.nhints);
+ return TRUE;
+}
+
+static bfd_boolean
bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
struct mach_o_fvmlib_command_external raw;
unsigned int nameoff;
+ unsigned int namelen;
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
nameoff = bfd_h_get_32 (abfd, raw.name);
fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
fvm->name_offset = command->offset + nameoff;
- fvm->name_len = command->len - nameoff;
- fvm->name_str = bfd_alloc (abfd, fvm->name_len);
+ namelen = command->len - nameoff;
+ fvm->name_str = bfd_alloc (abfd, namelen);
if (fvm->name_str == NULL)
- return -1;
+ return FALSE;
if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
- || bfd_bread (fvm->name_str, fvm->name_len, abfd) != fvm->name_len)
- return -1;
- return 0;
+ || bfd_bread (fvm->name_str, namelen, abfd) != namelen)
+ return FALSE;
+ return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
struct mach_o_thread_command_external raw;
if (offset >= command->len)
- return -1;
+ return FALSE;
if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
|| bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ return FALSE;
offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
nflavours++;
}
/* Allocate threads. */
- cmd->flavours = bfd_alloc
- (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
+ cmd->flavours = bfd_alloc2
+ (abfd, nflavours, sizeof (bfd_mach_o_thread_flavour));
if (cmd->flavours == NULL)
- return -1;
+ return FALSE;
cmd->nflavours = nflavours;
offset = 8;
struct mach_o_thread_command_external raw;
if (offset >= command->len)
- return -1;
+ return FALSE;
if (nflavours >= cmd->nflavours)
- return -1;
+ return FALSE;
if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
|| bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ return FALSE;
cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
{
case BFD_MACH_O_CPU_TYPE_POWERPC:
case BFD_MACH_O_CPU_TYPE_POWERPC_64:
- flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
+ flavourstr =
+ bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
break;
case BFD_MACH_O_CPU_TYPE_I386:
case BFD_MACH_O_CPU_TYPE_X86_64:
- flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
+ flavourstr =
+ bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
break;
default:
flavourstr = "UNKNOWN_ARCHITECTURE";
snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
sname = bfd_alloc (abfd, snamelen);
if (sname == NULL)
- return -1;
+ return FALSE;
for (;;)
{
cmd->section = bfdsec;
}
- return 0;
+ return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
{
struct mach_o_dysymtab_command_external raw;
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
unsigned int module_len = wide ? 56 : 52;
cmd->dylib_module =
- bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
+ bfd_alloc2 (abfd, cmd->nmodtab, sizeof (bfd_mach_o_dylib_module));
if (cmd->dylib_module == NULL)
- return -1;
+ return FALSE;
if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
- return -1;
+ return FALSE;
for (i = 0; i < cmd->nmodtab; i++)
{
unsigned char buf[56];
if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
- return -1;
+ return FALSE;
module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
if (cmd->ntoc != 0)
{
- unsigned int i;
+ unsigned long i;
- cmd->dylib_toc = bfd_alloc
- (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
+ cmd->dylib_toc = bfd_alloc2
+ (abfd, cmd->ntoc, sizeof (bfd_mach_o_dylib_table_of_content));
if (cmd->dylib_toc == NULL)
- return -1;
+ return FALSE;
if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
- return -1;
+ return FALSE;
for (i = 0; i < cmd->ntoc; i++)
{
bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ return FALSE;
toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
{
unsigned int i;
- cmd->indirect_syms = bfd_alloc
- (abfd, cmd->nindirectsyms * sizeof (unsigned int));
+ cmd->indirect_syms = bfd_alloc2
+ (abfd, cmd->nindirectsyms, sizeof (unsigned int));
if (cmd->indirect_syms == NULL)
- return -1;
+ return FALSE;
if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
- return -1;
+ return FALSE;
for (i = 0; i < cmd->nindirectsyms; i++)
{
unsigned int *is = &cmd->indirect_syms[i];
if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ return FALSE;
*is = bfd_h_get_32 (abfd, raw);
}
unsigned long v;
unsigned int i;
- cmd->ext_refs = bfd_alloc
- (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
+ cmd->ext_refs = bfd_alloc2
+ (abfd, cmd->nextrefsyms, sizeof (bfd_mach_o_dylib_reference));
if (cmd->ext_refs == NULL)
- return -1;
+ return FALSE;
if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
- return -1;
+ return FALSE;
for (i = 0; i < cmd->nextrefsyms; i++)
{
bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ return FALSE;
/* Fields isym and flags are written as bit-fields, thus we need
a specific processing for endianness. */
}
if (mdata->dysymtab)
- return -1;
+ return FALSE;
mdata->dysymtab = cmd;
- return 0;
+ return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_symtab_command *symtab = &command->command.symtab;
BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
abfd->flags |= HAS_SYMS;
if (mdata->symtab)
- return -1;
+ return FALSE;
mdata->symtab = symtab;
- return 0;
+ return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_uuid_command *cmd = &command->command.uuid;
BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (cmd->uuid, 16, abfd) != 16)
- return -1;
+ if (bfd_bread (cmd->uuid, 16, abfd) != 16)
+ return FALSE;
- return 0;
+ return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
struct mach_o_linkedit_data_command_external raw;
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
cmd->datasize = bfd_get_32 (abfd, raw.datasize);
- return 0;
+ return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_str_command *cmd = &command->command.str;
struct mach_o_str_command_external raw;
unsigned long off;
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
off = bfd_get_32 (abfd, raw.str);
cmd->stroff = command->offset + off;
cmd->str_len = command->len - off;
cmd->str = bfd_alloc (abfd, cmd->str_len);
if (cmd->str == NULL)
- return -1;
+ return FALSE;
if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
|| bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
- return -1;
- return 0;
+ return FALSE;
+ return TRUE;
}
-static int
+static unsigned char *
+bfd_mach_o_alloc_and_read (bfd *abfd, unsigned int off, unsigned int size)
+{
+ unsigned char *buf;
+
+ buf = bfd_alloc (abfd, size);
+ if (buf == NULL)
+ return NULL;
+ if (bfd_seek (abfd, off, SEEK_SET) != 0
+ || bfd_bread (buf, size, abfd) != size)
+ return NULL;
+ return buf;
+}
+
+static bfd_boolean
+bfd_mach_o_read_dyld_content (bfd *abfd, bfd_mach_o_dyld_info_command *cmd)
+{
+ /* Read rebase content. */
+ if (cmd->rebase_content == NULL && cmd->rebase_size != 0)
+ {
+ cmd->rebase_content =
+ bfd_mach_o_alloc_and_read (abfd, cmd->rebase_off, cmd->rebase_size);
+ if (cmd->rebase_content == NULL)
+ return FALSE;
+ }
+
+ /* Read bind content. */
+ if (cmd->bind_content == NULL && cmd->bind_size != 0)
+ {
+ cmd->bind_content =
+ bfd_mach_o_alloc_and_read (abfd, cmd->bind_off, cmd->bind_size);
+ if (cmd->bind_content == NULL)
+ return FALSE;
+ }
+
+ /* Read weak bind content. */
+ if (cmd->weak_bind_content == NULL && cmd->weak_bind_size != 0)
+ {
+ cmd->weak_bind_content = bfd_mach_o_alloc_and_read
+ (abfd, cmd->weak_bind_off, cmd->weak_bind_size);
+ if (cmd->weak_bind_content == NULL)
+ return FALSE;
+ }
+
+ /* Read lazy bind content. */
+ if (cmd->lazy_bind_content == NULL && cmd->lazy_bind_size != 0)
+ {
+ cmd->lazy_bind_content = bfd_mach_o_alloc_and_read
+ (abfd, cmd->lazy_bind_off, cmd->lazy_bind_size);
+ if (cmd->lazy_bind_content == NULL)
+ return FALSE;
+ }
+
+ /* Read export content. */
+ if (cmd->export_content == NULL && cmd->export_size != 0)
+ {
+ cmd->export_content = bfd_mach_o_alloc_and_read
+ (abfd, cmd->export_off, cmd->export_size);
+ if (cmd->export_content == NULL)
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static bfd_boolean
bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
struct mach_o_dyld_info_command_external raw;
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
+ cmd->rebase_content = NULL;
cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
+ cmd->bind_content = NULL;
cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
+ cmd->weak_bind_content = NULL;
cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
+ cmd->lazy_bind_content = NULL;
cmd->export_off = bfd_get_32 (abfd, raw.export_off);
cmd->export_size = bfd_get_32 (abfd, raw.export_size);
- return 0;
+ cmd->export_content = NULL;
+ return TRUE;
}
static bfd_boolean
struct mach_o_version_min_command_external raw;
unsigned int ver;
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
return FALSE;
ver = bfd_get_32 (abfd, raw.version);
bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
struct mach_o_encryption_info_command_external raw;
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
+
+ cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
+ cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
+ cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
+ return TRUE;
+}
+
+static bfd_boolean
+bfd_mach_o_read_encryption_info_64 (bfd *abfd, bfd_mach_o_load_command *command)
+{
+ bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
+ struct mach_o_encryption_info_64_command_external raw;
+
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
return FALSE;
cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
bfd_mach_o_main_command *cmd = &command->command.main;
struct mach_o_entry_point_command_external raw;
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
return FALSE;
cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
struct mach_o_source_version_command_external raw;
bfd_uint64_t ver;
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
return FALSE;
ver = bfd_get_64 (abfd, raw.version);
return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_read_segment (bfd *abfd,
bfd_mach_o_load_command *command,
unsigned int wide)
BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
memcpy (seg->segname, raw.segname, 16);
seg->segname[16] = '\0';
BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
- if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
- || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
- return -1;
+ if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
+ return FALSE;
memcpy (seg->segname, raw.segname, 16);
seg->segname[16] = '\0';
for (i = 0; i < seg->nsects; i++)
{
- bfd_vma segoff;
asection *sec;
- if (wide)
- segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
- + (i * BFD_MACH_O_SECTION_64_SIZE);
- else
- segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
- + (i * BFD_MACH_O_SECTION_SIZE);
-
- sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
+ sec = bfd_mach_o_read_section (abfd, seg->initprot, wide);
if (sec == NULL)
- return -1;
+ return FALSE;
- bfd_mach_o_append_section_to_segment (seg, sec);
+ bfd_mach_o_append_section_to_segment
+ (seg, bfd_mach_o_get_mach_o_section (sec));
}
- return 0;
+ return TRUE;
}
-static int
+static bfd_boolean
bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
{
return bfd_mach_o_read_segment (abfd, command, 0);
}
-static int
+static bfd_boolean
bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
{
return bfd_mach_o_read_segment (abfd, command, 1);
}
-static int
+static bfd_boolean
bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
{
+ bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
struct mach_o_load_command_external raw;
unsigned int cmd;
/* Read command type and length. */
- if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
+ if (bfd_seek (abfd, mdata->hdr_offset + command->offset, SEEK_SET) != 0
|| bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
- return -1;
+ return FALSE;
cmd = bfd_h_get_32 (abfd, raw.cmd);
command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
switch (command->type)
{
case BFD_MACH_O_LC_SEGMENT:
- if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
- return -1;
+ if (!bfd_mach_o_read_segment_32 (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_SEGMENT_64:
- if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
- return -1;
+ if (!bfd_mach_o_read_segment_64 (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_SYMTAB:
- if (bfd_mach_o_read_symtab (abfd, command) != 0)
- return -1;
+ if (!bfd_mach_o_read_symtab (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_SYMSEG:
break;
case BFD_MACH_O_LC_THREAD:
case BFD_MACH_O_LC_UNIXTHREAD:
- if (bfd_mach_o_read_thread (abfd, command) != 0)
- return -1;
+ if (!bfd_mach_o_read_thread (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_LOAD_DYLINKER:
case BFD_MACH_O_LC_ID_DYLINKER:
- if (bfd_mach_o_read_dylinker (abfd, command) != 0)
- return -1;
+ case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
+ if (!bfd_mach_o_read_dylinker (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_LOAD_DYLIB:
+ case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
case BFD_MACH_O_LC_ID_DYLIB:
case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
case BFD_MACH_O_LC_REEXPORT_DYLIB:
case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
- if (bfd_mach_o_read_dylib (abfd, command) != 0)
- return -1;
+ if (!bfd_mach_o_read_dylib (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_PREBOUND_DYLIB:
- if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
- return -1;
+ if (!bfd_mach_o_read_prebound_dylib (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_LOADFVMLIB:
case BFD_MACH_O_LC_IDFVMLIB:
- if (bfd_mach_o_read_fvmlib (abfd, command) != 0)
- return -1;
+ if (!bfd_mach_o_read_fvmlib (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_IDENT:
case BFD_MACH_O_LC_FVMFILE:
case BFD_MACH_O_LC_SUB_LIBRARY:
case BFD_MACH_O_LC_SUB_CLIENT:
case BFD_MACH_O_LC_RPATH:
- if (bfd_mach_o_read_str (abfd, command) != 0)
- return -1;
+ if (!bfd_mach_o_read_str (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_DYSYMTAB:
- if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
- return -1;
+ if (!bfd_mach_o_read_dysymtab (abfd, command))
+ return FALSE;
break;
- case BFD_MACH_O_LC_TWOLEVEL_HINTS:
case BFD_MACH_O_LC_PREBIND_CKSUM:
+ if (!bfd_mach_o_read_prebind_cksum (abfd, command))
+ return FALSE;
+ break;
+ case BFD_MACH_O_LC_TWOLEVEL_HINTS:
+ if (!bfd_mach_o_read_twolevel_hints (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_UUID:
- if (bfd_mach_o_read_uuid (abfd, command) != 0)
- return -1;
+ if (!bfd_mach_o_read_uuid (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_CODE_SIGNATURE:
case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
case BFD_MACH_O_LC_FUNCTION_STARTS:
case BFD_MACH_O_LC_DATA_IN_CODE:
case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
- if (bfd_mach_o_read_linkedit (abfd, command) != 0)
- return -1;
+ case BFD_MACH_O_LC_LINKER_OPTIMIZATION_HINT:
+ if (!bfd_mach_o_read_linkedit (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_ENCRYPTION_INFO:
if (!bfd_mach_o_read_encryption_info (abfd, command))
- return -1;
+ return FALSE;
+ break;
+ case BFD_MACH_O_LC_ENCRYPTION_INFO_64:
+ if (!bfd_mach_o_read_encryption_info_64 (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_DYLD_INFO:
- if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
- return -1;
+ if (!bfd_mach_o_read_dyld_info (abfd, command))
+ return FALSE;
break;
case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
+ case BFD_MACH_O_LC_VERSION_MIN_WATCHOS:
if (!bfd_mach_o_read_version_min (abfd, command))
- return -1;
+ return FALSE;
break;
case BFD_MACH_O_LC_MAIN:
if (!bfd_mach_o_read_main (abfd, command))
- return -1;
+ return FALSE;
break;
case BFD_MACH_O_LC_SOURCE_VERSION:
if (!bfd_mach_o_read_source_version (abfd, command))
- return -1;
+ return FALSE;
break;
default:
- (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
- abfd, (unsigned long) command->type);
- break;
+ command->len = 0;
+ _bfd_error_handler (_("%B: unknown load command 0x%lx"),
+ abfd, (unsigned long) command->type);
+ return FALSE;
}
- return 0;
+ return TRUE;
}
static void
bfd_mach_o_flatten_sections (bfd *abfd)
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
+ bfd_mach_o_load_command *cmd;
long csect = 0;
- unsigned long i;
/* Count total number of sections. */
mdata->nsects = 0;
- for (i = 0; i < mdata->header.ncmds; i++)
+ for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
{
- if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
- || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
+ if (cmd->type == BFD_MACH_O_LC_SEGMENT
+ || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
{
- bfd_mach_o_segment_command *seg;
+ bfd_mach_o_segment_command *seg = &cmd->command.segment;
- seg = &mdata->commands[i].command.segment;
mdata->nsects += seg->nsects;
}
}
/* Allocate sections array. */
- mdata->sections = bfd_alloc (abfd,
- mdata->nsects * sizeof (bfd_mach_o_section *));
+ mdata->sections = bfd_alloc2 (abfd,
+ mdata->nsects, sizeof (bfd_mach_o_section *));
/* Fill the array. */
csect = 0;
- for (i = 0; i < mdata->header.ncmds; i++)
+ for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
{
- if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
- || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
+ if (cmd->type == BFD_MACH_O_LC_SEGMENT
+ || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
{
- bfd_mach_o_segment_command *seg;
+ bfd_mach_o_segment_command *seg = &cmd->command.segment;
bfd_mach_o_section *sec;
- seg = &mdata->commands[i].command.segment;
BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
for (sec = seg->sect_head; sec != NULL; sec = sec->next)
bfd_mach_o_scan_start_address (bfd *abfd)
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
- bfd_mach_o_thread_command *cmd = NULL;
+ bfd_mach_o_thread_command *thr = NULL;
+ bfd_mach_o_load_command *cmd;
unsigned long i;
- for (i = 0; i < mdata->header.ncmds; i++)
- if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
- (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
+ for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
+ if (cmd->type == BFD_MACH_O_LC_THREAD
+ || cmd->type == BFD_MACH_O_LC_UNIXTHREAD)
{
- cmd = &mdata->commands[i].command.thread;
+ thr = &cmd->command.thread;
break;
}
+ else if (cmd->type == BFD_MACH_O_LC_MAIN && mdata->nsects > 1)
+ {
+ bfd_mach_o_main_command *main_cmd = &cmd->command.main;
+ bfd_mach_o_section *text_sect = mdata->sections[0];
+
+ if (text_sect)
+ {
+ abfd->start_address = main_cmd->entryoff
+ + (text_sect->addr - text_sect->offset);
+ return TRUE;
+ }
+ }
- if (cmd == NULL)
- return FALSE;
+ /* An object file has no start address, so do not fail if not found. */
+ if (thr == NULL)
+ return TRUE;
/* FIXME: create a subtarget hook ? */
- for (i = 0; i < cmd->nflavours; i++)
+ for (i = 0; i < thr->nflavours; i++)
{
if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
- && (cmd->flavours[i].flavour
- == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
+ && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE32))
{
unsigned char buf[4];
- if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
+ if (bfd_seek (abfd, thr->flavours[i].offset + 40, SEEK_SET) != 0
|| bfd_bread (buf, 4, abfd) != 4)
return FALSE;
abfd->start_address = bfd_h_get_32 (abfd, buf);
}
else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
- && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
+ && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
{
unsigned char buf[4];
- if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
+ if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
|| bfd_bread (buf, 4, abfd) != 4)
return FALSE;
abfd->start_address = bfd_h_get_32 (abfd, buf);
}
else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
- && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
+ && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
{
unsigned char buf[8];
- if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
+ if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
|| bfd_bread (buf, 8, abfd) != 8)
return FALSE;
abfd->start_address = bfd_h_get_64 (abfd, buf);
}
else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
- && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
+ && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
{
unsigned char buf[8];
- if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
+ if (bfd_seek (abfd, thr->flavours[i].offset + (16 * 8), SEEK_SET) != 0
|| bfd_bread (buf, 8, abfd) != 8)
return FALSE;
&cputype, &cpusubtype);
if (cputype == bfd_arch_unknown)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
header->cputype, header->cpusubtype);
return FALSE;
if (header->ncmds != 0)
{
- mdata->commands = bfd_alloc
- (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
- if (mdata->commands == NULL)
+ bfd_mach_o_load_command *cmd;
+
+ mdata->first_command = NULL;
+ mdata->last_command = NULL;
+
+ cmd = bfd_alloc2 (abfd, header->ncmds, sizeof (bfd_mach_o_load_command));
+ if (cmd == NULL)
return FALSE;
for (i = 0; i < header->ncmds; i++)
{
- bfd_mach_o_load_command *cur = &mdata->commands[i];
+ bfd_mach_o_load_command *cur = &cmd[i];
+
+ bfd_mach_o_append_command (abfd, cur);
if (i == 0)
cur->offset = hdrsize;
else
{
- bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
+ bfd_mach_o_load_command *prev = &cmd[i - 1];
cur->offset = prev->offset + prev->len;
}
- if (bfd_mach_o_read_command (abfd, cur) < 0)
+ if (!bfd_mach_o_read_command (abfd, cur))
return FALSE;
}
}
- if (bfd_mach_o_scan_start_address (abfd) < 0)
+ /* Sections should be flatten before scanning start address. */
+ bfd_mach_o_flatten_sections (abfd);
+ if (!bfd_mach_o_scan_start_address (abfd))
return FALSE;
- bfd_mach_o_flatten_sections (abfd);
return TRUE;
}
{
bfd_mach_o_data_struct *mdata = NULL;
- mdata = bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct));
+ mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
if (mdata == NULL)
return FALSE;
abfd->tdata.mach_o_data = mdata;
mdata->header.sizeofcmds = 0;
mdata->header.flags = 0;
mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
- mdata->commands = NULL;
+ mdata->first_command = NULL;
+ mdata->last_command = NULL;
mdata->nsects = 0;
mdata->sections = NULL;
mdata->dyn_reloc_cache = NULL;
const bfd_target *
bfd_mach_o_header_p (bfd *abfd,
+ file_ptr hdr_off,
bfd_mach_o_filetype filetype,
bfd_mach_o_cpu_type cputype)
{
- struct bfd_preserve preserve;
bfd_mach_o_header header;
+ bfd_mach_o_data_struct *mdata;
- preserve.marker = NULL;
- if (!bfd_mach_o_read_header (abfd, &header))
+ if (!bfd_mach_o_read_header (abfd, hdr_off, &header))
goto wrong;
if (! (header.byteorder == BFD_ENDIAN_BIG
|| header.byteorder == BFD_ENDIAN_LITTLE))
{
- (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
- (unsigned long) header.byteorder);
+ _bfd_error_handler (_("unknown header byte-order value 0x%lx"),
+ (unsigned long) header.byteorder);
goto wrong;
}
if (header.cputype != cputype)
goto wrong;
}
+ else
+ {
+#ifndef BFD64
+ /* Do not recognize 64 architectures if not configured for 64bit targets.
+ This could happen only for generic targets. */
+ if (mach_o_wide_p (&header))
+ goto wrong;
+#endif
+ }
if (filetype)
{
}
}
- preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
- if (preserve.marker == NULL
- || !bfd_preserve_save (abfd, &preserve))
+ mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
+ if (mdata == NULL)
goto fail;
+ mdata->hdr_offset = hdr_off;
- if (!bfd_mach_o_scan (abfd, &header,
- (bfd_mach_o_data_struct *) preserve.marker))
+ if (!bfd_mach_o_scan (abfd, &header, mdata))
goto wrong;
- bfd_preserve_finish (abfd, &preserve);
return abfd->xvec;
wrong:
bfd_set_error (bfd_error_wrong_format);
fail:
- if (preserve.marker != NULL)
- bfd_preserve_restore (abfd, &preserve);
return NULL;
}
static const bfd_target *
bfd_mach_o_gen_object_p (bfd *abfd)
{
- return bfd_mach_o_header_p (abfd, 0, 0);
+ return bfd_mach_o_header_p (abfd, 0, 0, 0);
}
static const bfd_target *
bfd_mach_o_gen_core_p (bfd *abfd)
{
- return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
+ return bfd_mach_o_header_p (abfd, 0, BFD_MACH_O_MH_CORE, 0);
+}
+
+/* Return the base address of ABFD, ie the address at which the image is
+ mapped. The possible initial pagezero is ignored. */
+
+bfd_vma
+bfd_mach_o_get_base_address (bfd *abfd)
+{
+ bfd_mach_o_data_struct *mdata;
+ bfd_mach_o_load_command *cmd;
+
+ /* Check for Mach-O. */
+ if (!bfd_mach_o_valid (abfd))
+ return 0;
+ mdata = bfd_mach_o_get_data (abfd);
+
+ for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
+ {
+ if ((cmd->type == BFD_MACH_O_LC_SEGMENT
+ || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
+ {
+ struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
+
+ if (segcmd->initprot != 0)
+ return segcmd->vmaddr;
+ }
+ }
+ return 0;
}
typedef struct mach_o_fat_archentry
} mach_o_fat_data_struct;
const bfd_target *
-bfd_mach_o_archive_p (bfd *abfd)
+bfd_mach_o_fat_archive_p (bfd *abfd)
{
mach_o_fat_data_struct *adata = NULL;
struct mach_o_fat_header_external hdr;
goto error;
adata->archentries =
- bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
+ bfd_alloc2 (abfd, adata->nfat_arch, sizeof (mach_o_fat_archentry));
if (adata->archentries == NULL)
goto error;
}
abfd->tdata.mach_o_fat_data = adata;
+
return abfd->xvec;
error:
if (ap)
{
/* Use the architecture name if known. */
- abfd->filename = ap->printable_name;
+ abfd->filename = xstrdup (ap->printable_name);
}
else
{
/* Forge a uniq id. */
const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
- char *name = bfd_alloc (abfd, namelen);
+ char *name = xmalloc (namelen);
snprintf (name, namelen, "0x%lx-0x%lx",
entry->cputype, entry->cpusubtype);
abfd->filename = name;
}
bfd *
-bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
+bfd_mach_o_fat_openr_next_archived_file (bfd *archive, bfd *prev)
{
mach_o_fat_data_struct *adata;
mach_o_fat_archentry *entry = NULL;
bfd_mach_o_load_command_type type,
bfd_mach_o_load_command **mcommand)
{
- struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
- bfd_mach_o_load_command *ncmd = NULL;
- unsigned int i, num;
+ struct mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
+ struct bfd_mach_o_load_command *cmd;
+ unsigned int num;
- BFD_ASSERT (md != NULL);
+ BFD_ASSERT (mdata != NULL);
BFD_ASSERT (mcommand != NULL);
num = 0;
- for (i = 0; i < md->header.ncmds; i++)
+ for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
{
- struct bfd_mach_o_load_command *cmd = &md->commands[i];
-
if (cmd->type != type)
continue;
if (num == 0)
- ncmd = cmd;
+ *mcommand = cmd;
num++;
}
- *mcommand = ncmd;
return num;
}
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
- unsigned int i = 0;
+ bfd_mach_o_load_command *cmd;
- for (i = 0; i < mdata->header.ncmds; i++)
+ for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
{
- bfd_mach_o_load_command *cur = &mdata->commands[i];
- bfd_mach_o_segment_command *seg = NULL;
+ bfd_mach_o_segment_command *seg;
- if (cur->type != BFD_MACH_O_LC_SEGMENT)
+ if (cmd->type != BFD_MACH_O_LC_SEGMENT)
continue;
- seg = &cur->command.segment;
+ seg = &cmd->command.segment;
if ((seg->vmaddr + seg->vmsize) == stackaddr)
{
{
unsigned char *buf = NULL;
unsigned int len = 0;
- int ret = -1;
+ int ret;
ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
if (ret < 0)
static bfd_mach_o_uuid_command *
bfd_mach_o_lookup_uuid_command (bfd *abfd)
{
- bfd_mach_o_load_command *uuid_cmd;
+ bfd_mach_o_load_command *uuid_cmd = NULL;
int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
- if (ncmd != 1)
+ if (ncmd != 1 || uuid_cmd == NULL)
return FALSE;
return &uuid_cmd->command.uuid;
}
if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
return NULL;
- if (abfd->my_archive)
+ if (abfd->my_archive && !bfd_is_thin_archive (abfd->my_archive))
base_bfd = abfd->my_archive;
/* BFD may have been opened from a stream. */
if (base_bfd->filename == NULL)
bfd_boolean
bfd_mach_o_find_nearest_line (bfd *abfd,
- asection *section,
asymbol **symbols,
+ asection *section,
bfd_vma offset,
const char **filename_ptr,
const char **functionname_ptr,
- unsigned int *line_ptr)
+ unsigned int *line_ptr,
+ unsigned int *discriminator_ptr)
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
if (mdata == NULL)
break;
if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
dwarf_debug_sections, symbols,
- &mdata->dwarf2_find_line_info))
+ &mdata->dwarf2_find_line_info,
+ FALSE))
return FALSE;
}
break;
default:
return FALSE;
}
- if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
- section, symbols, offset,
- filename_ptr, functionname_ptr,
- line_ptr, NULL, 0,
- &mdata->dwarf2_find_line_info))
- return TRUE;
- return FALSE;
+ return _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
+ filename_ptr, functionname_ptr,
+ line_ptr, discriminator_ptr,
+ dwarf_debug_sections, 0,
+ &mdata->dwarf2_find_line_info);
}
bfd_boolean
if (mdata->dsym_bfd != NULL)
{
bfd *fat_bfd = mdata->dsym_bfd->my_archive;
+#if 0
+ /* FIXME: PR 19435: This calculation to find the memory allocated by
+ bfd_mach_o_follow_dsym for the filename does not always end up
+ selecting the correct pointer. Unfortunately this problem is
+ very hard to reproduce on a non Mach-O native system, so until it
+ can be traced and fixed on such a system, this code will remain
+ commented out. This does mean that there will be a memory leak,
+ but it is small, and happens when we are closing down, so it
+ should not matter too much. */
char *dsym_filename = (char *)(fat_bfd
? fat_bfd->filename
: mdata->dsym_bfd->filename);
+#endif
bfd_close (mdata->dsym_bfd);
mdata->dsym_bfd = NULL;
if (fat_bfd)
bfd_close (fat_bfd);
+#if 0
free (dsym_filename);
+#endif
}
}
- if (bfd_get_format (abfd) == bfd_archive
- && abfd->xvec == &mach_o_fat_vec)
- return TRUE;
return _bfd_generic_close_and_cleanup (abfd);
}
#define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
#define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
-#define bfd_mach_o_swap_reloc_in NULL
+#define bfd_mach_o_canonicalize_one_reloc NULL
#define bfd_mach_o_swap_reloc_out NULL
#define bfd_mach_o_print_thread NULL
#define bfd_mach_o_tgt_seg_table NULL
#define TARGET_NAME mach_o_be_vec
#define TARGET_STRING "mach-o-be"
#define TARGET_ARCHITECTURE bfd_arch_unknown
+#define TARGET_PAGESIZE 1
#define TARGET_BIG_ENDIAN 1
#define TARGET_ARCHIVE 0
#define TARGET_PRIORITY 1
#undef TARGET_NAME
#undef TARGET_STRING
#undef TARGET_ARCHITECTURE
+#undef TARGET_PAGESIZE
#undef TARGET_BIG_ENDIAN
#undef TARGET_ARCHIVE
#undef TARGET_PRIORITY
#define TARGET_NAME mach_o_le_vec
#define TARGET_STRING "mach-o-le"
#define TARGET_ARCHITECTURE bfd_arch_unknown
+#define TARGET_PAGESIZE 1
#define TARGET_BIG_ENDIAN 0
#define TARGET_ARCHIVE 0
#define TARGET_PRIORITY 1
#undef TARGET_NAME
#undef TARGET_STRING
#undef TARGET_ARCHITECTURE
+#undef TARGET_PAGESIZE
#undef TARGET_BIG_ENDIAN
#undef TARGET_ARCHIVE
#undef TARGET_PRIORITY
/* Not yet handled: creating an archive. */
#define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
+#define bfd_mach_o_close_and_cleanup bfd_true
+
/* Not used. */
-#define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
-#define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
-#define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
-#define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
-#define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
-#define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
-#define bfd_mach_o_write_armap _bfd_noarchive_write_armap
-#define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
#define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
-#define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
+#define bfd_mach_o_openr_next_archived_file bfd_mach_o_fat_openr_next_archived_file
+#define bfd_mach_o_archive_p bfd_mach_o_fat_archive_p
#define TARGET_NAME mach_o_fat_vec
#define TARGET_STRING "mach-o-fat"
#define TARGET_ARCHITECTURE bfd_arch_unknown
+#define TARGET_PAGESIZE 1
#define TARGET_BIG_ENDIAN 1
#define TARGET_ARCHIVE 1
#define TARGET_PRIORITY 0
#undef TARGET_NAME
#undef TARGET_STRING
#undef TARGET_ARCHITECTURE
+#undef TARGET_PAGESIZE
#undef TARGET_BIG_ENDIAN
#undef TARGET_ARCHIVE
#undef TARGET_PRIORITY