Patchwork [Darwin/libiberty] fix target/48108 by adding a section wrapper scheme to the darwin port.

login
register
mail settings
Submitter IainS
Date Sept. 29, 2011, 8:27 a.m.
Message ID <9A9A82F6-5525-4ABD-AFEB-F1535E786262@sandoe-acoustics.co.uk>
Download mbox | patch
Permalink /patch/116924/
State New
Headers show

Comments

IainS - Sept. 29, 2011, 8:27 a.m.
It appears that the number of sections in a mach-o file is to be  
limited to 256.
Whilst we all (probably) agree that the documentation is not clear  
about this, there is likely little point in jumping up and down...

It's a show-stopper for LTO with current darwin tool-chains where 'as'  
errors-out for section count > 256.

... so here is a patch that implements a wrapper scheme on top of mach- 
o (used presently only for LTO - but in the most general sense  
available elsewhere to mach-o should the problem re-emerge).

The scheme is switched on by specifying a segment name to  
simple_object_mach_o_match () and always for the __GNU_LTO segment in  
darwin.c.

When the scheme is engaged, three sections are expected within the  
specified segment: an index, a name table and a 'sects' section.

All the section data from the segment are concatenated within the  
'sects' section with the offset to each 'input section', its length  
and its name recorded in the index.  The names themselves are stored  
in a separate table, with identical layout to the original scheme that  
allowed arbitrary section name lengths to be used with mach-o.

I guess that one might consider adding some padding to the index to  
cater for a possible future use of flags or alignment info (but I  
haven't done that at this stage).

Whilst it is darwin-specific, it does need to touch the simple-object  
stuff in libiberty - so I need approval there.

tested with bootstrap-lto across the darwin9, 10 and 11 range on 4.6  
and trunk (11 on trunk only).
The 4.6 tests included Ada, (but Ada won't 'bootstrap-lto' on trunk at  
present for unrelated reasons).

OK for trunk and 4.6 ?
Iain

libiberty:

	PR target/48108
	* simple-object-mach-o.c (GNU_SECTION_NAMES): Remove.
	(GNU_WRAPPER_SECTS, GNU_WRAPPER_INDEX,
	GNU_WRAPPER_NAMES): New macros.
	(simple_object_mach_o_match): Amend comment and error message.
	Do not require that a segment name is specified.
	(simple_object_mach_o_segment): Handle wrapper scheme, if a segment  
name is
	specified.  (simple_object_mach_o_write_section_header): Allow the  
segment name
	to be supplied. (simple_object_mach_o_write_segment): Handle wrapper  
scheme, if
	a segment name is specified.  Ensure that the top-level segment name  
in the load
	command is empty.   (simple_object_mach_o_write_to_file): Determine the
	number of sections during segment output, use that in writing the  
header.

gcc:

	PR target/48108
	* config/darwin.c (top level): Amend comments concerning LTO output.
	(lto_section_num): New variable.  (darwin_lto_section_e): New GTY.
	(LTO_SECTS_SECTION, LTO_INDEX_SECTION): New.
	(LTO_NAMES_SECTION): Rename.
	(darwin_asm_named_section): Record LTO section counts and switches
	in a vec of darwin_lto_section_e.
	(darwin_file_start): Remove unused code.
	(darwin_file_end): Put an LTO section termination label.  Handle output
	of the wrapped LTO sections, index and names table.
	
include:

	PR target/48108
	*simple-object.h: Amend comments for simple read/write to note the
	wrapper scheme for Mach-o.
Mike Stump - Sept. 29, 2011, 11 a.m.
On Sep 29, 2011, at 1:27 AM, Iain Sandoe wrote:
> ... so here is a patch that implements a wrapper scheme on top of mach-o (used presently only for LTO - but in the most general sense available elsewhere to mach-o should the problem re-emerge).

> OK for trunk and 4.6 ?

Ok for all my bits.  I don't know if others want me to own the darwin bits in libiberty, or if they want to own them...  I'll let them chime in.
Ian Lance Taylor - Sept. 29, 2011, 11 p.m.
Iain Sandoe <developer@sandoe-acoustics.co.uk> writes:


This patch looks basically OK but it seems to have a number of
extraneous changes which make it harder to review.


> libiberty:
>
> 	PR target/48108
> 	* simple-object-mach-o.c (GNU_SECTION_NAMES): Remove.
> 	(GNU_WRAPPER_SECTS, GNU_WRAPPER_INDEX,
> 	GNU_WRAPPER_NAMES): New macros.
> 	(simple_object_mach_o_match): Amend comment and error message.
> 	Do not require that a segment name is specified.
> 	(simple_object_mach_o_segment): Handle wrapper scheme, if a
> segment name is
> 	specified.  (simple_object_mach_o_write_section_header): Allow
> the segment name
> 	to be supplied. (simple_object_mach_o_write_segment): Handle
> wrapper scheme, if
> 	a segment name is specified.  Ensure that the top-level
> segment name in the load
> 	command is empty.   (simple_object_mach_o_write_to_file): Determine the
> 	number of sections during segment output, use that in writing
> the header.
>
> gcc:
>
> 	PR target/48108
> 	* config/darwin.c (top level): Amend comments concerning LTO output.
> 	(lto_section_num): New variable.  (darwin_lto_section_e): New GTY.
> 	(LTO_SECTS_SECTION, LTO_INDEX_SECTION): New.
> 	(LTO_NAMES_SECTION): Rename.
> 	(darwin_asm_named_section): Record LTO section counts and switches
> 	in a vec of darwin_lto_section_e.
> 	(darwin_file_start): Remove unused code.
> 	(darwin_file_end): Put an LTO section termination label.  Handle output
> 	of the wrapped LTO sections, index and names table.
> 	
> include:
>
> 	PR target/48108
> 	*simple-object.h: Amend comments for simple read/write to note the
> 	wrapper scheme for Mach-o.

Space after '*'.


> -#define GNU_SECTION_NAMES "__section_names"

Are we sure it is OK to drop support for __section_names?  Won't that
mean that any old LTO files will not work with new gcc?  Is that OK?


> @@ -258,18 +274,10 @@ simple_object_mach_o_match (
>      }
>  #endif
>  
> -  /* We require the user to provide a segment name.  This is
> -     unfortunate but I don't see any good choices here.  */
> -
> -  if (segment_name == NULL)
> +  /* Although a standard MH_OBJECT has a single anonymous segment, we allow
> +     a segment name to be specified - but don't act on it at this stage.  */
> +  if (segment_name && strlen (segment_name) > MACH_O_NAME_LEN)
>      {
> -      *errmsg = "Mach-O file found but no segment name specified";
> -      *err = 0;
> -      return NULL;
> -    }
> -
> -  if (strlen (segment_name) > MACH_O_NAME_LEN)
> -    {
>        *errmsg = "Mach-O segment name too long";
>        *err = 0;
>        return NULL;

Please write "segment_name != NULL &&", not just "segment_name &&".



> @@ -294,13 +302,14 @@ simple_object_mach_o_match (
>    filetype = (*fetch_32) (b + offsetof (struct mach_o_header_32, filetype));
>    if (filetype != MACH_O_MH_OBJECT)
>      {
> -      *errmsg = "Mach-O file is not object file";
> +      *errmsg = "Mach-O file is not an MH_OBJECT file";
>        *err = 0;
>        return NULL;
>      }

I'm not sure this error message change is an improvement.  This error
message may be seen by end users, not just developers.  I think more end
users will understand "object file."  Why do you want to make this
change?


>    omr = XNEW (struct simple_object_mach_o_read);
> -  omr->segment_name = xstrdup (segment_name);
> +  if (segment_name)
> +    omr->segment_name = xstrdup (segment_name);
>    omr->magic = magic;
>    omr->is_big_endian = is_big_endian;
>    omr->cputype = (*fetch_32) (b + offsetof (struct mach_o_header_32, cputype));

Please write "if (segment_name != NULL)".


> @@ -356,9 +365,25 @@ simple_object_mach_o_section_info (int is_big_endi
>      }
>  }
>  
> -/* Handle a segment in a Mach-O file.  Return 1 if we should continue,
> -   0 if the caller should return.  */
> +/* Handle a segment in a Mach-O Object file.
>  
> +   This will callback to the function pfn for each "section found" the meaning
> +   of which depends on a gnu extension to mach-o:
> +   
> +   When omr->segment_name is specified, we implement a wrapper scheme (which
> +   whilst it will, in principle, work with any segment name, is likely to be
> +   meaningless current for anything except __GNU_LTO).
> +   
> +   If we find mach-o sections (with the segment name as specified) which also
> +   contain: a 'sects' wrapper, an index, and a  name table, we expand this into
> +   as many sections as are specified in the index.  In this case, there will
> +   be a callback for each of these.
> +   
> +   When the omr->segment_name is not specified, then we would call-back for
> +   every mach-o section specified in the file.
> +
> +   Return 1 if we should continue, 0 if the caller should return.  */

Is there a reason that you are changing the code to support not
specifying a segment?  Should that be a separate change?


> @@ -375,12 +400,19 @@ simple_object_mach_o_segment (simple_object_read *
>    size_t sechdrsize;
>    size_t segname_offset;
>    size_t sectname_offset;
> -  unsigned int nsects;
> -  unsigned char *secdata;
> -  unsigned int i;
> -  unsigned int strtab_index;
> -  char *strtab;
> -  size_t strtab_size;
> +  int nsects;

Why change the type?

> +  unsigned char *secdata = NULL;

Why initialize?

> +  int i;

Why change the type?

> +  int strtab_index, index_index, sections_index;

Please put all variables in separate lines, like the existing code.

> +  char *strtab = NULL;
> +  size_t strtab_size = 0;
> +  unsigned char *index = NULL;
> +  size_t index_size;
> +  unsigned int n_wrapped_sects = 0;
> +  size_t wrapper_sect_size = 0;
> +  off_t wrapper_sect_offset = (off_t)0;
> +  int wrapping = (omr->segment_name && strlen (omr->segment_name) > 0);
> +  strtab_index = index_index = sections_index = -1;

Please initialize variables where they are used, not at the start of the
function.

Please write "omr->segment_name != NULL &&".  Please don't test whether
omr->segment_name is the empty string.  The description of the function
does not make a special case for an empty segment name, so I don't see
why this code should.  If you do need to for the empty string for some
reason, please write "omr->segment_name[0] != '\0'", not "strlen
(omr->segment_name) > 0".


>    /* Process the sections.  */
> -
>    for (i = 0; i < nsects; ++i)
>      {
>        const unsigned char *sechdr;

Please leave the blank line.


> -      char namebuf[MACH_O_NAME_LEN + 1];
> +      char namebuf[MACH_O_NAME_LEN*2 + 2]; /* space for segment,section\0.  */

Please put spaces around '*'.


> +      /* Otherwise, make a name like __segment,__section as per the convention
> +         in mach-o asm.  */
> +      memset (namebuf, 0, MACH_O_NAME_LEN*2+2);

Please put spaces around '*' and '+'.


> +      memcpy (namebuf, (char *) sechdr + segname_offset, MACH_O_NAME_LEN);
> +      l = strlen (namebuf);
> +      namebuf[l] = ',';
> +      memcpy (namebuf, (char *) sechdr + sectname_offset, MACH_O_NAME_LEN);

This is clearly wrong.  The last line should be namebuf + l.  But as
noted above I'm not sure why you need this functionality at all.



> +/* Write out the single (anonymous) segment containing the sections of a Mach-O
> +   Object file.
> +   
> +   As a GNU extension to mach-o, when the caller specifies a segment name in
> +   sobj->segment_name, all the sections passed will be output under a single
> +   mach-o section header.  The caller's sections are indexed within this 
> +   'wrapper' section by a table stored in a second mach-o section.  Finally,
> +   arbitrary length section names are permitted by the extension and these are
> +   stored in a table in a third mach-o section.
> +   
> +   Note that this is only likely to make any sense for the __GNU_LTO segment
> +   at present.
> +   
> +   If the segment_name is not specified (or zero-length) we just write out the 
> +   sections as we find them.  In that case we assume that the section name is 
> +   in the form __SEGMENT_NAME,__section_name as per Mach-O asm.  */

Why implement the case of segment_name == NULL?  Why make a zero-length
segment name a special case?  If you need to handle a zero-length
segment name for some reason, you need to document that in
libiberty/simple-object.h.


> +  int wrapping = (sobj->segment_name && strlen (sobj->segment_name) > 0);
> +  size_t nsects_in;
> +  uint32_t *index = NULL;
> +  char *snames = NULL;
> +  unsigned int sect;

If you need to test the length, test using [0], not strlen, as per
above.

Please initialize variables where you need them.

The libiberty library is meant to be highly portable, which means that
types like "uint32_t" are not available.  Just use "unsigned int".



> +  /* Count the number of sections we start with.  */
> +  for (section = sobj->sections; section != NULL;section = section->next)
> +    nsects_in++;

Please add a space after the second semicolon.


> +      for (section = sobj->sections, sect = 0; section != NULL;
> +	   section = section->next, sect++)

Please break the line after the first semicolon.


> +      else
> +	{
> +	  char namebuf[MACH_O_NAME_LEN + 1];
> +	  char segnbuf[MACH_O_NAME_LEN + 1];
> +	  char *comma;
> +	  /* Try to extract segment,section from the input name.  */
> +	  memset (namebuf, 0, sizeof namebuf);
> +	  memset (segnbuf, 0, sizeof segnbuf);
> +	  comma = strchr (section->name, ',');

Please add an empty blank line after the variable declarations.

> +	  if (comma)

Please write "comma != NULL".

> +	    {
> +	      int len = comma-section->name;

Please put spaces around the '-'.

> +	      len = len > MACH_O_NAME_LEN ? MACH_O_NAME_LEN : len;
> +	      if (len)
> +	        strncpy (namebuf, section->name, len);

Please write "len > 0".  But really you don't have to test this as
strncpy will do the right thing.

> +	      strncpy (segnbuf, comma+1, MACH_O_NAME_LEN);

Please put spaces around the '+'.

> +  if (wrapping)
> +    {
> +      size_t secsize;
> +      int i;
> +      /* Write the section header for the wrapper.  */
> +      /* Account for any initial aligment - which becomes the alignment for this
> +	 created section.  */
> +      secsize = (offset - index[0]); 

Please put a blank line after the variable declarations.

> +      /* Subtract the wrapper section start from the begining of each sub
> +	 section.  */
> +      for (i=1; i<nsects_in;i++)

Please put spaces around '=', around '<', and a space after the second
semicolon.

> +      /* Now do the index, we'll align this to 4 bytes although the read code
> +	 will handle unaligned.  */
> +      offset += 3; offset &= ~0x03;

Please break the line after the first semicolon.

Ian
IainS - Sept. 29, 2011, 11:33 p.m.
Hello Ian,

I'll re-jig with the typographical changes (sorry that were so  
many ... )
... and re-post - but I'd like to clear up a couple of points first.

On 30 Sep 2011, at 00:00, Ian Lance Taylor wrote:
>> -#define GNU_SECTION_NAMES "__section_names"
>
> Are we sure it is OK to drop support for __section_names?  Won't that
> mean that any old LTO files will not work with new gcc?  Is that OK?

I was under the impression that an lto built with an earlier revision  
of gcc would not interwork anyway.

If that is mistaken, then we could re-enable the option to allow both  
(I had that in the previous version, in fact).

>> +   If we find mach-o sections (with the segment name as specified)  
>> which also
>> +   contain: a 'sects' wrapper, an index, and a  name table, we  
>> expand this into
>> +   as many sections as are specified in the index.  In this case,  
>> there will
>> +   be a callback for each of these.
>> +
>> +   When the omr->segment_name is not specified, then we would call- 
>> back for
>> +   every mach-o section specified in the file.
>> +
>> +   Return 1 if we should continue, 0 if the caller should return.   
>> */
>
> Is there a reason that you are changing the code to support not
> specifying a segment?  Should that be a separate change?

I'll separate it out.
I think that it could help us build some small tools to assist in  
making GCC output more closely match what the system tool-chain is  
expecting (e.g. stripping off LTO sections).  But that would require  
being able to read all sections as they come and then apply a filter.

Perhaps it's just better to invest the time in BFD, but that does mean  
the user having to build a second set of stuff or a combined tree.

thanks for reviewing and sorry about the number of trivial errors.

Iain

Patch

Index: libiberty/simple-object-mach-o.c
===================================================================
--- libiberty/simple-object-mach-o.c	(revision 179332)
+++ libiberty/simple-object-mach-o.c	(working copy)
@@ -170,9 +170,14 @@  struct mach_o_section_64
 
 #define MACH_O_NAME_LEN (16)
 
-/* A GNU specific extension for long section names.  */
+/* A GNU-specific extension to wrap multiple sections using three 
+   mach-o sections within a given segment.  The section '__wrapper_sects'
+   is subdivided according to the index '__wrapper_index' and each sub
+   sect is named according to the names supplied in '__wrapper_names'.  */
 
-#define GNU_SECTION_NAMES "__section_names"
+#define GNU_WRAPPER_SECTS "__wrapper_sects"
+#define GNU_WRAPPER_INDEX "__wrapper_index"
+#define GNU_WRAPPER_NAMES "__wrapper_names"
 
 /* Private data for an simple_object_read.  */
 
@@ -214,8 +219,19 @@  struct simple_object_mach_o_attributes
   unsigned int reserved;
 };
 
-/* See if we have a Mach-O file.  */
+/* See if we have a Mach-O MH_OBJECT file:
 
+   A standard MH_OBJECT (from as) will have three load commands:
+   0 - LC_SEGMENT/LC_SEGMENT64
+   1 - LC_SYMTAB
+   2 - LC_DYSYMTAB
+   
+   The LC_SEGMENT/LC_SEGMENT64 will introduce a single anonymous segment
+   containing all the sections.
+   
+   Files written by simple-object will have only the segment command
+   (no symbol tables).  */
+
 static void *
 simple_object_mach_o_match (
     unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN],
@@ -258,18 +274,10 @@  simple_object_mach_o_match (
     }
 #endif
 
-  /* We require the user to provide a segment name.  This is
-     unfortunate but I don't see any good choices here.  */
-
-  if (segment_name == NULL)
+  /* Although a standard MH_OBJECT has a single anonymous segment, we allow
+     a segment name to be specified - but don't act on it at this stage.  */
+  if (segment_name && strlen (segment_name) > MACH_O_NAME_LEN)
     {
-      *errmsg = "Mach-O file found but no segment name specified";
-      *err = 0;
-      return NULL;
-    }
-
-  if (strlen (segment_name) > MACH_O_NAME_LEN)
-    {
       *errmsg = "Mach-O segment name too long";
       *err = 0;
       return NULL;
@@ -294,13 +302,14 @@  simple_object_mach_o_match (
   filetype = (*fetch_32) (b + offsetof (struct mach_o_header_32, filetype));
   if (filetype != MACH_O_MH_OBJECT)
     {
-      *errmsg = "Mach-O file is not object file";
+      *errmsg = "Mach-O file is not an MH_OBJECT file";
       *err = 0;
       return NULL;
     }
 
   omr = XNEW (struct simple_object_mach_o_read);
-  omr->segment_name = xstrdup (segment_name);
+  if (segment_name)
+    omr->segment_name = xstrdup (segment_name);
   omr->magic = magic;
   omr->is_big_endian = is_big_endian;
   omr->cputype = (*fetch_32) (b + offsetof (struct mach_o_header_32, cputype));
@@ -356,9 +365,25 @@  simple_object_mach_o_section_info (int is_big_endi
     }
 }
 
-/* Handle a segment in a Mach-O file.  Return 1 if we should continue,
-   0 if the caller should return.  */
+/* Handle a segment in a Mach-O Object file.
 
+   This will callback to the function pfn for each "section found" the meaning
+   of which depends on a gnu extension to mach-o:
+   
+   When omr->segment_name is specified, we implement a wrapper scheme (which
+   whilst it will, in principle, work with any segment name, is likely to be
+   meaningless current for anything except __GNU_LTO).
+   
+   If we find mach-o sections (with the segment name as specified) which also
+   contain: a 'sects' wrapper, an index, and a  name table, we expand this into
+   as many sections as are specified in the index.  In this case, there will
+   be a callback for each of these.
+   
+   When the omr->segment_name is not specified, then we would call-back for
+   every mach-o section specified in the file.
+
+   Return 1 if we should continue, 0 if the caller should return.  */
+
 static int
 simple_object_mach_o_segment (simple_object_read *sobj, off_t offset,
 			      const unsigned char *segbuf,
@@ -375,12 +400,19 @@  simple_object_mach_o_segment (simple_object_read *
   size_t sechdrsize;
   size_t segname_offset;
   size_t sectname_offset;
-  unsigned int nsects;
-  unsigned char *secdata;
-  unsigned int i;
-  unsigned int strtab_index;
-  char *strtab;
-  size_t strtab_size;
+  int nsects;
+  unsigned char *secdata = NULL;
+  int i;
+  int strtab_index, index_index, sections_index;
+  char *strtab = NULL;
+  size_t strtab_size = 0;
+  unsigned char *index = NULL;
+  size_t index_size;
+  unsigned int n_wrapped_sects = 0;
+  size_t wrapper_sect_size = 0;
+  off_t wrapper_sect_offset = (off_t)0;
+  int wrapping = (omr->segment_name && strlen (omr->segment_name) > 0);
+  strtab_index = index_index = sections_index = -1;
 
   fetch_32 = (omr->is_big_endian
 	      ? simple_object_fetch_big_32
@@ -409,6 +441,7 @@  simple_object_mach_o_segment (simple_object_read *
 					nsects));
     }
 
+  /* Fetch the section headers from the segment command.  */
   secdata = XNEWVEC (unsigned char, nsects * sechdrsize);
   if (!simple_object_internal_read (sobj->descriptor, offset + seghdrsize,
 				    secdata, nsects * sechdrsize, errmsg, err))
@@ -417,87 +450,147 @@  simple_object_mach_o_segment (simple_object_read *
       return 0;
     }
 
-  /* Scan for a __section_names section.  This is in effect a GNU
-     extension that permits section names longer than 16 chars.  */
-
-  for (i = 0; i < nsects; ++i)
+  /* If the user has set a segment name to be processed for GNU sub-sections
+     then scan for the three relevant sections.  */
+  if (wrapping)
     {
-      size_t nameoff;
+      off_t strtab_offset;
+      off_t index_offset;
 
-      nameoff = i * sechdrsize + segname_offset;
-      if (strcmp ((char *) secdata + nameoff, omr->segment_name) != 0)
-	continue;
-      nameoff = i * sechdrsize + sectname_offset;
-      if (strcmp ((char *) secdata + nameoff, GNU_SECTION_NAMES) == 0)
-	break;
-    }
+      for (i = 0; i < nsects; ++i)
+	{
+	  size_t nameoff;
 
-  strtab_index = i;
-  if (strtab_index >= nsects)
-    {
-      strtab = NULL;
-      strtab_size = 0;
-    }
-  else
-    {
-      off_t strtab_offset;
+	nameoff = i * sechdrsize + segname_offset;
+	if (strcmp ((char *) secdata + nameoff, omr->segment_name) != 0)
+	  continue;
 
-      simple_object_mach_o_section_info (omr->is_big_endian, is_32,
-					 secdata + strtab_index * sechdrsize,
-					 &strtab_offset, &strtab_size);
-      strtab = XNEWVEC (char, strtab_size);
-      if (!simple_object_internal_read (sobj->descriptor,
-					sobj->offset + strtab_offset,
-					(unsigned char *) strtab, strtab_size,
+	nameoff = i * sechdrsize + sectname_offset;
+	if (strcmp ((char *) secdata + nameoff, GNU_WRAPPER_NAMES) == 0)
+	  strtab_index = i;
+	else if (strcmp ((char *) secdata + nameoff, GNU_WRAPPER_INDEX) == 0)
+	  index_index = i;
+	else if (strcmp ((char *) secdata + nameoff, GNU_WRAPPER_SECTS) == 0)
+	  sections_index = i;
+      }
+
+      /* If any of the special wrapper section components is present, then
+	 they all should be.  */
+      if (sections_index >= 0 || index_index >= 0 || strtab_index >= 0)
+	{
+	  if (sections_index < 0 || index_index < 0 || strtab_index < 0)
+	    {
+	      *errmsg = "GNU Mach-o section wrapper: required section missing";
+	      *err = 0; /* No useful errno.  */
+	      XDELETEVEC (secdata);
+	      return 0;
+	    }
+
+	  /* Fetch the name table.  */
+	  simple_object_mach_o_section_info (omr->is_big_endian, is_32,
+					     secdata + strtab_index * sechdrsize,
+					     &strtab_offset, &strtab_size);
+	  strtab = XNEWVEC (char, strtab_size);
+	  if (!simple_object_internal_read (sobj->descriptor,
+					    sobj->offset + strtab_offset,
+					    (unsigned char *) strtab, strtab_size,
+					    errmsg, err))
+	    {
+	      XDELETEVEC (strtab);
+	      XDELETEVEC (secdata);
+	      return 0;
+	    }
+
+	  /* Fetch the index.  */
+	  simple_object_mach_o_section_info (omr->is_big_endian, is_32,
+					 secdata + index_index * sechdrsize,
+					 &index_offset, &index_size);
+	  index = XNEWVEC (unsigned char, index_size);
+	  if (!simple_object_internal_read (sobj->descriptor,
+					sobj->offset + index_offset,
+					index, index_size,
 					errmsg, err))
-	{
-	  XDELETEVEC (strtab);
-	  XDELETEVEC (secdata);
-	  return 0;
+	    {
+	      XDELETEVEC (index);
+	      XDELETEVEC (strtab);
+	      XDELETEVEC (secdata);
+	      return 0;
+	   }
+
+	  /* The index contains 4 uint32_t per sub-section:
+	     sub-section offset/length, sub-section name/length.  
+	     We fix this for both 32 and 64 bit mach-o for now, since
+	     other fields limit the maximum size of an object to 4G.  */
+	  n_wrapped_sects = index_size / 16;
+
+	  /* Get the parameters for the wrapper too.  */
+	  simple_object_mach_o_section_info (omr->is_big_endian, is_32,
+				       secdata + sections_index * sechdrsize,
+				       &wrapper_sect_offset, 
+				       &wrapper_sect_size);
+
 	}
+      else
+	wrapping = 0; /* We thought we were, but no wrapped sections found.  */
     }
 
   /* Process the sections.  */
-
   for (i = 0; i < nsects; ++i)
     {
       const unsigned char *sechdr;
-      char namebuf[MACH_O_NAME_LEN + 1];
+      char namebuf[MACH_O_NAME_LEN*2 + 2]; /* space for segment,section\0.  */
       char *name;
       off_t secoffset;
       size_t secsize;
+      int l;
 
-      if (i == strtab_index)
-	continue;
-
       sechdr = secdata + i * sechdrsize;
+      /* Process sections associated with the wrapper.  */
+      if (wrapping)
+	{
+	  if (i == strtab_index || i == index_index)
+	    continue;
 
-      if (strcmp ((char *) sechdr + segname_offset, omr->segment_name) != 0)
-	continue;
+	  if (strcmp ((char *) sechdr + segname_offset, omr->segment_name) != 0)
+	    continue;
 
-      memcpy (namebuf, sechdr + sectname_offset, MACH_O_NAME_LEN);
-      namebuf[MACH_O_NAME_LEN] = '\0';
-
-      name = &namebuf[0];
-      if (strtab != NULL && name[0] == '_' && name[1] == '_')
-	{
-	  unsigned long stringoffset;
-
-	  if (sscanf (name + 2, "%08lX", &stringoffset) == 1)
+	  if (i == sections_index)
 	    {
-	      if (stringoffset >= strtab_size)
+	      int j;
+	      for (j = 0; j < n_wrapped_sects; ++j)
 		{
-		  *errmsg = "section name offset out of range";
-		  *err = 0;
-		  XDELETEVEC (strtab);
-		  XDELETEVEC (secdata);
-		  return 0;
+		  unsigned int subsect_offset, subsect_length, name_offset;
+		  subsect_offset = (*fetch_32) (index + 16 * j);
+		  subsect_length = (*fetch_32) (index + 16 * j + 4);
+		  name_offset = (*fetch_32) (index + 16 * j + 8);
+		  /* We don't need the name_length yet.  */
+	  
+		  secoffset = wrapper_sect_offset + subsect_offset;
+		  secsize = subsect_length;
+		  name = strtab + name_offset;
+
+		  if (!(*pfn) (data, name, secoffset, secsize))
+		    {
+		      *errmsg = NULL;
+		      *err = 0;
+		      XDELETEVEC (index);
+		      XDELETEVEC (strtab);
+		      XDELETEVEC (secdata);
+		      return 0;
+		    }
 		}
-
-	      name = strtab + stringoffset;
+	      continue;
 	    }
 	}
 
+      /* Otherwise, make a name like __segment,__section as per the convention
+         in mach-o asm.  */
+      memset (namebuf, 0, MACH_O_NAME_LEN*2+2);
+      memcpy (namebuf, (char *) sechdr + segname_offset, MACH_O_NAME_LEN);
+      l = strlen (namebuf);
+      namebuf[l] = ',';
+      memcpy (namebuf, (char *) sechdr + sectname_offset, MACH_O_NAME_LEN);
+
       simple_object_mach_o_section_info (omr->is_big_endian, is_32, sechdr,
 					 &secoffset, &secsize);
 
@@ -505,12 +598,14 @@  simple_object_mach_o_segment (simple_object_read *
 	{
 	  *errmsg = NULL;
 	  *err = 0;
+	  XDELETEVEC (index);
 	  XDELETEVEC (strtab);
 	  XDELETEVEC (secdata);
 	  return 0;
 	}
     }
 
+  XDELETEVEC (index);
   XDELETEVEC (strtab);
   XDELETEVEC (secdata);
 
@@ -724,9 +819,9 @@  static int
 simple_object_mach_o_write_section_header (simple_object_write *sobj,
 					   int descriptor,
 					   size_t sechdr_offset,
-					   const char *name, size_t secaddr,
-					   size_t secsize, size_t offset,
-					   unsigned int align,
+					   const char *name, const char *segn,
+					   size_t secaddr, size_t secsize,
+					   size_t offset, unsigned int align,
 					   const char **errmsg, int *err)
 {
   struct simple_object_mach_o_attributes *attrs =
@@ -748,7 +843,7 @@  simple_object_mach_o_write_section_header (simple_
       strncpy ((char *) hdr + offsetof (struct mach_o_section_32, sectname),
 	       name, MACH_O_NAME_LEN);
       strncpy ((char *) hdr + offsetof (struct mach_o_section_32, segname),
-	       sobj->segment_name, MACH_O_NAME_LEN);
+	       segn, MACH_O_NAME_LEN);
       set_32 (hdr + offsetof (struct mach_o_section_32, addr), secaddr);
       set_32 (hdr + offsetof (struct mach_o_section_32, size), secsize);
       set_32 (hdr + offsetof (struct mach_o_section_32, offset), offset);
@@ -773,7 +868,7 @@  simple_object_mach_o_write_section_header (simple_
       strncpy ((char *) hdr + offsetof (struct mach_o_section_64, sectname),
 	       name, MACH_O_NAME_LEN);
       strncpy ((char *) hdr + offsetof (struct mach_o_section_64, segname),
-	       sobj->segment_name, MACH_O_NAME_LEN);
+	       segn, MACH_O_NAME_LEN);
       set_64 (hdr + offsetof (struct mach_o_section_64, addr), secaddr);
       set_64 (hdr + offsetof (struct mach_o_section_64, size), secsize);
       set_32 (hdr + offsetof (struct mach_o_section_64, offset), offset);
@@ -793,11 +888,26 @@  simple_object_mach_o_write_section_header (simple_
 				       sechdrsize, errmsg, err);
 }
 
-/* Write out the single segment and the sections of a Mach-O file.  */
+/* Write out the single (anonymous) segment containing the sections of a Mach-O
+   Object file.
+   
+   As a GNU extension to mach-o, when the caller specifies a segment name in
+   sobj->segment_name, all the sections passed will be output under a single
+   mach-o section header.  The caller's sections are indexed within this 
+   'wrapper' section by a table stored in a second mach-o section.  Finally,
+   arbitrary length section names are permitted by the extension and these are
+   stored in a table in a third mach-o section.
+   
+   Note that this is only likely to make any sense for the __GNU_LTO segment
+   at present.
+   
+   If the segment_name is not specified (or zero-length) we just write out the 
+   sections as we find them.  In that case we assume that the section name is 
+   in the form __SEGMENT_NAME,__section_name as per Mach-O asm.  */
 
 static int
 simple_object_mach_o_write_segment (simple_object_write *sobj, int descriptor,
-				    size_t nsects, const char **errmsg,
+				    size_t *nsects, const char **errmsg,
 				    int *err)
 {
   struct simple_object_mach_o_attributes *attrs =
@@ -814,6 +924,11 @@  simple_object_mach_o_write_segment (simple_object_
   simple_object_write_section *section;
   unsigned char hdrbuf[sizeof (struct mach_o_segment_command_64)];
   unsigned char *hdr;
+  int wrapping = (sobj->segment_name && strlen (sobj->segment_name) > 0);
+  size_t nsects_in;
+  uint32_t *index = NULL;
+  char *snames = NULL;
+  unsigned int sect;
 
   set_32 = (attrs->is_big_endian
 	    ? simple_object_set_big_32
@@ -834,19 +949,52 @@  simple_object_mach_o_write_segment (simple_object_
       sechdrsize = sizeof (struct mach_o_section_64);
     }
 
+  name_offset = 0;
+  *nsects = nsects_in = 0;
+  
+  /* Count the number of sections we start with.  */
+  for (section = sobj->sections; section != NULL;section = section->next)
+    nsects_in++;
+
+  if (wrapping)
+    {
+      /* We will only write 3 sections: wrapped data, index and names.  */
+      *nsects = 3; 
+      /* The index has four entries per wrapped section:
+	   Section Offset, length,  Name offset, length.
+	 Where the offsets are based at the start of the wrapper and name
+	 sections respectively.
+	 The values are stored as uint32 for both 32 and 64 bit mach-o
+	 since the size of a mach-o MH_OBJECT cannot exceed 4G owing to 
+	 other constraints.  */
+      index = XNEWVEC (uint32_t, nsects_in * 4);
+      /* We now need to figure out the size of the names section.  This just
+	 stores the names as null-terminated c strings, packed without any
+	 alignment padding.  */
+      for (section = sobj->sections, sect = 0; section != NULL;
+	   section = section->next, sect++)
+	{
+	  index[sect*4+2] = name_offset;
+	  index[sect*4+3] = strlen (section->name) + 1;
+	  name_offset += strlen (section->name) + 1;
+	}
+      snames = XNEWVEC (char, name_offset);
+    }
+  else
+    *nsects = nsects_in;
+
   sechdr_offset = hdrsize + seghdrsize;
-  cmdsize = seghdrsize + nsects * sechdrsize;
+  cmdsize = seghdrsize + *nsects * sechdrsize;
   offset = hdrsize + cmdsize;
-  name_offset = 0;
   secaddr = 0;
 
-  for (section = sobj->sections; section != NULL; section = section->next)
+  for (section = sobj->sections, sect = 0; section != NULL; 
+       section = section->next, sect++)
     {
       size_t mask;
       size_t new_offset;
       size_t secsize;
       struct simple_object_write_section_buffer *buffer;
-      char namebuf[MACH_O_NAME_LEN + 1];
 
       mask = (1U << section->align) - 1;
       new_offset = offset + mask;
@@ -877,39 +1025,117 @@  simple_object_mach_o_write_segment (simple_object_
 	  secsize += buffer->size;
 	}
 
-      snprintf (namebuf, sizeof namebuf, "__%08X", name_offset);
+      if (wrapping)
+	{
+	  index[sect*4+0] = (uint32_t) offset;
+	  index[sect*4+1] = secsize;
+	  /* Stash the section name in our table.  */
+	  memcpy (snames + index[sect*4+2], section->name, index[sect*4+3]);
+	}
+      else
+	{
+	  char namebuf[MACH_O_NAME_LEN + 1];
+	  char segnbuf[MACH_O_NAME_LEN + 1];
+	  char *comma;
+	  /* Try to extract segment,section from the input name.  */
+	  memset (namebuf, 0, sizeof namebuf);
+	  memset (segnbuf, 0, sizeof segnbuf);
+	  comma = strchr (section->name, ',');
+	  if (comma)
+	    {
+	      int len = comma-section->name;
+	      len = len > MACH_O_NAME_LEN ? MACH_O_NAME_LEN : len;
+	      if (len)
+	        strncpy (namebuf, section->name, len);
+	      strncpy (segnbuf, comma+1, MACH_O_NAME_LEN);
+	    }
+	  else /* just try to copy the name, leave segment blank.  */
+	    strncpy (namebuf, section->name, MACH_O_NAME_LEN);
+
+	  if (!simple_object_mach_o_write_section_header (sobj, descriptor,
+							  sechdr_offset, 
+							  namebuf, segnbuf,
+							  secaddr, secsize,
+							  offset, 
+							  section->align,
+							  errmsg, err))
+	    return 0;
+	  sechdr_offset += sechdrsize;
+	}
+
+      offset += secsize;
+      secaddr += secsize;
+    }
+
+  if (wrapping)
+    {
+      size_t secsize;
+      int i;
+      /* Write the section header for the wrapper.  */
+      /* Account for any initial aligment - which becomes the alignment for this
+	 created section.  */
+      secsize = (offset - index[0]); 
       if (!simple_object_mach_o_write_section_header (sobj, descriptor,
-						      sechdr_offset, namebuf,
-						      secaddr, secsize, offset,
-						      section->align,
+						      sechdr_offset, 
+						      GNU_WRAPPER_SECTS,
+						      sobj->segment_name,
+						      0 /*secaddr*/, 
+						      secsize, 
+						      index[0] /* initial offset*/,
+						      sobj->sections->align,
 						      errmsg, err))
 	return 0;
 
+      /* Subtract the wrapper section start from the begining of each sub
+	 section.  */
+      for (i=1; i<nsects_in;i++)
+	index[4*i] -= index[0];
+      index[0] = 0;
+      
       sechdr_offset += sechdrsize;
-      offset += secsize;
-      name_offset += strlen (section->name) + 1;
-      secaddr += secsize;
-    }
+      /* Write out the section names.  
+	 ... the header ...
+	 name_offset contains the length of the section.  It is not aligned.  */
+	 
+      if (!simple_object_mach_o_write_section_header (sobj, descriptor,
+						      sechdr_offset,
+						      GNU_WRAPPER_NAMES,
+						      sobj->segment_name,
+						      0 /*secaddr*/, name_offset, 
+						      offset,
+						      0, errmsg, err))
+	return 0;
 
-  /* Write out the section names.  */
+      /* ... and the content.. */
+      if (!simple_object_internal_write (descriptor, offset,
+					 (const unsigned char *) snames,
+					 name_offset, errmsg, err))
+	return 0;
 
-  if (!simple_object_mach_o_write_section_header (sobj, descriptor,
-						  sechdr_offset,
-						  GNU_SECTION_NAMES, secaddr,
-						  name_offset, offset, 0,
-						  errmsg, err))
-    return 0;
+      sechdr_offset += sechdrsize;
+      secaddr += name_offset;
+      offset += name_offset;
 
-  for (section = sobj->sections; section != NULL; section = section->next)
-    {
-      size_t namelen;
-
-      namelen = strlen (section->name) + 1;
+      /* Now do the index, we'll align this to 4 bytes although the read code
+	 will handle unaligned.  */
+      offset += 3; offset &= ~0x03;
+      if (!simple_object_mach_o_write_section_header (sobj, descriptor,
+						      sechdr_offset,
+						      GNU_WRAPPER_INDEX,
+						      sobj->segment_name,
+						      0 /*secaddr*/, nsects_in*16, 
+						      offset,
+						      2, errmsg, err))
+	return 0;
+      
+      /* ... and the content.. */
       if (!simple_object_internal_write (descriptor, offset,
-					 (const unsigned char *) section->name,
-					 namelen, errmsg, err))
+					 (const unsigned char *) index,
+					 nsects_in*16, errmsg, err))
 	return 0;
-      offset += namelen;
+
+      XDELETEVEC (index);
+      XDELETEVEC (snames);
     }
 
   /* Write out the segment header.  */
@@ -923,9 +1149,8 @@  simple_object_mach_o_write_segment (simple_object_
 	      MACH_O_LC_SEGMENT);
       set_32 (hdr + offsetof (struct mach_o_segment_command_32, cmdsize),
 	      cmdsize);
-      strncpy (((char *) hdr
-		+ offsetof (struct mach_o_segment_command_32, segname)),
-	       sobj->segment_name, MACH_O_NAME_LEN);
+     /* MH_OBJECTS have a single, anonymous, segment - so the segment name
+	 is left empty.  */
       /* vmaddr left as zero.  */
       /* vmsize left as zero.  */
       set_32 (hdr + offsetof (struct mach_o_segment_command_32, fileoff),
@@ -935,7 +1160,7 @@  simple_object_mach_o_write_segment (simple_object_
       /* maxprot left as zero.  */
       /* initprot left as zero.  */
       set_32 (hdr + offsetof (struct mach_o_segment_command_32, nsects),
-	      nsects);
+	      *nsects);
       /* flags left as zero.  */
     }
   else
@@ -951,9 +1176,8 @@  simple_object_mach_o_write_segment (simple_object_
 	      MACH_O_LC_SEGMENT);
       set_32 (hdr + offsetof (struct mach_o_segment_command_64, cmdsize),
 	      cmdsize);
-      strncpy (((char *) hdr
-		+ offsetof (struct mach_o_segment_command_64, segname)),
-	       sobj->segment_name, MACH_O_NAME_LEN);
+      /* MH_OBJECTS have a single, anonymous, segment - so the segment name
+	 is left empty.  */
       /* vmaddr left as zero.  */
       /* vmsize left as zero.  */
       set_64 (hdr + offsetof (struct mach_o_segment_command_64, fileoff),
@@ -963,7 +1187,7 @@  simple_object_mach_o_write_segment (simple_object_
       /* maxprot left as zero.  */
       /* initprot left as zero.  */
       set_32 (hdr + offsetof (struct mach_o_segment_command_64, nsects),
-	      nsects);
+	      *nsects);
       /* flags left as zero.  */
 #endif
     }
@@ -978,23 +1202,17 @@  static const char *
 simple_object_mach_o_write_to_file (simple_object_write *sobj, int descriptor,
 				    int *err)
 {
-  size_t nsects;
-  simple_object_write_section *section;
+  size_t nsects = 0;
   const char *errmsg;
 
-  /* Start at 1 for symbol_names section.  */
-  nsects = 1;
-  for (section = sobj->sections; section != NULL; section = section->next)
-    ++nsects;
+  if (!simple_object_mach_o_write_segment (sobj, descriptor, &nsects,
+					   &errmsg, err))
+    return errmsg;
 
   if (!simple_object_mach_o_write_header (sobj, descriptor, nsects,
 					  &errmsg, err))
     return errmsg;
 
-  if (!simple_object_mach_o_write_segment (sobj, descriptor, nsects,
-					   &errmsg, err))
-    return errmsg;
-
   return NULL;
 }
 
Index: gcc/config/darwin.c
===================================================================
--- gcc/config/darwin.c	(revision 179332)
+++ gcc/config/darwin.c	(working copy)
@@ -1753,19 +1753,51 @@  darwin_label_is_anonymous_local_objc_name (const c
   return (!strncmp ((const char *)p, "_OBJC_", 6));
 }
 
-/* LTO support for Mach-O.  */
+/* LTO support for Mach-O.
 
-/* Section names for LTO sections.  */
-static unsigned int lto_section_names_offset = 0;
+   This version uses three mach-o sections to encapsulate the (unlimited
+   number of) lto sections.
+   
+   __GNU_LTO, __lto_sections  contains the concatented GNU LTO section data.
+   __GNU_LTO, __section_names contains the GNU LTO section names.
+   __GNU_LTO, __section_index contains an array of values that index these.
 
-/* This is the obstack which we use to allocate the many strings.  */
-static struct obstack lto_section_names_obstack;
+   Indexed thus:
+     <section offset from the start of __GNU_LTO, __lto_sections>,
+     <section length>
+     <name offset from the start of __GNU_LTO, __section_names,
+     <name length>.
 
-/* Segment name for LTO sections.  */
+   At present, for both m32 and m64 mach-o files each of these fields is
+   represented  by a uint32_t.  This is because, AFAICT, a mach-o object
+   cannot exceed 4Gb because the section_64 offset field (see below) is 32bits.
+   
+    uint32_t offset;
+   "offset  An integer specifying the offset to this section in the file."  */
+
+/* Count lto section numbers. */
+static unsigned int lto_section_num = 0;
+
+/* A vector of information about LTO sections, at present, we only have
+   the name.  TODO: see if we can get the data length somehow.  */
+typedef struct GTY(()) darwin_lto_section_e {
+  const char *sectname;
+} darwin_lto_section_e ;
+DEF_VEC_O(darwin_lto_section_e);
+DEF_VEC_ALLOC_O(darwin_lto_section_e, gc);
+
+static GTY (()) VEC (darwin_lto_section_e, gc) * lto_section_names;
+
+/* Segment for LTO data.  */
 #define LTO_SEGMENT_NAME "__GNU_LTO"
 
-/* Section name for LTO section names section.  */
-#define LTO_NAMES_SECTION "__section_names"
+/* Section wrapper scheme (used here to wrap the unlimited number of LTO
+   sections into three Mach-O ones).
+   NOTE: These names MUST be kept in sync with those in 
+	 libiberty/simple-object-mach-o. */
+#define LTO_SECTS_SECTION "__wrapper_sects"
+#define LTO_NAMES_SECTION "__wrapper_names"
+#define LTO_INDEX_SECTION "__wrapper_index"
 
 /* File to temporarily store LTO data.  This is appended to asm_out_file
    in darwin_end_file.  */
@@ -1808,37 +1840,37 @@  darwin_asm_named_section (const char *name,
 			  unsigned int flags,
 			  tree decl ATTRIBUTE_UNUSED)
 {
-  /* LTO sections go in a special segment __GNU_LTO.  We want to replace the
-     section name with something we can use to represent arbitrary-length
-     names (section names in Mach-O are at most 16 characters long).  */
+  /* LTO sections go in a special section that encapsulates the (unlimited)
+     number of GNU LTO sections within a single mach-o one.  */
   if (strncmp (name, LTO_SECTION_NAME_PREFIX,
 	       strlen (LTO_SECTION_NAME_PREFIX)) == 0)
     {
+      darwin_lto_section_e e;
       /* We expect certain flags to be set...  */
       gcc_assert ((flags & (SECTION_DEBUG | SECTION_NAMED))
 		  == (SECTION_DEBUG | SECTION_NAMED));
 
-      /* Add the section name to the things to output when we end the
-	 current assembler output file.
-	 This is all not very efficient, but that doesn't matter -- this
-	 shouldn't be a hot path in the compiler...  */
-      obstack_1grow (&lto_section_names_obstack, '\t');
-      obstack_grow (&lto_section_names_obstack, ".ascii ", 7);
-      obstack_1grow (&lto_section_names_obstack, '"');
-      obstack_grow (&lto_section_names_obstack, name, strlen (name));
-      obstack_grow (&lto_section_names_obstack, "\\0\"\n", 4);
-
-      /* Output the dummy section name.  */
-      fprintf (asm_out_file, "\t# %s\n", name);
-      fprintf (asm_out_file, "\t.section %s,__%08X,regular,debug\n",
-	       LTO_SEGMENT_NAME, lto_section_names_offset);
-
-      /* Update the offset for the next section name.  Make sure we stay
-	 within reasonable length.  */  
-      lto_section_names_offset += strlen (name) + 1;
-      gcc_assert (lto_section_names_offset > 0
-		  && lto_section_names_offset < ((unsigned) 1 << 31));
-    }
+      /* Switch to our combined section.  */
+      fprintf (asm_out_file, "\t.section %s,%s,regular,debug\n",
+	       LTO_SEGMENT_NAME, LTO_SECTS_SECTION);
+      /* Output a label for the start of this sub-section.  */
+      fprintf (asm_out_file, "L_GNU_LTO%d:\t;# %s\n",
+	       lto_section_num, name);
+      /* We have to jump through hoops to get the values of the intra-section
+         offsets... */
+      fprintf (asm_out_file, "\t.set L$gnu$lto$offs%d,L_GNU_LTO%d-L_GNU_LTO0\n",
+	       lto_section_num, lto_section_num);
+      fprintf (asm_out_file, "\t.set L$gnu$lto$size%d,L_GNU_LTO%d-L_GNU_LTO%d\n",
+	       lto_section_num, lto_section_num+1, lto_section_num);
+      lto_section_num++;
+      e.sectname = xstrdup (name);
+      /* Keep the names, we'll need to make a table later.
+         TODO: check that we do not revisit sections, that would break 
+         the assumption of how this is done. */
+      if (lto_section_names == NULL)
+        lto_section_names = VEC_alloc (darwin_lto_section_e, gc, 16);
+      VEC_safe_push (darwin_lto_section_e, gc, lto_section_names, &e);
+   }
   else if (strncmp (name, "__DWARF,", 8) == 0)
     darwin_asm_dwarf_section (name, flags, decl);
   else
@@ -2711,16 +2743,12 @@  darwin_asm_output_dwarf_offset (FILE *file, int si
   darwin_asm_output_dwarf_delta (file, size, lab, sname);
 }
 
-/* Called from the within the TARGET_ASM_FILE_START for each target. 
-  Initialize the stuff we need for LTO long section names support.  */
+/* Called from the within the TARGET_ASM_FILE_START for each target.  */
 
 void
 darwin_file_start (void)
 {
-  /* We fill this obstack with the complete section text for the lto section
-     names to write in darwin_file_end.  */
-  obstack_init (&lto_section_names_obstack);
-  lto_section_names_offset = 0;
+  /* Nothing to do.  */
 }
 
 /* Called for the TARGET_ASM_FILE_END hook.
@@ -2731,8 +2759,6 @@  darwin_file_start (void)
 void
 darwin_file_end (void)
 {
-  const char *lto_section_names;
-
   machopic_finish (asm_out_file);
   if (strcmp (lang_hooks.name, "GNU C++") == 0)
     {
@@ -2762,6 +2788,13 @@  darwin_file_end (void)
 	  lto_asm_txt = buf = (char *) xmalloc (n + 1);
 	  while (fgets (lto_asm_txt, n, lto_asm_out_file))
 	    fputs (lto_asm_txt, asm_out_file);
+	  /* Put a termination label.  */
+	  fprintf (asm_out_file, "\t.section %s,%s,regular,debug\n",
+		   LTO_SEGMENT_NAME, LTO_SECTS_SECTION);
+	  fprintf (asm_out_file, "L_GNU_LTO%d:\t;# end of lto\n",
+		   lto_section_num);
+	  /* Make sure our termination label stays in this section.  */
+	  fputs ("\t.space\t1\n", asm_out_file);
 	}
 
       /* Remove the temporary file.  */
@@ -2770,21 +2803,49 @@  darwin_file_end (void)
       free (lto_asm_out_name);
     }
 
-  /* Finish the LTO section names obstack.  Don't output anything if
-     there are no recorded section names.  */
-  obstack_1grow (&lto_section_names_obstack, '\0');
-  lto_section_names = XOBFINISH (&lto_section_names_obstack, const char *);
-  if (strlen (lto_section_names) > 0)
+  /* Output the names and indices.  */
+  if (lto_section_names && VEC_length (darwin_lto_section_e, lto_section_names))
     {
-      fprintf (asm_out_file,
-	       "\t.section %s,%s,regular,debug\n",
+      int count;
+      darwin_lto_section_e *ref;
+      /* For now, we'll make the offsets 4 bytes and unaligned - we'll fix
+         the latter up ourselves. */
+      const char *op = integer_asm_op (4,0); 
+
+      /* Emit the names. */
+      fprintf (asm_out_file, "\t.section %s,%s,regular,debug\n",
 	       LTO_SEGMENT_NAME, LTO_NAMES_SECTION);
-      fprintf (asm_out_file,
-	       "\t# Section names in %s are offsets into this table\n",
-	       LTO_SEGMENT_NAME);
-      fprintf (asm_out_file, "%s\n", lto_section_names);
+      FOR_EACH_VEC_ELT (darwin_lto_section_e, lto_section_names, count, ref)
+	{
+	  fprintf (asm_out_file, "L_GNU_LTO_NAME%d:\n", count);
+         /* We have to jump through hoops to get the values of the intra-section
+            offsets... */
+	  fprintf (asm_out_file, 
+		   "\t.set L$gnu$lto$noff%d,L_GNU_LTO_NAME%d-L_GNU_LTO_NAME0\n",
+		   count, count);
+	  fprintf (asm_out_file,
+		   "\t.set L$gnu$lto$nsiz%d,L_GNU_LTO_NAME%d-L_GNU_LTO_NAME%d\n",
+		   count, count+1, count);
+	  fprintf (asm_out_file, "\t.asciz\t\"%s\"\n", ref->sectname);
+	}
+      fprintf (asm_out_file, "L_GNU_LTO_NAME%d:\t;# end\n", lto_section_num);
+      /* make sure our termination label stays in this section.  */
+      fputs ("\t.space\t1\n", asm_out_file);
+
+      /* Emit the Index. */
+      fprintf (asm_out_file, "\t.section %s,%s,regular,debug\n",
+	       LTO_SEGMENT_NAME, LTO_INDEX_SECTION);
+      fputs ("\t.align\t2\n", asm_out_file);
+      fputs ("# Section offset, Section length, Name offset, Name length\n", asm_out_file);
+      FOR_EACH_VEC_ELT (darwin_lto_section_e, lto_section_names, count, ref)
+	{
+	  fprintf (asm_out_file, "%s L$gnu$lto$offs%d\t;# %s\n",
+		   op, count, ref->sectname);
+	  fprintf (asm_out_file, "%s L$gnu$lto$size%d\n", op, count);
+	  fprintf (asm_out_file, "%s L$gnu$lto$noff%d\n", op, count);
+	  fprintf (asm_out_file, "%s L$gnu$lto$nsiz%d\n", op, count);
+	}
     }
-  obstack_free (&lto_section_names_obstack, NULL);
 
   /* If we have section anchors, then we must prevent the linker from
      re-arranging data.  */
Index: include/simple-object.h
===================================================================
--- include/simple-object.h	(revision 179332)
+++ include/simple-object.h	(working copy)
@@ -45,12 +45,13 @@  typedef struct simple_object_read_struct simple_ob
    descriptor, and OFFSET, an offset within the file.  The offset is
    for use with archives, and should be 0 for an ordinary object file.
    The descriptor must remain open until done with the returned
-   simple_object_read.  SEGMENT_NAME is used on Mach-O and is required
-   on that platform: it means to only look at sections within the
-   segment with that name.  It is ignored for other object file
-   formats.  On error, this function returns NULL, and sets *ERRMSG to
-   an error string and sets *ERR to an errno value or 0 if there is no
-   relevant errno.  */
+   simple_object_read.  SEGMENT_NAME is used to provide a GNU extension
+   to Mach-O.  When provided, only sections within that segment will be
+   considered and, additionally, they will be processed according to a GNU
+   extension to Mach-O.  SEGMENT_NAME is ignored for other object file
+   formats.  On error, this function returns NULL, and sets *ERRMSG to an
+   error string and sets *ERR to an errno value or 0 if there is no relevant
+   errno.  */
 
 extern simple_object_read *
 simple_object_start_read (int descriptor, off_t offset,
@@ -139,12 +140,12 @@  typedef struct simple_object_write_struct simple_o
 /* Start creating a new object file which is like ATTRS.  You must
    fetch attribute information from an existing object file before you
    can create a new one.  There is currently no support for creating
-   an object file de novo.  The segment name is only used on Mach-O,
-   where it is required.  It means that all sections are created
-   within that segment.  It is ignored for other object file formats.
-   On error this function returns NULL, sets *ERRMSG to an error
-   message, and sets *ERR to an errno value or 0 if there isn't
-   one.  */
+   an object file de novo.  SEGMENT_NAME is only used on Mach-O and, if
+   set, it will cause all sections supplied to be stored according to a
+   GNU section wrapper extension to the format.  It is ignored for other
+   object file formats.  On error this function returns NULL, sets *ERRMSG
+   to an error message, and sets *ERR to an errno value or 0 if there
+   isn't one.  */
 
 extern simple_object_write *
 simple_object_start_write (simple_object_attributes *attrs,