/* Mach-O support for BFD.
- Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+ Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+ 2009, 2010, 2011
Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
#define bfd_mach_o_object_p bfd_mach_o_gen_object_p
#define bfd_mach_o_core_p bfd_mach_o_gen_core_p
-#define bfd_mach_o_mkobject bfd_false
+#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)))
-static int bfd_mach_o_scan_read_symtab_symbols (bfd *);
+static int bfd_mach_o_read_symtab_symbols (bfd *);
unsigned int
bfd_mach_o_version (bfd *abfd)
{
const char *bfd_name;
const char *mach_o_name;
+ flagword flags;
};
static const struct mach_o_section_name_xlat dwarf_section_names_xlat[] =
{
- { ".debug_frame", "__debug_frame" },
- { ".debug_info", "__debug_info" },
- { ".debug_abbrev", "__debug_abbrev" },
- { ".debug_aranges", "__debug_aranges" },
- { ".debug_macinfo", "__debug_macinfo" },
- { ".debug_line", "__debug_line" },
- { ".debug_loc", "__debug_loc" },
- { ".debug_pubnames", "__debug_pubnames" },
- { ".debug_pubtypes", "__debug_pubtypes" },
- { ".debug_str", "__debug_str" },
- { ".debug_ranges", "__debug_ranges" },
- { NULL, NULL}
+ { ".debug_frame", "__debug_frame", SEC_DEBUGGING },
+ { ".debug_info", "__debug_info", SEC_DEBUGGING },
+ { ".debug_abbrev", "__debug_abbrev", SEC_DEBUGGING },
+ { ".debug_aranges", "__debug_aranges", SEC_DEBUGGING },
+ { ".debug_macinfo", "__debug_macinfo", SEC_DEBUGGING },
+ { ".debug_line", "__debug_line", SEC_DEBUGGING },
+ { ".debug_loc", "__debug_loc", SEC_DEBUGGING },
+ { ".debug_pubnames", "__debug_pubnames", SEC_DEBUGGING },
+ { ".debug_pubtypes", "__debug_pubtypes", SEC_DEBUGGING },
+ { ".debug_str", "__debug_str", SEC_DEBUGGING },
+ { ".debug_ranges", "__debug_ranges", SEC_DEBUGGING },
+ { NULL, NULL, 0}
};
static const struct mach_o_section_name_xlat text_section_names_xlat[] =
{
- { ".text", "__text" },
- { ".const", "__const" },
- { ".cstring", "__cstring" },
- { ".eh_frame", "__eh_frame" },
- { NULL, NULL}
+ { ".text", "__text", SEC_CODE | SEC_LOAD },
+ { ".const", "__const", SEC_READONLY | SEC_DATA | SEC_LOAD },
+ { ".cstring", "__cstring", SEC_READONLY | SEC_DATA | SEC_LOAD },
+ { ".eh_frame", "__eh_frame", SEC_READONLY | SEC_LOAD },
+ { NULL, NULL, 0}
};
static const struct mach_o_section_name_xlat data_section_names_xlat[] =
{
- { ".data", "__data" },
- { ".bss", "__bss" },
- { NULL, NULL}
+ { ".data", "__data", SEC_DATA | SEC_LOAD },
+ { ".const_data", "__const", SEC_DATA | SEC_LOAD },
+ { ".dyld", "__dyld", SEC_DATA | SEC_LOAD },
+ { ".lazy_symbol_ptr", "__la_symbol_ptr", SEC_DATA | SEC_LOAD },
+ { ".non_lazy_symbol_ptr", "__nl_symbol_ptr", SEC_DATA | SEC_LOAD },
+ { ".bss", "__bss", SEC_NO_FLAGS },
+ { NULL, NULL, 0}
};
struct mach_o_segment_name_xlat
/* Mach-O to bfd names. */
-static char *
-bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, bfd_mach_o_section *section)
+static void
+bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, bfd_mach_o_section *section,
+ char **name, flagword *flags)
{
const struct mach_o_segment_name_xlat *seg;
char *res;
unsigned int len;
const char *pfx = "";
+ *name = NULL;
+ *flags = SEC_NO_FLAGS;
+
for (seg = segsec_names_xlat; seg->segname; seg++)
{
if (strcmp (seg->segname, section->segname) == 0)
res = bfd_alloc (abfd, len + 1);
if (res == NULL)
- return NULL;
+ return;
strcpy (res, sec->bfd_name);
- return res;
+ *name = res;
+ *flags = sec->flags;
+ return;
}
}
}
res = bfd_alloc (abfd, len);
if (res == NULL)
- return NULL;
+ return;
snprintf (res, len, "%s%s.%s", pfx, section->segname, section->sectname);
- return res;
+ *name = res;
}
/* Convert a bfd section name to a Mach-O segment + section name. */
if (nsyms < 0)
return nsyms;
- if (bfd_mach_o_scan_read_symtab_symbols (abfd) != 0)
+ if (bfd_mach_o_read_symtab_symbols (abfd) != 0)
{
- fprintf (stderr,
- "bfd_mach_o_canonicalize_symtab: unable to load symbols\n");
+ (*_bfd_error_handler) (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
return 0;
}
for (i = 0; i < mdata->nsects; i++)
{
bfd_mach_o_section *sec = mdata->sections[i];
- unsigned int j, first, last;
- bfd_mach_o_symtab_command *symtab = mdata->symtab;
+ unsigned int first, last;
bfd_vma addr;
bfd_vma entry_size;
void
bfd_mach_o_print_symbol (bfd *abfd,
- PTR afile,
+ void * afile,
asymbol *symbol,
bfd_print_symbol_type how)
{
fprintf (file, "%s", symbol->name);
break;
default:
- bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
+ bfd_print_symbol_vandf (abfd, (void *) file, symbol);
if (asym->n_type & BFD_MACH_O_N_STAB)
name = bfd_get_stab_name (asym->n_type);
else
bfd_h_put_32 (abfd, header->reserved, buf + 28);
if (bfd_seek (abfd, 0, SEEK_SET) != 0
- || bfd_bwrite ((PTR) buf, size, abfd) != size)
+ || bfd_bwrite ((void *) buf, size, abfd) != size)
return FALSE;
return TRUE;
}
static int
-bfd_mach_o_scan_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_thread_command *cmd = &command->command.thread;
unsigned int i;
unsigned char buf[8];
unsigned int offset;
- unsigned int nflavours;
BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
|| (command->type == BFD_MACH_O_LC_UNIXTHREAD));
offset = 8;
- nflavours = 0;
for (i = 0; i < cmd->nflavours; i++)
{
BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), buf + 4);
if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
- || bfd_bwrite ((PTR) buf, 8, abfd) != 8)
+ || bfd_bwrite ((void *) buf, 8, abfd) != 8)
return -1;
offset += cmd->flavours[i].size + 8;
res->addend = 0;
res->address = addr;
if (symnum & BFD_MACH_O_R_EXTERN)
- sym = syms + num;
+ {
+ sym = syms + num;
+ reloc.r_extern = 1;
+ }
else
{
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 conventio, substract 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;
+ reloc.r_extern = 0;
}
res->sym_ptr_ptr = sym;
reloc.r_type = BFD_MACH_O_GET_R_TYPE (symnum);
}
static bfd_boolean
-bfd_mach_o_scan_write_relocs (bfd *abfd, bfd_mach_o_section *section)
+bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
unsigned int i;
bfd_put_32 (abfd, v, buf + 4);
}
- if (bfd_bwrite ((PTR) buf, BFD_MACH_O_RELENT_SIZE, abfd)
+ if (bfd_bwrite ((void *) buf, BFD_MACH_O_RELENT_SIZE, abfd)
!= BFD_MACH_O_RELENT_SIZE)
return FALSE;
}
}
static int
-bfd_mach_o_scan_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
+bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
{
unsigned char buf[BFD_MACH_O_SECTION_SIZE];
bfd_h_put_32 (abfd, section->reserved1, buf + 60);
bfd_h_put_32 (abfd, section->reserved2, buf + 64);
- if (bfd_bwrite ((PTR) buf, BFD_MACH_O_SECTION_SIZE, abfd)
+ if (bfd_bwrite ((void *) buf, BFD_MACH_O_SECTION_SIZE, abfd)
!= BFD_MACH_O_SECTION_SIZE)
return -1;
}
static int
-bfd_mach_o_scan_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
+bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
{
unsigned char buf[BFD_MACH_O_SECTION_64_SIZE];
bfd_h_put_32 (abfd, section->reserved2, buf + 72);
bfd_h_put_32 (abfd, section->reserved3, buf + 76);
- if (bfd_bwrite ((PTR) buf, BFD_MACH_O_SECTION_64_SIZE, abfd)
+ if (bfd_bwrite ((void *) buf, BFD_MACH_O_SECTION_64_SIZE, abfd)
!= BFD_MACH_O_SECTION_64_SIZE)
return -1;
}
static int
-bfd_mach_o_scan_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
{
unsigned char buf[BFD_MACH_O_LC_SEGMENT_SIZE];
bfd_mach_o_segment_command *seg = &command->command.segment;
BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
for (i = 0; i < seg->nsects; i++)
- if (!bfd_mach_o_scan_write_relocs (abfd, &seg->sections[i]))
+ if (!bfd_mach_o_write_relocs (abfd, &seg->sections[i]))
return -1;
memcpy (buf, seg->segname, 16);
bfd_h_put_32 (abfd, seg->flags, buf + 44);
if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
- || (bfd_bwrite ((PTR) buf, BFD_MACH_O_LC_SEGMENT_SIZE - 8, abfd)
+ || (bfd_bwrite ((void *) buf, BFD_MACH_O_LC_SEGMENT_SIZE - 8, abfd)
!= BFD_MACH_O_LC_SEGMENT_SIZE - 8))
return -1;
for (i = 0; i < seg->nsects; i++)
- if (bfd_mach_o_scan_write_section_32 (abfd, &seg->sections[i]))
+ if (bfd_mach_o_write_section_32 (abfd, &seg->sections[i]))
return -1;
return 0;
}
static int
-bfd_mach_o_scan_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
{
unsigned char buf[BFD_MACH_O_LC_SEGMENT_64_SIZE];
bfd_mach_o_segment_command *seg = &command->command.segment;
BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
for (i = 0; i < seg->nsects; i++)
- if (!bfd_mach_o_scan_write_relocs (abfd, &seg->sections[i]))
+ if (!bfd_mach_o_write_relocs (abfd, &seg->sections[i]))
return -1;
memcpy (buf, seg->segname, 16);
bfd_h_put_32 (abfd, seg->flags, buf + 60);
if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
- || (bfd_bwrite ((PTR) buf, BFD_MACH_O_LC_SEGMENT_64_SIZE - 8, abfd)
+ || (bfd_bwrite ((void *) buf, BFD_MACH_O_LC_SEGMENT_64_SIZE - 8, abfd)
!= BFD_MACH_O_LC_SEGMENT_64_SIZE - 8))
return -1;
for (i = 0; i < seg->nsects; i++)
- if (bfd_mach_o_scan_write_section_64 (abfd, &seg->sections[i]))
+ if (bfd_mach_o_write_section_64 (abfd, &seg->sections[i]))
return -1;
return 0;
}
static bfd_boolean
-bfd_mach_o_scan_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
bfd_mach_o_symtab_command *sym = &command->command.symtab;
for (i = 0; i < sym->nsyms; i++)
{
- unsigned char buf[16];
- bfd_size_type index;
+ bfd_size_type str_index;
bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
/* Compute name index. */
/* An index of 0 always means the empty string. */
if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
- index = 0;
+ str_index = 0;
else
{
- index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
- if (index == (bfd_size_type) -1)
+ str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
+ if (str_index == (bfd_size_type) -1)
goto err;
}
- bfd_h_put_32 (abfd, index, buf);
+ bfd_h_put_32 (abfd, str_index, buf);
bfd_h_put_8 (abfd, s->n_type, buf + 4);
bfd_h_put_8 (abfd, s->n_sect, buf + 5);
bfd_h_put_16 (abfd, s->n_desc, buf + 6);
else
bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value, buf + 8);
- if (bfd_bwrite ((PTR) buf, symlen, abfd) != symlen)
+ if (bfd_bwrite ((void *) buf, symlen, abfd) != symlen)
goto err;
}
sym->strsize = _bfd_stringtab_size (strtab);
bfd_h_put_32 (abfd, sym->strsize, buf + 12);
if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
- || bfd_bwrite ((PTR) buf, 16, abfd) != 16)
+ || bfd_bwrite ((void *) buf, 16, abfd) != 16)
return FALSE;
return TRUE;
bfd_h_put_32 (abfd, cur->len, buf + 4);
if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0
- || bfd_bwrite ((PTR) buf, 8, abfd) != 8)
+ || bfd_bwrite ((void *) buf, 8, abfd) != 8)
return FALSE;
switch (cur->type)
{
case BFD_MACH_O_LC_SEGMENT:
- if (bfd_mach_o_scan_write_segment_32 (abfd, cur) != 0)
+ if (bfd_mach_o_write_segment_32 (abfd, cur) != 0)
return FALSE;
break;
case BFD_MACH_O_LC_SEGMENT_64:
- if (bfd_mach_o_scan_write_segment_64 (abfd, cur) != 0)
+ if (bfd_mach_o_write_segment_64 (abfd, cur) != 0)
return FALSE;
break;
case BFD_MACH_O_LC_SYMTAB:
- if (!bfd_mach_o_scan_write_symtab (abfd, cur))
+ if (!bfd_mach_o_write_symtab (abfd, cur))
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_scan_write_thread (abfd, cur) != 0)
+ if (bfd_mach_o_write_thread (abfd, cur) != 0)
return FALSE;
break;
case BFD_MACH_O_LC_LOADFVMLIB:
case BFD_MACH_O_LC_SUB_FRAMEWORK:
break;
default:
- fprintf (stderr,
- "unable to write unknown load command 0x%lx\n",
- (unsigned long) cur->type);
+ (*_bfd_error_handler) (_("unable to write unknown load command 0x%lx"),
+ (unsigned long) cur->type);
return FALSE;
}
}
/* Just read the magic number. */
if (bfd_seek (abfd, 0, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 4, abfd) != 4)
+ || bfd_bread ((void *) buf, 4, abfd) != 4)
return FALSE;
if (bfd_getb32 (buf) == BFD_MACH_O_MH_MAGIC)
BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
if (bfd_seek (abfd, 0, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, size, abfd) != size)
+ || bfd_bread ((void *) buf, size, abfd) != size)
return FALSE;
header->cputype = (*get32) (buf + 4);
char *sname;
flagword flags;
- sname = bfd_mach_o_convert_section_name_to_bfd (abfd, section);
+ bfd_mach_o_convert_section_name_to_bfd (abfd, section, &sname, &flags);
if (sname == NULL)
return NULL;
- if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
- flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
+ if (flags == SEC_NO_FLAGS)
+ {
+ /* Try to guess flags. */
+ if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
+ flags = SEC_DEBUGGING;
+ else
+ {
+ flags = SEC_ALLOC;
+ if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
+ != BFD_MACH_O_S_ZEROFILL)
+ {
+ flags |= SEC_LOAD;
+ if (prot & BFD_MACH_O_PROT_EXECUTE)
+ flags |= SEC_CODE;
+ if (prot & BFD_MACH_O_PROT_WRITE)
+ flags |= SEC_DATA;
+ else if (prot & BFD_MACH_O_PROT_READ)
+ flags |= SEC_READONLY;
+ }
+ }
+ }
else
{
- flags = SEC_ALLOC;
- if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
- != BFD_MACH_O_S_ZEROFILL)
- {
- flags |= SEC_HAS_CONTENTS | SEC_LOAD;
- if (prot & BFD_MACH_O_PROT_EXECUTE)
- flags |= SEC_CODE;
- if (prot & BFD_MACH_O_PROT_WRITE)
- flags |= SEC_DATA;
- else if (prot & BFD_MACH_O_PROT_READ)
- flags |= SEC_READONLY;
- }
+ if ((flags & SEC_DEBUGGING) == 0)
+ flags |= SEC_ALLOC;
}
+
+ if (section->offset != 0)
+ flags |= SEC_HAS_CONTENTS;
if (section->nreloc != 0)
flags |= SEC_RELOC;
}
static int
-bfd_mach_o_scan_read_section_32 (bfd *abfd,
- bfd_mach_o_section *section,
- unsigned int offset,
- unsigned long prot)
+bfd_mach_o_read_section_32 (bfd *abfd,
+ bfd_mach_o_section *section,
+ unsigned int offset,
+ unsigned long prot)
{
unsigned char buf[BFD_MACH_O_SECTION_SIZE];
if (bfd_seek (abfd, offset, SEEK_SET) != 0
- || (bfd_bread ((PTR) buf, BFD_MACH_O_SECTION_SIZE, abfd)
+ || (bfd_bread ((void *) buf, BFD_MACH_O_SECTION_SIZE, abfd)
!= BFD_MACH_O_SECTION_SIZE))
return -1;
}
static int
-bfd_mach_o_scan_read_section_64 (bfd *abfd,
- bfd_mach_o_section *section,
- unsigned int offset,
- unsigned long prot)
+bfd_mach_o_read_section_64 (bfd *abfd,
+ bfd_mach_o_section *section,
+ unsigned int offset,
+ unsigned long prot)
{
unsigned char buf[BFD_MACH_O_SECTION_64_SIZE];
if (bfd_seek (abfd, offset, SEEK_SET) != 0
- || (bfd_bread ((PTR) buf, BFD_MACH_O_SECTION_64_SIZE, abfd)
+ || (bfd_bread ((void *) buf, BFD_MACH_O_SECTION_64_SIZE, abfd)
!= BFD_MACH_O_SECTION_64_SIZE))
return -1;
}
static int
-bfd_mach_o_scan_read_section (bfd *abfd,
- bfd_mach_o_section *section,
- unsigned int offset,
- unsigned long prot,
- unsigned int wide)
+bfd_mach_o_read_section (bfd *abfd,
+ bfd_mach_o_section *section,
+ unsigned int offset,
+ unsigned long prot,
+ unsigned int wide)
{
if (wide)
- return bfd_mach_o_scan_read_section_64 (abfd, section, offset, prot);
+ return bfd_mach_o_read_section_64 (abfd, section, offset, prot);
else
- return bfd_mach_o_scan_read_section_32 (abfd, section, offset, prot);
+ return bfd_mach_o_read_section_32 (abfd, section, offset, prot);
}
static int
-bfd_mach_o_scan_read_symtab_symbol (bfd *abfd,
- bfd_mach_o_symtab_command *sym,
- bfd_mach_o_asymbol *s,
- unsigned long i)
+bfd_mach_o_read_symtab_symbol (bfd *abfd,
+ bfd_mach_o_symtab_command *sym,
+ bfd_mach_o_asymbol *s,
+ unsigned long i)
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
unsigned int wide = mach_o_wide_p (&mdata->header);
BFD_ASSERT (sym->strtab != NULL);
if (bfd_seek (abfd, symoff, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, symwidth, abfd) != symwidth)
+ || bfd_bread ((void *) buf, symwidth, abfd) != symwidth)
{
- fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: unable to read %d bytes at %lu\n",
- symwidth, (unsigned long) symoff);
+ (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
+ symwidth, (unsigned long) symoff);
return -1;
}
if (stroff >= sym->strsize)
{
- fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: symbol name out of range (%lu >= %lu)\n",
- (unsigned long) stroff, (unsigned long) sym->strsize);
+ (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: symbol name out of range (%lu >= %lu)"),
+ (unsigned long) stroff,
+ (unsigned long) sym->strsize);
return -1;
}
/* Mach-O uses 0 to mean "no section"; not an error. */
if (section != 0)
{
- fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
- "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined\n",
- s->symbol.name, section, mdata->nsects);
+ (*_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);
}
s->symbol.section = bfd_und_section_ptr;
}
break;
case BFD_MACH_O_N_INDR:
- fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
- "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined\n",
- s->symbol.name);
+ (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
+ "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined"),
+ s->symbol.name);
s->symbol.section = bfd_und_section_ptr;
break;
default:
- fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
- "symbol \"%s\" specified invalid type field 0x%x: setting to undefined\n",
- s->symbol.name, symtype);
+ (*_bfd_error_handler) (_("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;
}
}
static int
-bfd_mach_o_scan_read_symtab_strtab (bfd *abfd)
+bfd_mach_o_read_symtab_strtab (bfd *abfd)
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
bfd_mach_o_symtab_command *sym = mdata->symtab;
return -1;
if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
- || bfd_bread ((PTR) sym->strtab, sym->strsize, abfd) != sym->strsize)
+ || bfd_bread ((void *) sym->strtab, sym->strsize, abfd) != sym->strsize)
{
bfd_set_error (bfd_error_file_truncated);
return -1;
}
static int
-bfd_mach_o_scan_read_symtab_symbols (bfd *abfd)
+bfd_mach_o_read_symtab_symbols (bfd *abfd)
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
bfd_mach_o_symtab_command *sym = mdata->symtab;
if (sym->symbols == NULL)
{
- fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbols: unable to allocate memory for symbols\n");
+ (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
return -1;
}
- ret = bfd_mach_o_scan_read_symtab_strtab (abfd);
+ ret = bfd_mach_o_read_symtab_strtab (abfd);
if (ret != 0)
return ret;
for (i = 0; i < sym->nsyms; i++)
{
- ret = bfd_mach_o_scan_read_symtab_symbol (abfd, sym, &sym->symbols[i], i);
+ ret = bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i);
if (ret != 0)
return ret;
}
}
int
-bfd_mach_o_scan_read_dysymtab_symbol (bfd *abfd,
- bfd_mach_o_dysymtab_command *dysym,
- bfd_mach_o_symtab_command *sym,
- bfd_mach_o_asymbol *s,
- unsigned long i)
+bfd_mach_o_read_dysymtab_symbol (bfd *abfd,
+ bfd_mach_o_dysymtab_command *dysym,
+ bfd_mach_o_symtab_command *sym,
+ bfd_mach_o_asymbol *s,
+ unsigned long i)
{
unsigned long isymoff = dysym->indirectsymoff + (i * 4);
- unsigned long symindex;
+ unsigned long sym_index;
unsigned char buf[4];
BFD_ASSERT (i < dysym->nindirectsyms);
if (bfd_seek (abfd, isymoff, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 4, abfd) != 4)
+ || bfd_bread ((void *) buf, 4, abfd) != 4)
{
- fprintf (stderr, "bfd_mach_o_scan_read_dysymtab_symbol: unable to read %lu bytes at %lu\n",
- (unsigned long) 4, isymoff);
+ (*_bfd_error_handler) (_("bfd_mach_o_read_dysymtab_symbol: unable to read %lu bytes at %lu"),
+ (unsigned long) 4, isymoff);
return -1;
}
- symindex = bfd_h_get_32 (abfd, buf);
+ sym_index = bfd_h_get_32 (abfd, buf);
- return bfd_mach_o_scan_read_symtab_symbol (abfd, sym, s, symindex);
+ return bfd_mach_o_read_symtab_symbol (abfd, sym, s, sym_index);
}
static const char *
}
static int
-bfd_mach_o_scan_read_dylinker (bfd *abfd,
- bfd_mach_o_load_command *command)
+bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
unsigned char buf[4];
|| (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 4, abfd) != 4)
+ || bfd_bread ((void *) buf, 4, abfd) != 4)
return -1;
nameoff = bfd_h_get_32 (abfd, buf + 0);
}
static int
-bfd_mach_o_scan_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_dylib_command *cmd = &command->command.dylib;
unsigned char buf[16];
}
if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 16, abfd) != 16)
+ || bfd_bread ((void *) buf, 16, abfd) != 16)
return -1;
nameoff = bfd_h_get_32 (abfd, buf + 0);
}
static int
-bfd_mach_o_scan_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
- bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
+bfd_mach_o_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
+ bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
{
/* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
}
static int
-bfd_mach_o_scan_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
+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);
bfd_mach_o_thread_command *cmd = &command->command.thread;
return -1;
if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 8, abfd) != 8)
+ || bfd_bread ((void *) buf, 8, abfd) != 8)
return -1;
offset += 8 + bfd_h_get_32 (abfd, buf + 4) * 4;
return -1;
if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 8, abfd) != 8)
+ || bfd_bread ((void *) buf, 8, abfd) != 8)
return -1;
cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, buf);
}
static int
-bfd_mach_o_scan_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 72, abfd) != 72)
+ || bfd_bread ((void *) buf, 72, abfd) != 72)
return -1;
cmd->ilocalsym = bfd_h_get_32 (abfd, buf + 0);
if (cmd->nmodtab != 0)
{
- char buf[56];
unsigned int i;
int wide = bfd_mach_o_wide_p (abfd);
unsigned int module_len = wide ? 56 : 52;
bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
unsigned long v;
- if (bfd_bread ((PTR) buf, module_len, abfd) != module_len)
+ if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
return -1;
module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
if (cmd->ntoc != 0)
{
- char buf[8];
unsigned int i;
cmd->dylib_toc = bfd_alloc
{
bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
- if (bfd_bread ((PTR) buf, 8, abfd) != 8)
+ if (bfd_bread ((void *) buf, 8, abfd) != 8)
return -1;
toc->symbol_index = bfd_h_get_32 (abfd, buf + 0);
if (cmd->nindirectsyms != 0)
{
- char buf[4];
unsigned int i;
cmd->indirect_syms = bfd_alloc
{
unsigned int *is = &cmd->indirect_syms[i];
- if (bfd_bread ((PTR) buf, 4, abfd) != 4)
+ if (bfd_bread ((void *) buf, 4, abfd) != 4)
return -1;
*is = bfd_h_get_32 (abfd, buf + 0);
if (cmd->nextrefsyms != 0)
{
- char buf[4];
unsigned long v;
unsigned int i;
{
bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
- if (bfd_bread ((PTR) buf, 4, abfd) != 4)
+ if (bfd_bread ((void *) buf, 4, abfd) != 4)
return -1;
/* Fields isym and flags are written as bit-fields, thus we need
}
static int
-bfd_mach_o_scan_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_symtab_command *symtab = &command->command.symtab;
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 16, abfd) != 16)
+ || bfd_bread ((void *) buf, 16, abfd) != 16)
return -1;
symtab->symoff = bfd_h_get_32 (abfd, buf);
}
static int
-bfd_mach_o_scan_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_uuid_command *cmd = &command->command.uuid;
- asection *bfdsec;
- char *sname;
- static const char prefix[] = "LC_UUID";
BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
- || bfd_bread ((PTR) cmd->uuid, 16, abfd) != 16)
- return -1;
-
- sname = bfd_alloc (abfd, strlen (prefix) + 1);
- if (sname == NULL)
+ || bfd_bread ((void *) cmd->uuid, 16, abfd) != 16)
return -1;
- strcpy (sname, prefix);
-
- bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, SEC_HAS_CONTENTS);
- if (bfdsec == NULL)
- return -1;
-
- bfdsec->vma = 0;
- bfdsec->lma = 0;
- bfdsec->size = command->len - 8;
- bfdsec->filepos = command->offset + 8;
- bfdsec->alignment_power = 0;
-
- cmd->section = bfdsec;
return 0;
}
static int
-bfd_mach_o_scan_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
char buf[8];
if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 8, abfd) != 8)
+ || bfd_bread ((void *) buf, 8, abfd) != 8)
return -1;
cmd->dataoff = bfd_get_32 (abfd, buf + 0);
}
static int
-bfd_mach_o_scan_read_str (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
{
bfd_mach_o_str_command *cmd = &command->command.str;
char buf[4];
unsigned long off;
if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 4, abfd) != 4)
+ || bfd_bread ((void *) buf, 4, abfd) != 4)
return -1;
off = bfd_get_32 (abfd, buf + 0);
if (cmd->str == NULL)
return -1;
if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
- || bfd_bread ((PTR) cmd->str, cmd->str_len, abfd) != cmd->str_len)
+ || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
return -1;
return 0;
}
static int
-bfd_mach_o_scan_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
+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;
char buf[40];
if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, sizeof (buf), abfd) != sizeof (buf))
+ || bfd_bread ((void *) buf, sizeof (buf), abfd) != sizeof (buf))
return -1;
cmd->rebase_off = bfd_get_32 (abfd, buf + 0);
}
static int
-bfd_mach_o_scan_read_segment (bfd *abfd,
- bfd_mach_o_load_command *command,
- unsigned int wide)
+bfd_mach_o_read_segment (bfd *abfd,
+ bfd_mach_o_load_command *command,
+ unsigned int wide)
{
unsigned char buf[64];
bfd_mach_o_segment_command *seg = &command->command.segment;
BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 64, abfd) != 64)
+ || bfd_bread ((void *) buf, 64, abfd) != 64)
return -1;
memcpy (seg->segname, buf, 16);
BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 48, abfd) != 48)
+ || bfd_bread ((void *) buf, 48, abfd) != 48)
return -1;
memcpy (seg->segname, buf, 16);
segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
+ (i * BFD_MACH_O_SECTION_SIZE);
- if (bfd_mach_o_scan_read_section
+ if (bfd_mach_o_read_section
(abfd, &seg->sections[i], segoff, seg->initprot, wide) != 0)
return -1;
}
}
static int
-bfd_mach_o_scan_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
{
- return bfd_mach_o_scan_read_segment (abfd, command, 0);
+ return bfd_mach_o_read_segment (abfd, command, 0);
}
static int
-bfd_mach_o_scan_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
{
- return bfd_mach_o_scan_read_segment (abfd, command, 1);
+ return bfd_mach_o_read_segment (abfd, command, 1);
}
static int
-bfd_mach_o_scan_read_command (bfd *abfd, bfd_mach_o_load_command *command)
+bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
{
unsigned char buf[8];
/* Read command type and length. */
if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 8, abfd) != 8)
+ || bfd_bread ((void *) buf, 8, abfd) != 8)
return -1;
command->type = bfd_h_get_32 (abfd, buf) & ~BFD_MACH_O_LC_REQ_DYLD;
switch (command->type)
{
case BFD_MACH_O_LC_SEGMENT:
- if (bfd_mach_o_scan_read_segment_32 (abfd, command) != 0)
+ if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
return -1;
break;
case BFD_MACH_O_LC_SEGMENT_64:
- if (bfd_mach_o_scan_read_segment_64 (abfd, command) != 0)
+ if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
return -1;
break;
case BFD_MACH_O_LC_SYMTAB:
- if (bfd_mach_o_scan_read_symtab (abfd, command) != 0)
+ if (bfd_mach_o_read_symtab (abfd, command) != 0)
return -1;
break;
case BFD_MACH_O_LC_SYMSEG:
break;
case BFD_MACH_O_LC_THREAD:
case BFD_MACH_O_LC_UNIXTHREAD:
- if (bfd_mach_o_scan_read_thread (abfd, command) != 0)
+ if (bfd_mach_o_read_thread (abfd, command) != 0)
return -1;
break;
case BFD_MACH_O_LC_LOAD_DYLINKER:
case BFD_MACH_O_LC_ID_DYLINKER:
- if (bfd_mach_o_scan_read_dylinker (abfd, command) != 0)
+ if (bfd_mach_o_read_dylinker (abfd, command) != 0)
return -1;
break;
case BFD_MACH_O_LC_LOAD_DYLIB:
case BFD_MACH_O_LC_ID_DYLIB:
case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
case BFD_MACH_O_LC_REEXPORT_DYLIB:
- if (bfd_mach_o_scan_read_dylib (abfd, command) != 0)
+ if (bfd_mach_o_read_dylib (abfd, command) != 0)
return -1;
break;
case BFD_MACH_O_LC_PREBOUND_DYLIB:
- if (bfd_mach_o_scan_read_prebound_dylib (abfd, command) != 0)
+ if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
return -1;
break;
case BFD_MACH_O_LC_LOADFVMLIB:
case BFD_MACH_O_LC_SUB_UMBRELLA:
case BFD_MACH_O_LC_SUB_LIBRARY:
case BFD_MACH_O_LC_SUB_CLIENT:
- if (bfd_mach_o_scan_read_str (abfd, command) != 0)
+ case BFD_MACH_O_LC_RPATH:
+ if (bfd_mach_o_read_str (abfd, command) != 0)
return -1;
break;
case BFD_MACH_O_LC_DYSYMTAB:
- if (bfd_mach_o_scan_read_dysymtab (abfd, command) != 0)
+ if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
return -1;
break;
case BFD_MACH_O_LC_TWOLEVEL_HINTS:
case BFD_MACH_O_LC_PREBIND_CKSUM:
break;
case BFD_MACH_O_LC_UUID:
- if (bfd_mach_o_scan_read_uuid (abfd, command) != 0)
+ if (bfd_mach_o_read_uuid (abfd, command) != 0)
return -1;
break;
case BFD_MACH_O_LC_CODE_SIGNATURE:
case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
- if (bfd_mach_o_scan_read_linkedit (abfd, command) != 0)
+ if (bfd_mach_o_read_linkedit (abfd, command) != 0)
return -1;
break;
case BFD_MACH_O_LC_DYLD_INFO:
- if (bfd_mach_o_scan_read_dyld_info (abfd, command) != 0)
+ if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
return -1;
break;
default:
- fprintf (stderr, "unable to read unknown load command 0x%lx\n",
- (unsigned long) command->type);
+ (*_bfd_error_handler) (_("unable to read unknown load command 0x%lx"),
+ (unsigned long) command->type);
break;
}
return 0;
}
+bfd_boolean
+bfd_mach_o_set_arch_mach (bfd *abfd,
+ enum bfd_architecture arch,
+ unsigned long machine)
+{
+ bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
+
+ /* If this isn't the right architecture for this backend, and this
+ isn't the generic backend, fail. */
+ if (arch != bed->arch
+ && arch != bfd_arch_unknown
+ && bed->arch != bfd_arch_unknown)
+ return FALSE;
+
+ return bfd_default_set_arch_mach (abfd, arch, machine);
+}
+
int
bfd_mach_o_scan (bfd *abfd,
bfd_mach_o_header *header,
&cputype, &cpusubtype);
if (cputype == bfd_arch_unknown)
{
- fprintf (stderr, "bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx\n",
- header->cputype, header->cpusubtype);
+ (*_bfd_error_handler) (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
+ header->cputype, header->cpusubtype);
return -1;
}
cur->offset = prev->offset + prev->len;
}
- if (bfd_mach_o_scan_read_command (abfd, cur) < 0)
+ if (bfd_mach_o_read_command (abfd, cur) < 0)
return -1;
}
}
return TRUE;
}
+static bfd_boolean
+bfd_mach_o_gen_mkobject (bfd *abfd)
+{
+ bfd_mach_o_data_struct *mdata;
+
+ if (!bfd_mach_o_mkobject_init (abfd))
+ return FALSE;
+
+ mdata = bfd_mach_o_get_data (abfd);
+ mdata->header.magic = BFD_MACH_O_MH_MAGIC;
+ mdata->header.cputype = 0;
+ mdata->header.cpusubtype = 0;
+ mdata->header.byteorder = abfd->xvec->byteorder;
+ mdata->header.version = 1;
+
+ return TRUE;
+}
+
const bfd_target *
bfd_mach_o_header_p (bfd *abfd,
bfd_mach_o_filetype filetype,
if (! (header.byteorder == BFD_ENDIAN_BIG
|| header.byteorder == BFD_ENDIAN_LITTLE))
{
- fprintf (stderr, "unknown header byte-order value 0x%lx\n",
- (unsigned long) header.byteorder);
+ (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
+ (unsigned long) header.byteorder);
goto wrong;
}
unsigned long i;
if (bfd_seek (abfd, 0, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 8, abfd) != 8)
+ || bfd_bread ((void *) buf, 8, abfd) != 8)
goto error;
adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
for (i = 0; i < adata->nfat_arch; i++)
{
if (bfd_seek (abfd, 8 + 20 * i, SEEK_SET) != 0
- || bfd_bread ((PTR) buf, 20, abfd) != 20)
+ || bfd_bread ((void *) buf, 20, abfd) != 20)
goto error;
adata->archentries[i].cputype = bfd_getb32 (buf);
adata->archentries[i].cpusubtype = bfd_getb32 (buf + 4);
|| dysymtab->nextrefsyms > 0)
{
/* Try to read the symbols to display the toc or indirect symbols. */
- bfd_mach_o_scan_read_symtab_symbols (abfd);
+ bfd_mach_o_read_symtab_symbols (abfd);
}
else if (dysymtab->nmodtab > 0)
{
/* Try to read the strtab to display modules name. */
- bfd_mach_o_scan_read_symtab_strtab (abfd);
+ bfd_mach_o_read_symtab_strtab (abfd);
}
for (i = 0; i < dysymtab->nmodtab; i++)
}
bfd_boolean
-bfd_mach_o_bfd_print_private_bfd_data (bfd *abfd, PTR ptr)
+bfd_mach_o_bfd_print_private_bfd_data (bfd *abfd, void * ptr)
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
FILE *file = (FILE *) ptr;
case BFD_MACH_O_LC_UUID:
{
bfd_mach_o_uuid_command *uuid = &cmd->command.uuid;
- unsigned int i;
+ unsigned int j;
- for (i = 0; i < sizeof (uuid->uuid); i++)
- fprintf (file, " %02x", uuid->uuid[i]);
+ for (j = 0; j < sizeof (uuid->uuid); j ++)
+ fprintf (file, " %02x", uuid->uuid[j]);
fputc ('\n', file);
}
break;
case BFD_MACH_O_LC_SUB_UMBRELLA:
case BFD_MACH_O_LC_SUB_LIBRARY:
case BFD_MACH_O_LC_SUB_CLIENT:
+ case BFD_MACH_O_LC_RPATH:
{
bfd_mach_o_str_command *str = &cmd->command.str;
fprintf (file, " %s\n", str->str);
#define TARGET_NAME mach_o_be_vec
#define TARGET_STRING "mach-o-be"
+#define TARGET_ARCHITECTURE bfd_arch_unknown
#define TARGET_BIG_ENDIAN 1
#define TARGET_ARCHIVE 0
#include "mach-o-target.c"
#undef TARGET_NAME
#undef TARGET_STRING
+#undef TARGET_ARCHITECTURE
#undef TARGET_BIG_ENDIAN
#undef TARGET_ARCHIVE
#define TARGET_NAME mach_o_le_vec
#define TARGET_STRING "mach-o-le"
+#define TARGET_ARCHITECTURE bfd_arch_unknown
#define TARGET_BIG_ENDIAN 0
#define TARGET_ARCHIVE 0
#undef TARGET_NAME
#undef TARGET_STRING
+#undef TARGET_ARCHITECTURE
#undef TARGET_BIG_ENDIAN
#undef TARGET_ARCHIVE
+/* Not yet handled: creating an archive. */
+#define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
+
+/* 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_noarchive_generic_stat_arch_elt
+#define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
+
#define TARGET_NAME mach_o_fat_vec
#define TARGET_STRING "mach-o-fat"
+#define TARGET_ARCHITECTURE bfd_arch_unknown
#define TARGET_BIG_ENDIAN 1
#define TARGET_ARCHIVE 1
#undef TARGET_NAME
#undef TARGET_STRING
+#undef TARGET_ARCHITECTURE
#undef TARGET_BIG_ENDIAN
#undef TARGET_ARCHIVE
projects / binutils-gdb.git / blobdiff