+ {
+ 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;
+ }
+
+ /* 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_layout_commands (bfd_mach_o_data_struct *mdata)
+{
+ 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;
+
+ for (cmd = mdata->first_command; cmd; cmd = cmd->next)
+ {
+ mdata->header.ncmds++;
+ cmd->offset = offset;
+
+ switch (cmd->type)
+ {
+ 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;
+ }
+
+ BFD_ASSERT (cmd->len % (align + 1) == 0);
+ offset += cmd->len;
+ }
+ mdata->header.sizeofcmds = offset - hdrlen;
+ mdata->filelen = offset;
+
+ return ret;
+}
+
+/* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
+ segment. */
+
+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);
+
+ /* Init segment command. */
+ cmd->type = wide ? BFD_MACH_O_LC_SEGMENT_64 : BFD_MACH_O_LC_SEGMENT;
+ cmd->type_required = FALSE;
+
+ strcpy (seg->segname, segname);
+ seg->nsects = nbr_sect;
+
+ seg->vmaddr = 0;
+ seg->vmsize = 0;
+
+ 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).
+ TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
+ and copy functionality. */
+
+bfd_boolean
+bfd_mach_o_build_commands (bfd *abfd)
+{
+ bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
+ unsigned wide = mach_o_wide_p (&mdata->header);
+ unsigned int nbr_segcmd = 0;
+ bfd_mach_o_load_command *commands;
+ unsigned int nbr_commands;
+ int symtab_idx = -1;
+ int dysymtab_idx = -1;
+ int main_idx = -1;
+ unsigned int i;
+
+ /* 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)
+ mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
+ else if (abfd->flags & DYNAMIC)
+ mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
+ else
+ mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
+ }
+
+ /* If hasn't already been done, flatten sections list, and sort
+ if/when required. Must be done before the symbol table is adjusted,
+ since that depends on properly numbered sections. */
+ if (mdata->nsects == 0 || mdata->sections == NULL)
+ if (! bfd_mach_o_mangle_sections (abfd, mdata))
+ return FALSE;
+
+ /* Order the symbol table, fill-in/check mach-o specific fields and
+ partition out any indirect symbols. */
+ if (!bfd_mach_o_mangle_symbols (abfd))
+ return FALSE;
+
+ /* 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;
+
+ /* One pagezero segment and one linkedit segment. */
+ nbr_segcmd = 2;
+
+ /* 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 (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)
+ 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))
+ {
+ /* If there should be a case where a dysymtab could be emitted without
+ a symtab (seems improbable), this would need amending. */
+ dysymtab_idx = nbr_commands++;
+ }
+
+ /* 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 = 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 (nbr_commands == 0)
+ {
+ /* Layout commands (well none...) and set headers command fields. */
+ return bfd_mach_o_layout_commands (mdata);
+ }
+
+ /* 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;
+ 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)
+ {
+ /* 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;
+
+ BFD_ASSERT (nbr_segcmd >= 2);
+
+ /* The pagezero. */
+ cmd = &commands[0];
+ bfd_mach_o_init_segment (mdata, cmd, "__PAGEZERO", 0);
+
+ /* Segments from sections. */
+ cmd++;
+ for (i = 0; i < mdata->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++;
+ }
+
+ /* The linkedit. */
+ bfd_mach_o_init_segment (mdata, cmd, "__LINKEDIT", 0);
+ }
+
+ if (symtab_idx >= 0)
+ {
+ /* Init symtab command. */
+ bfd_mach_o_load_command *cmd = &commands[symtab_idx];
+
+ cmd->type = BFD_MACH_O_LC_SYMTAB;
+ cmd->type_required = FALSE;
+ }
+
+ /* If required, setup symtab command, see comment above about the quality
+ of this test. */
+ if (dysymtab_idx >= 0)
+ {
+ bfd_mach_o_load_command *cmd = &commands[dysymtab_idx];
+
+ cmd->type = BFD_MACH_O_LC_DYSYMTAB;
+ cmd->type_required = FALSE;
+ }
+
+ /* 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;
+
+ 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 (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;
+
+ /* 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;
+ }