Revert "sphinx: copy files from texi2rst-generated repository"

This reverts commit c63539ffe4c0e327337a1a51f638d9c8c958cb26.

13 files changed, 0 insertions, 2859 deletions

diff --git a/libiberty/doc/bsd.rst b/libiberty/doc/bsd.rst
deleted file mode 100644
index bb786e2..0000000
--- a/libiberty/doc/bsd.rst
+++ /dev/null
@@ -1,6 +0,0 @@
-..
-  Copyright 1988-2022 Free Software Foundation, Inc.
-  This is part of the GCC manual.
-  For copying conditions, see the copyright.rst file.
-
-.. include:: ../../doc/bsd.rst
\ No newline at end of file
diff --git a/libiberty/doc/conf.py b/libiberty/doc/conf.py
deleted file mode 100644
index b255fd9..0000000
--- a/libiberty/doc/conf.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# Configuration file for the Sphinx documentation builder.
-
-import sys
-sys.path.append('../..//doc')
-
-from baseconf import *
-
-name = 'libiberty'
-project = 'GNU libiberty'
-copyright = '2001-2022 Free Software Foundation, Inc.'
-authors = 'Phil Edwards et al.'
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-#  dir menu entry, description, category)
-latex_documents = [
-  ('index', f'{name}.tex', project, authors, 'manual'),
-]
-
-
-texinfo_documents = [
-  ('index', name, project, authors, None, None, None, True)
-]
-
-set_common(name, globals())
\ No newline at end of file
diff --git a/libiberty/doc/copyright.rst b/libiberty/doc/copyright.rst
deleted file mode 100644
index 5afce61..0000000
--- a/libiberty/doc/copyright.rst
+++ /dev/null
@@ -1,13 +0,0 @@
-..
-  Copyright 1988-2022 Free Software Foundation, Inc.
-  This is part of the GCC manual.
-  For copying conditions, see the GPL license file
-
-Copyright
-^^^^^^^^^
-
-Permission is granted to copy, distribute and/or modify this document
-under the terms of the GNU Free Documentation License, Version 1.3 or
-any later version published by the Free Software Foundation; with no
-Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
-A copy of the license is in the :ref:`gnu_fdl`.
\ No newline at end of file
diff --git a/libiberty/doc/extensions.rst b/libiberty/doc/extensions.rst
deleted file mode 100644
index 03a2419..0000000
--- a/libiberty/doc/extensions.rst
+++ /dev/null
@@ -1,767 +0,0 @@
-..
-  Copyright 1988-2022 Free Software Foundation, Inc.
-  This is part of the GCC manual.
-  For copying conditions, see the copyright.rst file.
-
-.. index:: extensions, functions, extension
-
-.. _extensions:
-
-Extensions
-**********
-
-``libiberty`` includes additional functionality above and beyond standard
-functions, which has proven generically useful in GNU programs, such as
-obstacks and regex.  These functions are often copied from other
-projects as they gain popularity, and are included here to provide a
-central location from which to use, maintain, and distribute them.
-
-.. toctree::
-  :maxdepth: 2
-
-
-.. This is generated from the glibc manual using contrib/make-obstacks-texi.pl
-
-.. index:: obstacks
-
-.. _obstacks:
-
-Obstacks
-^^^^^^^^
-
-An :dfn:`obstack` is a pool of memory containing a stack of objects.  You
-can create any number of separate obstacks, and then allocate objects in
-specified obstacks.  Within each obstack, the last object allocated must
-always be the first one freed, but distinct obstacks are independent of
-each other.
-
-Aside from this one constraint of order of freeing, obstacks are totally
-general: an obstack can contain any number of objects of any size.  They
-are implemented with macros, so allocation is usually very fast as long as
-the objects are usually small.  And the only space overhead per object is
-the padding needed to start each object on a suitable boundary.
-
-.. toctree::
-  :maxdepth: 2
-
-
-.. _creating-obstacks:
-
-Creating Obstacks
-~~~~~~~~~~~~~~~~~
-
-The utilities for manipulating obstacks are declared in the header
-file :samp:`obstack.h`.
-
-.. index:: obstack.h, struct obstack
-
-Data Type struct obstackAn obstack is represented by a data structure of type ``struct
-obstack``.  This structure has a small fixed size; it records the status
-of the obstack and how to find the space in which objects are allocated.
-It does not contain any of the objects themselves.  You should not try
-to access the contents of the structure directly; use only the macros
-described in this chapter.
-
-You can declare variables of type ``struct obstack`` and use them as
-obstacks, or you can allocate obstacks dynamically like any other kind
-of object.  Dynamic allocation of obstacks allows your program to have a
-variable number of different stacks.  (You can even allocate an
-obstack structure in another obstack, but this is rarely useful.)
-
-All the macros that work with obstacks require you to specify which
-obstack to use.  You do this with a pointer of type ``struct obstack
-*``.  In the following, we often say 'an obstack' when strictly
-speaking the object at hand is such a pointer.
-
-The objects in the obstack are packed into large blocks called
-:dfn:`chunks`.  The ``struct obstack`` structure points to a chain of
-the chunks currently in use.
-
-The obstack library obtains a new chunk whenever you allocate an object
-that won't fit in the previous chunk.  Since the obstack library manages
-chunks automatically, you don't need to pay much attention to them, but
-you do need to supply a function which the obstack library should use to
-get a chunk.  Usually you supply a function which uses ``malloc``
-directly or indirectly.  You must also supply a function to free a chunk.
-These matters are described in the following section.
-
-.. _preparing-for-obstacks:
-
-Preparing for Using Obstacks
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Each source file in which you plan to use obstacks
-must include the header file :samp:`obstack.h`, like this:
-
-.. code-block:: c++
-
-  #include <obstack.h>
-
-.. index:: obstack_chunk_alloc, obstack_chunk_free
-
-Also, if the source file uses the macro ``obstack_init``, it must
-declare or define two macros that will be called by the
-obstack library.  One, ``obstack_chunk_alloc``, is used to allocate
-the chunks of memory into which objects are packed.  The other,
-``obstack_chunk_free``, is used to return chunks when the objects in
-them are freed.  These macros should appear before any use of obstacks
-in the source file.
-
-Usually these are defined to use ``malloc`` via the intermediary
-``xmalloc`` (see `Unconstrained Allocation <https://www.gnu.org/software/libc/manual/html_node/Unconstrained-Allocation.html>`_
-in The GNU C Library Reference Manual).  This is done with
-the following pair of macro definitions:
-
-.. code-block:: c++
-
-  #define obstack_chunk_alloc xmalloc
-  #define obstack_chunk_free free
-
-Though the memory you get using obstacks really comes from ``malloc``,
-using obstacks is faster because ``malloc`` is called less often, for
-larger blocks of memory.  See :ref:`obstack-chunks`, for full details.
-
-At run time, before the program can use a ``struct obstack`` object
-as an obstack, it must initialize the obstack by calling
-``obstack_init`` or one of its variants, ``obstack_begin``,
-``obstack_specify_allocation``, or
-``obstack_specify_allocation_with_arg``.
-
-.. function:: int obstack_init (struct obstack *obstack_ptr)
-
-  Initialize obstack :samp:`{obstack_ptr}` for allocation of objects.  This
-  macro calls the obstack's ``obstack_chunk_alloc`` function.  If
-  allocation of memory fails, the function pointed to by
-  ``obstack_alloc_failed_handler`` is called.  The ``obstack_init``
-  macro always returns 1 (Compatibility notice: Former versions of
-  obstack returned 0 if allocation failed).
-
-Here are two examples of how to allocate the space for an obstack and
-initialize it.  First, an obstack that is a static variable:
-
-.. code-block:: c++
-
-  static struct obstack myobstack;
-  ...
-  obstack_init (&myobstack);
-
-Second, an obstack that is itself dynamically allocated:
-
-.. code-block:: c++
-
-  struct obstack *myobstack_ptr
-    = (struct obstack *) xmalloc (sizeof (struct obstack));
-
-  obstack_init (myobstack_ptr);
-
-.. function:: int obstack_begin (struct obstack *obstack_ptr, size_t chunk_size)
-
-  Like ``obstack_init``, but specify chunks to be at least
-  :samp:`{chunk_size}` bytes in size.
-
-.. function:: int obstack_specify_allocation (struct obstack *obstack_ptr, size_t chunk_size, size_t alignment, void *(*chunkfun) (size_t), void (*freefun) (void *))
-
-  Like ``obstack_init``, specifying chunk size, chunk
-  alignment, and memory allocation functions.  A :samp:`{chunk_size}` or
-  :samp:`{alignment}` of zero results in the default size or alignment
-  respectively being used.
-
-.. function:: int obstack_specify_allocation_with_arg (struct obstack *obstack_ptr, size_t chunk_size, size_t alignment, void *(*chunkfun) (void *, size_t), void (*freefun) (void *, void *), void *arg)
-
-  Like ``obstack_specify_allocation``, but specifying memory
-  allocation functions that take an extra first argument, :samp:`{arg}`.
-
-.. index:: obstack_alloc_failed_handler
-
-Variable obstack_alloc_failed_handlerThe value of this variable is a pointer to a function that
-``obstack`` uses when ``obstack_chunk_alloc`` fails to allocate
-memory.  The default action is to print a message and abort.
-You should supply a function that either calls ``exit``
-(see `Program Termination <https://www.gnu.org/software/libc/manual/html_node/Program-Termination.html>`_ in The GNU C Library Reference Manual)
-or ``longjmp`` and doesn't return.
-
-.. code-block:: c++
-
-  void my_obstack_alloc_failed (void)
-  ...
-  obstack_alloc_failed_handler = &my_obstack_alloc_failed;
-
-.. index:: allocation (obstacks)
-
-.. _allocation-in-an-obstack:
-
-Allocation in an Obstack
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-The most direct way to allocate an object in an obstack is with
-``obstack_alloc``, which is invoked almost like ``malloc``.
-
-.. function:: void * obstack_alloc (struct obstack *obstack_ptr, size_t size)
-
-  This allocates an uninitialized block of :samp:`{size}` bytes in an obstack
-  and returns its address.  Here :samp:`{obstack_ptr}` specifies which obstack
-  to allocate the block in; it is the address of the ``struct obstack``
-  object which represents the obstack.  Each obstack macro
-  requires you to specify an :samp:`{obstack_ptr}` as the first argument.
-
-  This macro calls the obstack's ``obstack_chunk_alloc`` function if
-  it needs to allocate a new chunk of memory; it calls
-  ``obstack_alloc_failed_handler`` if allocation of memory by
-  ``obstack_chunk_alloc`` failed.
-
-For example, here is a function that allocates a copy of a string :samp:`{str}`
-in a specific obstack, which is in the variable ``string_obstack`` :
-
-.. code-block:: c++
-
-  struct obstack string_obstack;
-
-  char *
-  copystring (char *string)
-  {
-    size_t len = strlen (string) + 1;
-    char *s = (char *) obstack_alloc (&string_obstack, len);
-    memcpy (s, string, len);
-    return s;
-  }
-
-To allocate a block with specified contents, use the macro ``obstack_copy``.
-
-.. function:: void * obstack_copy (struct obstack *obstack_ptr, void *address, size_t size)
-
-  This allocates a block and initializes it by copying :samp:`{size}`
-  bytes of data starting at :samp:`{address}`.  It calls
-  ``obstack_alloc_failed_handler`` if allocation of memory by
-  ``obstack_chunk_alloc`` failed.
-
-.. function:: void * obstack_copy0 (struct obstack *obstack_ptr, void *address, size_t size)
-
-  Like ``obstack_copy``, but appends an extra byte containing a null
-  character.  This extra byte is not counted in the argument :samp:`{size}`.
-
-The ``obstack_copy0`` macro is convenient for copying a sequence
-of characters into an obstack as a null-terminated string.  Here is an
-example of its use:
-
-.. code-block:: c++
-
-  char *
-  obstack_savestring (char *addr, size_t size)
-  {
-    return obstack_copy0 (&myobstack, addr, size);
-  }
-
-Contrast this with the previous example of ``savestring`` using
-``malloc`` see (`Basic Allocation <http://www.gnu.org/software/libc/manual/html_node/Basic-Allocation.html#Basic-Allocation>`_).
-
-.. index:: freeing (obstacks)
-
-.. _freeing-obstack-objects:
-
-Freeing Objects in an Obstack
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-To free an object allocated in an obstack, use the macro
-``obstack_free``.  Since the obstack is a stack of objects, freeing
-one object automatically frees all other objects allocated more recently
-in the same obstack.
-
-.. function:: void obstack_free (struct obstack *obstack_ptr, void *object)
-
-  If :samp:`{object}` is a null pointer, everything allocated in the obstack
-  is freed.  Otherwise, :samp:`{object}` must be the address of an object
-  allocated in the obstack.  Then :samp:`{object}` is freed, along with
-  everything allocated in :samp:`{obstack}` since :samp:`{object}`.
-
-Note that if :samp:`{object}` is a null pointer, the result is an
-uninitialized obstack.  To free all memory in an obstack but leave it
-valid for further allocation, call ``obstack_free`` with the address
-of the first object allocated on the obstack:
-
-.. code-block:: c++
-
-  obstack_free (obstack_ptr, first_object_allocated_ptr);
-
-Recall that the objects in an obstack are grouped into chunks.  When all
-the objects in a chunk become free, the obstack library automatically
-frees the chunk (see :ref:`preparing-for-obstacks`).  Then other
-obstacks, or non-obstack allocation, can reuse the space of the chunk.
-
-.. index:: macros
-
-.. _obstack-functions:
-
-Obstack Functions and Macros
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The interfaces for using obstacks are shown here as functions to
-specify the return type and argument types, but they are really
-defined as macros.  This means that the arguments don't actually have
-types, but they generally behave as if they have the types shown.
-You can call these macros like functions, but you cannot use them in
-any other way (for example, you cannot take their address).
-
-Calling the macros requires a special precaution: namely, the first
-operand (the obstack pointer) may not contain any side effects, because
-it may be computed more than once.  For example, if you write this:
-
-.. code-block:: c++
-
-  obstack_alloc (get_obstack (), 4);
-
-you will find that ``get_obstack`` may be called several times.
-If you use ``*obstack_list_ptr++`` as the obstack pointer argument,
-you will get very strange results since the incrementation may occur
-several times.
-
-If you use the GNU C compiler, this precaution is not necessary, because
-various language extensions in GNU C permit defining the macros so as to
-compute each argument only once.
-
-Note that arguments other than the first will only be evaluated once,
-even when not using GNU C.
-
-``obstack.h`` does declare a number of functions,
-``_obstack_begin``, ``_obstack_begin_1``,
-``_obstack_newchunk``, ``_obstack_free``, and
-``_obstack_memory_used``.  You should not call these directly.
-
-.. index:: growing objects (in obstacks), changing the size of a block (obstacks)
-
-.. _growing-objects:
-
-Growing Objects
-~~~~~~~~~~~~~~~
-
-Because memory in obstack chunks is used sequentially, it is possible to
-build up an object step by step, adding one or more bytes at a time to the
-end of the object.  With this technique, you do not need to know how much
-data you will put in the object until you come to the end of it.  We call
-this the technique of :dfn:`growing objects`.  The special macros
-for adding data to the growing object are described in this section.
-
-You don't need to do anything special when you start to grow an object.
-Using one of the macros to add data to the object automatically
-starts it.  However, it is necessary to say explicitly when the object is
-finished.  This is done with ``obstack_finish``.
-
-The actual address of the object thus built up is not known until the
-object is finished.  Until then, it always remains possible that you will
-add so much data that the object must be copied into a new chunk.
-
-While the obstack is in use for a growing object, you cannot use it for
-ordinary allocation of another object.  If you try to do so, the space
-already added to the growing object will become part of the other object.
-
-.. function:: void obstack_blank (struct obstack *obstack_ptr, size_t size)
-
-  The most basic macro for adding to a growing object is
-  ``obstack_blank``, which adds space without initializing it.
-
-.. function:: void obstack_grow (struct obstack *obstack_ptr, void *data, size_t size)
-
-  To add a block of initialized space, use ``obstack_grow``, which is
-  the growing-object analogue of ``obstack_copy``.  It adds :samp:`{size}`
-  bytes of data to the growing object, copying the contents from
-  :samp:`{data}`.
-
-.. function:: void obstack_grow0 (struct obstack *obstack_ptr, void *data, size_t size)
-
-  This is the growing-object analogue of ``obstack_copy0``.  It adds
-  :samp:`{size}` bytes copied from :samp:`{data}`, followed by an additional null
-  character.
-
-.. function:: void obstack_1grow (struct obstack *obstack_ptr, char c)
-
-  To add one character at a time, use ``obstack_1grow``.
-  It adds a single byte containing :samp:`{c}` to the growing object.
-
-.. function:: void obstack_ptr_grow (struct obstack *obstack_ptr, void *data)
-
-  Adding the value of a pointer one can use
-  ``obstack_ptr_grow``.  It adds ``sizeof (void *)`` bytes
-  containing the value of :samp:`{data}`.
-
-.. function:: void obstack_int_grow (struct obstack *obstack_ptr, int data)
-
-  A single value of type ``int`` can be added by using
-  ``obstack_int_grow``.  It adds ``sizeof (int)`` bytes to
-  the growing object and initializes them with the value of :samp:`{data}`.
-
-.. function:: void * obstack_finish (struct obstack *obstack_ptr)
-
-  When you are finished growing the object, use
-  ``obstack_finish`` to close it off and return its final address.
-
-  Once you have finished the object, the obstack is available for ordinary
-  allocation or for growing another object.
-
-When you build an object by growing it, you will probably need to know
-afterward how long it became.  You need not keep track of this as you grow
-the object, because you can find out the length from the obstack
-with ``obstack_object_size``, before finishing the object.
-
-.. function:: size_t obstack_object_size (struct obstack *obstack_ptr)
-
-  This macro returns the current size of the growing object, in bytes.
-  Remember to call ``obstack_object_size`` *before* finishing the object.
-  After it is finished, ``obstack_object_size`` will return zero.
-
-If you have started growing an object and wish to cancel it, you should
-finish it and then free it, like this:
-
-.. code-block:: c++
-
-  obstack_free (obstack_ptr, obstack_finish (obstack_ptr));
-
-This has no effect if no object was growing.
-
-.. index:: efficiency and obstacks
-
-.. _extra-fast-growing:
-
-Extra Fast Growing Objects
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The usual macros for growing objects incur overhead for checking
-whether there is room for the new growth in the current chunk.  If you
-are frequently constructing objects in small steps of growth, this
-overhead can be significant.
-
-You can reduce the overhead by using special 'fast growth'
-macros that grow the object without checking.  In order to have a
-robust program, you must do the checking yourself.  If you do this checking
-in the simplest way each time you are about to add data to the object, you
-have not saved anything, because that is what the ordinary growth
-macros do.  But if you can arrange to check less often, or check
-more efficiently, then you make the program faster.
-
-``obstack_room`` returns the amount of room available
-in the current chunk.
-
-.. function:: size_t obstack_room (struct obstack *obstack_ptr)
-
-  This returns the number of bytes that can be added safely to the current
-  growing object (or to an object about to be started) in obstack
-  :samp:`{obstack}` using the fast growth macros.
-
-While you know there is room, you can use these fast growth macros
-for adding data to a growing object:
-
-.. function:: void obstack_1grow_fast (struct obstack *obstack_ptr, char c)
-
-  ``obstack_1grow_fast`` adds one byte containing the
-  character :samp:`{c}` to the growing object in obstack :samp:`{obstack_ptr}`.
-
-.. function:: void obstack_ptr_grow_fast (struct obstack *obstack_ptr, void *data)
-
-  ``obstack_ptr_grow_fast`` adds ``sizeof (void *)``
-  bytes containing the value of :samp:`{data}` to the growing object in
-  obstack :samp:`{obstack_ptr}`.
-
-.. function:: void obstack_int_grow_fast (struct obstack *obstack_ptr, int data)
-
-  ``obstack_int_grow_fast`` adds ``sizeof (int)`` bytes
-  containing the value of :samp:`{data}` to the growing object in obstack
-  :samp:`{obstack_ptr}`.
-
-.. function:: void obstack_blank_fast (struct obstack *obstack_ptr, size_t size)
-
-  ``obstack_blank_fast`` adds :samp:`{size}` bytes to the
-  growing object in obstack :samp:`{obstack_ptr}` without initializing them.
-
-When you check for space using ``obstack_room`` and there is not
-enough room for what you want to add, the fast growth macros
-are not safe.  In this case, simply use the corresponding ordinary
-growth macro instead.  Very soon this will copy the object to a
-new chunk; then there will be lots of room available again.
-
-So, each time you use an ordinary growth macro, check afterward for
-sufficient space using ``obstack_room``.  Once the object is copied
-to a new chunk, there will be plenty of space again, so the program will
-start using the fast growth macros again.
-
-Here is an example:
-
-.. code-block:: c++
-
-  void
-  add_string (struct obstack *obstack, const char *ptr, size_t len)
-  {
-    while (len > 0)
-      {
-        size_t room = obstack_room (obstack);
-        if (room == 0)
-          {
-            /* Not enough room.  Add one character slowly,
-               which may copy to a new chunk and make room.  */
-            obstack_1grow (obstack, *ptr++);
-            len--;
-          }
-        else
-          {
-            if (room > len)
-              room = len;
-            /* Add fast as much as we have room for. */
-            len -= room;
-            while (room-- > 0)
-              obstack_1grow_fast (obstack, *ptr++);
-          }
-      }
-  }
-
-.. index:: shrinking objects
-
-You can use ``obstack_blank_fast`` with a 'negative' size
-argument to make the current object smaller.  Just don't try to shrink
-it beyond zero length---there's no telling what will happen if you do
-that.  Earlier versions of obstacks allowed you to use
-``obstack_blank`` to shrink objects.  This will no longer work.
-
-.. index:: obstack status, status of obstack
-
-.. _status-of-an-obstack:
-
-Status of an Obstack
-~~~~~~~~~~~~~~~~~~~~
-
-Here are macros that provide information on the current status of
-allocation in an obstack.  You can use them to learn about an object while
-still growing it.
-
-.. function:: void * obstack_base (struct obstack *obstack_ptr)
-
-  This macro returns the tentative address of the beginning of the
-  currently growing object in :samp:`{obstack_ptr}`.  If you finish the object
-  immediately, it will have that address.  If you make it larger first, it
-  may outgrow the current chunk---then its address will change!
-
-  If no object is growing, this value says where the next object you
-  allocate will start (once again assuming it fits in the current
-  chunk).
-
-.. function:: void * obstack_next_free (struct obstack *obstack_ptr)
-
-  This macro returns the address of the first free byte in the current
-  chunk of obstack :samp:`{obstack_ptr}`.  This is the end of the currently
-  growing object.  If no object is growing, ``obstack_next_free``
-  returns the same value as ``obstack_base``.
-
-.. function:: size_t obstack_object_size (struct obstack *obstack_ptr)
-
-  This macro returns the size in bytes of the currently growing object.
-  This is equivalent to
-
-  .. code-block:: c++
-
-    ((size_t) (obstack_next_free (obstack_ptr) - obstack_base (obstack_ptr)))
-
-.. index:: alignment (in obstacks)
-
-.. _obstacks-data-alignment:
-
-Alignment of Data in Obstacks
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Each obstack has an :dfn:`alignment boundary`; each object allocated in
-the obstack automatically starts on an address that is a multiple of the
-specified boundary.  By default, this boundary is aligned so that
-the object can hold any type of data.
-
-To access an obstack's alignment boundary, use the macro
-``obstack_alignment_mask``.
-
-.. function:: size_t obstack_alignment_mask (struct obstack *obstack_ptr)
-
-  The value is a bit mask; a bit that is 1 indicates that the corresponding
-  bit in the address of an object should be 0.  The mask value should be one
-  less than a power of 2; the effect is that all object addresses are
-  multiples of that power of 2.  The default value of the mask is a value
-  that allows aligned objects to hold any type of data: for example, if
-  its value is 3, any type of data can be stored at locations whose
-  addresses are multiples of 4.  A mask value of 0 means an object can start
-  on any multiple of 1 (that is, no alignment is required).
-
-  The expansion of the macro ``obstack_alignment_mask`` is an lvalue,
-  so you can alter the mask by assignment.  For example, this statement:
-
-  .. code-block:: c++
-
-    obstack_alignment_mask (obstack_ptr) = 0;
-
-  has the effect of turning off alignment processing in the specified obstack.
-
-Note that a change in alignment mask does not take effect until
-*after* the next time an object is allocated or finished in the
-obstack.  If you are not growing an object, you can make the new
-alignment mask take effect immediately by calling ``obstack_finish``.
-This will finish a zero-length object and then do proper alignment for
-the next object.
-
-.. index:: efficiency of chunks, chunks
-
-.. _obstack-chunks:
-
-Obstack Chunks
-~~~~~~~~~~~~~~
-
-Obstacks work by allocating space for themselves in large chunks, and
-then parceling out space in the chunks to satisfy your requests.  Chunks
-are normally 4096 bytes long unless you specify a different chunk size.
-The chunk size includes 8 bytes of overhead that are not actually used
-for storing objects.  Regardless of the specified size, longer chunks
-will be allocated when necessary for long objects.
-
-The obstack library allocates chunks by calling the function
-``obstack_chunk_alloc``, which you must define.  When a chunk is no
-longer needed because you have freed all the objects in it, the obstack
-library frees the chunk by calling ``obstack_chunk_free``, which you
-must also define.
-
-These two must be defined (as macros) or declared (as functions) in each
-source file that uses ``obstack_init`` (see :ref:`creating-obstacks`).
-Most often they are defined as macros like this:
-
-.. code-block:: c++
-
-  #define obstack_chunk_alloc malloc
-  #define obstack_chunk_free free
-
-Note that these are simple macros (no arguments).  Macro definitions with
-arguments will not work!  It is necessary that ``obstack_chunk_alloc``
-or ``obstack_chunk_free``, alone, expand into a function name if it is
-not itself a function name.
-
-If you allocate chunks with ``malloc``, the chunk size should be a
-power of 2.  The default chunk size, 4096, was chosen because it is long
-enough to satisfy many typical requests on the obstack yet short enough
-not to waste too much memory in the portion of the last chunk not yet used.
-
-.. function:: size_t obstack_chunk_size (struct obstack *obstack_ptr)
-
-  This returns the chunk size of the given obstack.
-
-Since this macro expands to an lvalue, you can specify a new chunk size by
-assigning it a new value.  Doing so does not affect the chunks already
-allocated, but will change the size of chunks allocated for that particular
-obstack in the future.  It is unlikely to be useful to make the chunk size
-smaller, but making it larger might improve efficiency if you are
-allocating many objects whose size is comparable to the chunk size.  Here
-is how to do so cleanly:
-
-.. code-block:: c++
-
-  if (obstack_chunk_size (obstack_ptr) < new-chunk-size)
-    obstack_chunk_size (obstack_ptr) = new-chunk-size;
-
-.. _summary-of-obstacks:
-
-Summary of Obstack Macros
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Here is a summary of all the macros associated with obstacks.  Each
-takes the address of an obstack (``struct obstack *``) as its first
-argument.
-
-.. function:: int obstack_init (struct obstack *obstack_ptr)
-
-  Initialize use of an obstack.  See :ref:`creating-obstacks`.
-
-.. function:: int obstack_begin (struct obstack *obstack_ptr, size_t chunk_size)
-
-  Initialize use of an obstack, with an initial chunk of
-  :samp:`{chunk_size}` bytes.
-
-.. function:: int obstack_specify_allocation (struct obstack *obstack_ptr, size_t chunk_size, size_t alignment, void *(*chunkfun) (size_t), void (*freefun) (void *))
-
-  Initialize use of an obstack, specifying intial chunk size, chunk
-  alignment, and memory allocation functions.
-
-.. function:: int obstack_specify_allocation_with_arg (struct obstack *obstack_ptr, size_t chunk_size, size_t alignment, void *(*chunkfun) (void *, size_t), void (*freefun) (void *, void *), void *arg)
-
-  Like ``obstack_specify_allocation``, but specifying memory
-  allocation functions that take an extra first argument, :samp:`{arg}`.
-
-.. function:: void *obstack_alloc (struct obstack *obstack_ptr, size_t size)
-
-  Allocate an object of :samp:`{size}` uninitialized bytes.
-  See :ref:`allocation-in-an-obstack`.
-
-.. function:: void *obstack_copy (struct obstack *obstack_ptr, void *address, size_t size)
-
-  Allocate an object of :samp:`{size}` bytes, with contents copied from
-  :samp:`{address}`.  See :ref:`allocation-in-an-obstack`.
-
-.. function:: void *obstack_copy0 (struct obstack *obstack_ptr, void *address, size_t size)
-
-  Allocate an object of :samp:`{size}` +1 bytes, with :samp:`{size}` of them copied
-  from :samp:`{address}`, followed by a null character at the end.
-  See :ref:`allocation-in-an-obstack`.
-
-.. function:: void obstack_free (struct obstack *obstack_ptr, void *object)
-
-  Free :samp:`{object}` (and everything allocated in the specified obstack
-  more recently than :samp:`{object}`).  See :ref:`freeing-obstack-objects`.
-
-.. function:: void obstack_blank (struct obstack *obstack_ptr, size_t size)
-
-  Add :samp:`{size}` uninitialized bytes to a growing object.
-  See :ref:`growing-objects`.
-
-.. function:: void obstack_grow (struct obstack *obstack_ptr, void *address, size_t size)
-
-  Add :samp:`{size}` bytes, copied from :samp:`{address}`, to a growing object.
-  See :ref:`growing-objects`.
-
-.. function:: void obstack_grow0 (struct obstack *obstack_ptr, void *address, size_t size)
-
-  Add :samp:`{size}` bytes, copied from :samp:`{address}`, to a growing object,
-  and then add another byte containing a null character.  See :ref:`growing-objects`.
-
-.. function:: void obstack_1grow (struct obstack *obstack_ptr, char data_char)
-
-  Add one byte containing :samp:`{data-char}` to a growing object.
-  See :ref:`growing-objects`.
-
-.. function:: void *obstack_finish (struct obstack *obstack_ptr)
-
-  Finalize the object that is growing and return its permanent address.
-  See :ref:`growing-objects`.
-
-.. function:: size_t obstack_object_size (struct obstack *obstack_ptr)
-
-  Get the current size of the currently growing object.  See :ref:`growing-objects`.
-
-.. function:: void obstack_blank_fast (struct obstack *obstack_ptr, size_t size)
-
-  Add :samp:`{size}` uninitialized bytes to a growing object without checking
-  that there is enough room.  See :ref:`extra-fast-growing`.
-
-.. function:: void obstack_1grow_fast (struct obstack *obstack_ptr, char data_char)
-
-  Add one byte containing :samp:`{data-char}` to a growing object without
-  checking that there is enough room.  See :ref:`extra-fast-growing`.
-
-.. function:: size_t obstack_room (struct obstack *obstack_ptr)
-
-  Get the amount of room now available for growing the current object.
-  See :ref:`extra-fast-growing`.
-
-.. function:: size_t obstack_alignment_mask (struct obstack *obstack_ptr)
-
-  The mask used for aligning the beginning of an object.  This is an
-  lvalue.  See :ref:`obstacks-data-alignment`.
-
-.. function:: size_t obstack_chunk_size (struct obstack *obstack_ptr)
-
-  The size for allocating chunks.  This is an lvalue.  See :ref:`obstack-chunks`.
-
-.. function:: void *obstack_base (struct obstack *obstack_ptr)
-
-  Tentative starting address of the currently growing object.
-  See :ref:`status-of-an-obstack`.
-
-.. function:: void *obstack_next_free (struct obstack *obstack_ptr)
-
-  Address just after the end of the currently growing object.
-  See :ref:`status-of-an-obstack`.
\ No newline at end of file
diff --git a/libiberty/doc/function-variable-and-macro-listing.rst b/libiberty/doc/function-variable-and-macro-listing.rst
deleted file mode 100644
index 244ec9e..0000000
--- a/libiberty/doc/function-variable-and-macro-listing.rst
+++ /dev/null
@@ -1,1857 +0,0 @@
-..
-  Copyright 1988-2022 Free Software Foundation, Inc.
-  This is part of the GCC manual.
-  For copying conditions, see the copyright.rst file.
-
-.. _functions:
-
-Function, Variable, and Macro Listing.
---------------------------------------
-
-.. Automatically generated from *.c and others (the comments before
-   each entry tell you which file and where in that file).  DO NOT EDIT!
-   Edit the *.c files, configure with -enable-maintainer-mode,
-   run 'make stamp-functions' and gather-docs will build a new copy.
-   alloca.c:26
-
-.. function:: void* alloca (size_t size)
-
-  This function allocates memory which will be automatically reclaimed
-  after the procedure exits.  The ``libiberty`` implementation does not free
-  the memory immediately but will do so eventually during subsequent
-  calls to this function.  Memory is allocated using ``xmalloc`` under
-  normal circumstances.
-
-  The header file :samp:`alloca-conf.h` can be used in conjunction with the
-  GNU Autoconf test ``AC_FUNC_ALLOCA`` to test for and properly make
-  available this function.  The ``AC_FUNC_ALLOCA`` test requires that
-  client code use a block of preprocessor code to be safe (see the Autoconf
-  manual for more); this header incorporates that logic and more, including
-  the possibility of a GCC built-in function.
-
-.. asprintf.c:32
-
-.. function:: int asprintf (char **resptr, const char *format, ...)
-
-  Like ``sprintf``, but instead of passing a pointer to a buffer, you
-  pass a pointer to a pointer.  This function will compute the size of
-  the buffer needed, allocate memory with ``malloc``, and store a
-  pointer to the allocated memory in ``*resptr``.  The value
-  returned is the same as ``sprintf`` would return.  If memory could
-  not be allocated, minus one is returned and ``NULL`` is stored in
-  ``*resptr``.
-
-.. atexit.c:6
-
-.. function:: int atexit (void (*f)())
-
-  Causes function :samp:`{f}` to be called at exit.  Returns 0.
-
-.. basename.c:6
-
-.. function:: char* basename (const char *name)
-
-  Returns a pointer to the last component of pathname :samp:`{name}`.
-  Behavior is undefined if the pathname ends in a directory separator.
-
-.. bcmp.c:6
-
-.. function:: int bcmp (char *x, char *y, int count)
-
-  Compares the first :samp:`{count}` bytes of two areas of memory.  Returns
-  zero if they are the same, nonzero otherwise.  Returns zero if
-  :samp:`{count}` is zero.  A nonzero result only indicates a difference,
-  it does not indicate any sorting order (say, by having a positive
-  result mean :samp:`{x}` sorts before :samp:`{y}`).
-
-.. bcopy.c:3
-
-.. function:: void bcopy (char *in, char *out, int length)
-
-  Copies :samp:`{length}` bytes from memory region :samp:`{in}` to region
-  :samp:`{out}`.  The use of ``bcopy`` is deprecated in new programs.
-
-.. bsearch.c:33
-
-.. function:: void* bsearch (const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))
-
-  Performs a search over an array of :samp:`{nmemb}` elements pointed to by
-  :samp:`{base}` for a member that matches the object pointed to by :samp:`{key}`.
-  The size of each member is specified by :samp:`{size}`.  The array contents
-  should be sorted in ascending order according to the :samp:`{compar}`
-  comparison function.  This routine should take two arguments pointing to
-  the :samp:`{key}` and to an array member, in that order, and should return an
-  integer less than, equal to, or greater than zero if the :samp:`{key}` object
-  is respectively less than, matching, or greater than the array member.
-
-.. bsearch_r.c:33
-
-.. function:: void* bsearch_r (const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *, void *), void *arg)
-
-  Performs a search over an array of :samp:`{nmemb}` elements pointed to by
-  :samp:`{base}` for a member that matches the object pointed to by :samp:`{key}`.
-  The size of each member is specified by :samp:`{size}`.  The array contents
-  should be sorted in ascending order according to the :samp:`{compar}`
-  comparison function.  This routine should take three arguments: the first
-  two point to the :samp:`{key}` and to an array member, and the last is passed
-  down unchanged from ``bsearch_r`` 's last argument.  It should return an
-  integer less than, equal to, or greater than zero if the :samp:`{key}` object
-  is respectively less than, matching, or greater than the array member.
-
-.. argv.c:138
-
-.. function:: char** buildargv (char *sp)
-
-  Given a pointer to a string, parse the string extracting fields
-  separated by whitespace and optionally enclosed within either single
-  or double quotes (which are stripped off), and build a vector of
-  pointers to copies of the string for each field.  The input string
-  remains unchanged.  The last element of the vector is followed by a
-  ``NULL`` element.
-
-  All of the memory for the pointer array and copies of the string
-  is obtained from ``xmalloc``.  All of the memory can be returned to the
-  system with the single function call ``freeargv``, which takes the
-  returned result of ``buildargv``, as it's argument.
-
-  Returns a pointer to the argument vector if successful.  Returns
-  ``NULL`` if :samp:`{sp}` is ``NULL`` or if there is insufficient
-  memory to complete building the argument vector.
-
-  If the input is a null string (as opposed to a ``NULL`` pointer),
-  then buildarg returns an argument vector that has one arg, a null
-  string.
-
-.. bzero.c:6
-
-.. function:: void bzero (char *mem, int count)
-
-  Zeros :samp:`{count}` bytes starting at :samp:`{mem}`.  Use of this function
-  is deprecated in favor of ``memset``.
-
-.. calloc.c:6
-
-.. function:: void* calloc (size_t nelem, size_t elsize)
-
-  Uses ``malloc`` to allocate storage for :samp:`{nelem}` objects of
-  :samp:`{elsize}` bytes each, then zeros the memory.
-
-.. filename_cmp.c:201
-
-.. function:: int canonical_filename_eq (const char *a, const char *b)
-
-  Return non-zero if file names :samp:`{a}` and :samp:`{b}` are equivalent.
-  This function compares the canonical versions of the filenames as returned by
-  ``lrealpath()``, so that so that different file names pointing to the same
-  underlying file are treated as being identical.
-
-.. choose-temp.c:45
-
-.. function:: char* choose_temp_base (void)
-
-  Return a prefix for temporary file names or ``NULL`` if unable to
-  find one.  The current directory is chosen if all else fails so the
-  program is exited if a temporary directory can't be found (``mktemp``
-  fails).  The buffer for the result is obtained with ``xmalloc``.
-
-  This function is provided for backwards compatibility only.  Its use is
-  not recommended.
-
-.. make-temp-file.c:95
-
-.. function:: const char* choose_tmpdir ()
-
-  Returns a pointer to a directory path suitable for creating temporary
-  files in.
-
-.. clock.c:27
-
-.. function:: long clock (void)
-
-  Returns an approximation of the CPU time used by the process as a
-  ``clock_t`` ; divide this number by :samp:`CLOCKS_PER_SEC` to get the
-  number of seconds used.
-
-.. concat.c:24
-
-.. function:: char* concat (const char *s1, const char *s2, ..., NULL)
-
-  Concatenate zero or more of strings and return the result in freshly
-  ``xmalloc`` ed memory.  The argument list is terminated by the first
-  ``NULL`` pointer encountered.  Pointers to empty strings are ignored.
-
-.. argv.c:495
-
-.. function:: int countargv (char * const *argv)
-
-  Return the number of elements in :samp:`{argv}`.
-  Returns zero if :samp:`{argv}` is NULL.
-
-.. crc32.c:140
-
-.. function:: unsigned int crc32 (const unsigned char *buf, int len, unsigned int init)
-
-  Compute the 32-bit CRC of :samp:`{buf}` which has length :samp:`{len}`.  The
-  starting value is :samp:`{init}` ; this may be used to compute the CRC of
-  data split across multiple buffers by passing the return value of each
-  call as the :samp:`{init}` parameter of the next.
-
-  This is used by the :command:`gdb` remote protocol for the :samp:`qCRC`
-  command.  In order to get the same results as gdb for a block of data,
-  you must pass the first CRC parameter as ``0xffffffff``.
-
-  This CRC can be specified as:
-
-  Width  : 32
-    Poly   : 0x04c11db7
-    Init   : parameter, typically 0xffffffff
-    RefIn  : false
-    RefOut : false
-    XorOut : 0
-
-  This differs from the "standard" CRC-32 algorithm in that the values
-  are not reflected, and there is no final XOR value.  These differences
-  make it easy to compose the values of multiple blocks.
-
-.. argv.c:59
-
-.. function:: char** dupargv (char * const *vector)
-
-  Duplicate an argument vector.  Simply scans through :samp:`{vector}`,
-  duplicating each argument until the terminating ``NULL`` is found.
-  Returns a pointer to the argument vector if successful.  Returns
-  ``NULL`` if there is insufficient memory to complete building the
-  argument vector.
-
-.. strerror.c:572
-
-.. function:: int errno_max (void)
-
-  Returns the maximum ``errno`` value for which a corresponding
-  symbolic name or message is available.  Note that in the case where we
-  use the ``sys_errlist`` supplied by the system, it is possible for
-  there to be more symbolic names than messages, or vice versa.  In
-  fact, the manual page for ``perror(3C)`` explicitly warns that one
-  should check the size of the table (``sys_nerr``) before indexing
-  it, since new error codes may be added to the system before they are
-  added to the table.  Thus ``sys_nerr`` might be smaller than value
-  implied by the largest ``errno`` value defined in ``<errno.h>``.
-
-  We return the maximum value that can be used to obtain a meaningful
-  symbolic name or message.
-
-.. argv.c:352
-
-.. function:: void expandargv (int *argcp, char ***argvp)
-
-  The :samp:`{argcp}` and ``argvp`` arguments are pointers to the usual
-  ``argc`` and ``argv`` arguments to ``main``.  This function
-  looks for arguments that begin with the character :samp:`@`.  Any such
-  arguments are interpreted as 'response files'.  The contents of the
-  response file are interpreted as additional command line options.  In
-  particular, the file is separated into whitespace-separated strings;
-  each such string is taken as a command-line option.  The new options
-  are inserted in place of the option naming the response file, and
-  ``*argcp`` and ``*argvp`` will be updated.  If the value of
-  ``*argvp`` is modified by this function, then the new value has
-  been dynamically allocated and can be deallocated by the caller with
-  ``freeargv``.  However, most callers will simply call
-  ``expandargv`` near the beginning of ``main`` and allow the
-  operating system to free the memory when the program exits.
-
-.. fdmatch.c:23
-
-.. function:: int fdmatch (int fd1, int fd2)
-
-  Check to see if two open file descriptors refer to the same file.
-  This is useful, for example, when we have an open file descriptor for
-  an unnamed file, and the name of a file that we believe to correspond
-  to that fd.  This can happen when we are exec'd with an already open
-  file (``stdout`` for example) or from the SVR4 :samp:`/proc` calls
-  that return open file descriptors for mapped address spaces.  All we
-  have to do is open the file by name and check the two file descriptors
-  for a match, which is done by comparing major and minor device numbers
-  and inode numbers.
-
-.. fopen_unlocked.c:49
-
-.. function:: FILE * fdopen_unlocked (int fildes, const char * mode)
-
-  Opens and returns a ``FILE`` pointer via ``fdopen``.  If the
-  operating system supports it, ensure that the stream is setup to avoid
-  any multi-threaded locking.  Otherwise return the ``FILE`` pointer
-  unchanged.
-
-.. ffs.c:3
-
-.. function:: int ffs (int valu)
-
-  Find the first (least significant) bit set in :samp:`{valu}`.  Bits are
-  numbered from right to left, starting with bit 1 (corresponding to the
-  value 1).  If :samp:`{valu}` is zero, zero is returned.
-
-.. filename_cmp.c:37
-
-.. function:: int filename_cmp (const char *s1, const char *s2)
-
-  Return zero if the two file names :samp:`{s1}` and :samp:`{s2}` are equivalent.
-  If not equivalent, the returned value is similar to what ``strcmp``
-  would return.  In other words, it returns a negative value if :samp:`{s1}`
-  is less than :samp:`{s2}`, or a positive value if :samp:`{s2}` is greater than
-  :samp:`{s2}`.
-
-  This function does not normalize file names.  As a result, this function
-  will treat filenames that are spelled differently as different even in
-  the case when the two filenames point to the same underlying file.
-  However, it does handle the fact that on DOS-like file systems, forward
-  and backward slashes are equal.
-
-.. filename_cmp.c:183
-
-.. function:: int filename_eq (const void *s1, const void *s2)
-
-  Return non-zero if file names :samp:`{s1}` and :samp:`{s2}` are equivalent.
-  This function is for use with hashtab.c hash tables.
-
-.. filename_cmp.c:152
-
-.. function:: hashval_t filename_hash (const void *s)
-
-  Return the hash value for file name :samp:`{s}` that will be compared
-  using filename_cmp.
-  This function is for use with hashtab.c hash tables.
-
-.. filename_cmp.c:94
-
-.. function:: int filename_ncmp (const char *s1, const char *s2, size_t n)
-
-  Return zero if the two file names :samp:`{s1}` and :samp:`{s2}` are equivalent
-  in range :samp:`{n}`.
-  If not equivalent, the returned value is similar to what ``strncmp``
-  would return.  In other words, it returns a negative value if :samp:`{s1}`
-  is less than :samp:`{s2}`, or a positive value if :samp:`{s2}` is greater than
-  :samp:`{s2}`.
-
-  This function does not normalize file names.  As a result, this function
-  will treat filenames that are spelled differently as different even in
-  the case when the two filenames point to the same underlying file.
-  However, it does handle the fact that on DOS-like file systems, forward
-  and backward slashes are equal.
-
-.. fnmatch.txh:1
-
-.. function:: int fnmatch (const char *pattern, const char *string, int flags)
-
-  Matches :samp:`{string}` against :samp:`{pattern}`, returning zero if it
-  matches, ``FNM_NOMATCH`` if not.  :samp:`{pattern}` may contain the
-  wildcards ``?`` to match any one character, ``*`` to match any
-  zero or more characters, or a set of alternate characters in square
-  brackets, like :samp:`[a-gt8]`, which match one character (``a``
-  through ``g``, or ``t``, or ``8``, in this example) if that one
-  character is in the set.  A set may be inverted (i.e., match anything
-  except what's in the set) by giving ``^`` or ``!`` as the first
-  character in the set.  To include those characters in the set, list them
-  as anything other than the first character of the set.  To include a
-  dash in the set, list it last in the set.  A backslash character makes
-  the following character not special, so for example you could match
-  against a literal asterisk with :samp:`\\*`.  To match a literal
-  backslash, use :samp:`\\\\`.
-
-  ``flags`` controls various aspects of the matching process, and is a
-  boolean OR of zero or more of the following values (defined in
-  ``<fnmatch.h>``):
-
-  .. envvar:: FNM_PATHNAME
-
-    :samp:`{string}` is assumed to be a path name.  No wildcard will ever match
-    ``/``.
-
-  .. envvar:: FNM_NOESCAPE
-
-    Do not interpret backslashes as quoting the following special character.
-
-  .. envvar:: FNM_PERIOD
-
-    A leading period (at the beginning of :samp:`{string}`, or if
-    ``FNM_PATHNAME`` after a slash) is not matched by ``*`` or
-    ``?`` but must be matched explicitly.
-
-  .. envvar:: FNM_LEADING_DIR
-
-    Means that :samp:`{string}` also matches :samp:`{pattern}` if some initial part
-    of :samp:`{string}` matches, and is followed by ``/`` and zero or more
-    characters.  For example, :samp:`foo*` would match either :samp:`foobar`
-    or :samp:`foobar/grill`.
-
-  .. envvar:: FNM_CASEFOLD
-
-    Ignores case when performing the comparison.
-
-.. fopen_unlocked.c:39
-
-.. function:: FILE * fopen_unlocked (const char *path, const char * mode)
-
-  Opens and returns a ``FILE`` pointer via ``fopen``.  If the
-  operating system supports it, ensure that the stream is setup to avoid
-  any multi-threaded locking.  Otherwise return the ``FILE`` pointer
-  unchanged.
-
-.. argv.c:93
-
-.. function:: void freeargv (char **vector)
-
-  Free an argument vector that was built using ``buildargv``.  Simply
-  scans through :samp:`{vector}`, freeing the memory for each argument until
-  the terminating ``NULL`` is found, and then frees :samp:`{vector}`
-  itself.
-
-.. fopen_unlocked.c:59
-
-.. function:: FILE * freopen_unlocked (const char * path, const char * mode, FILE * stream)
-
-  Opens and returns a ``FILE`` pointer via ``freopen``.  If the
-  operating system supports it, ensure that the stream is setup to avoid
-  any multi-threaded locking.  Otherwise return the ``FILE`` pointer
-  unchanged.
-
-.. getruntime.c:86
-
-.. function:: long get_run_time (void)
-
-  Returns the time used so far, in microseconds.  If possible, this is
-  the time used by this process, else it is the elapsed time since the
-  process started.
-
-.. getcwd.c:6
-
-.. function:: char* getcwd (char *pathname, int len)
-
-  Copy the absolute pathname for the current working directory into
-  :samp:`{pathname}`, which is assumed to point to a buffer of at least
-  :samp:`{len}` bytes, and return a pointer to the buffer.  If the current
-  directory's path doesn't fit in :samp:`{len}` characters, the result is
-  ``NULL`` and ``errno`` is set.  If :samp:`{pathname}` is a null pointer,
-  ``getcwd`` will obtain :samp:`{len}` bytes of space using
-  ``malloc``.
-
-.. getpagesize.c:5
-
-.. function:: int getpagesize (void)
-
-  Returns the number of bytes in a page of memory.  This is the
-  granularity of many of the system memory management routines.  No
-  guarantee is made as to whether or not it is the same as the basic
-  memory management hardware page size.
-
-.. getpwd.c:5
-
-.. function:: char* getpwd (void)
-
-  Returns the current working directory.  This implementation caches the
-  result on the assumption that the process will not call ``chdir``
-  between calls to ``getpwd``.
-
-.. gettimeofday.c:12
-
-.. function:: int gettimeofday (struct timeval *tp, void *tz)
-
-  Writes the current time to :samp:`{tp}`.  This implementation requires
-  that :samp:`{tz}` be NULL.  Returns 0 on success, -1 on failure.
-
-.. hex.c:33
-
-.. function:: void hex_init (void)
-
-  Initializes the array mapping the current character set to
-  corresponding hex values.  This function must be called before any
-  call to ``hex_p`` or ``hex_value``.  If you fail to call it, a
-  default ASCII-based table will normally be used on ASCII systems.
-
-.. hex.c:42
-
-.. function:: int hex_p (int c)
-
-  Evaluates to non-zero if the given character is a valid hex character,
-  or zero if it is not.  Note that the value you pass will be cast to
-  ``unsigned char`` within the macro.
-
-.. hex.c:50
-
-.. function:: unsigned int hex_value (int c)
-
-  Returns the numeric equivalent of the given character when interpreted
-  as a hexadecimal digit.  The result is undefined if you pass an
-  invalid hex digit.  Note that the value you pass will be cast to
-  ``unsigned char`` within the macro.
-
-  The ``hex_value`` macro returns ``unsigned int``, rather than
-  signed ``int``, to make it easier to use in parsing addresses from
-  hex dump files: a signed ``int`` would be sign-extended when
-  converted to a wider unsigned type --- like ``bfd_vma``, on some
-  systems.
-
-.. safe-ctype.c:24
-
-.. index:: HOST_CHARSET
-
-.. c:macro:: HOST_CHARSET
-
-  This macro indicates the basic character set and encoding used by the
-  host: more precisely, the encoding used for character constants in
-  preprocessor :samp:`#if` statements (the C "execution character set").
-  It is defined by :samp:`safe-ctype.h`, and will be an integer constant
-  with one of the following values:
-
-.. envvar:: HOST_CHARSET_UNKNOWN
-
-  The host character set is unknown - that is, not one of the next two
-  possibilities.
-
-.. envvar:: HOST_CHARSET_ASCII
-
-  The host character set is ASCII.
-
-.. envvar:: HOST_CHARSET_EBCDIC
-
-  The host character set is some variant of EBCDIC.  (Only one of the
-  nineteen EBCDIC varying characters is tested; exercise caution.)
-
-.. hashtab.c:327
-
-.. function:: htab_t htab_create_typed_alloc (size_t size, htab_hash hash_f, htab_eq eq_f, htab_del del_f, htab_alloc alloc_tab_f, htab_alloc alloc_f, htab_free free_f)
-
-  This function creates a hash table that uses two different allocators
-  :samp:`{alloc_tab_f}` and :samp:`{alloc_f}` to use for allocating the table itself
-  and its entries respectively.  This is useful when variables of different
-  types need to be allocated with different allocators.
-
-  The created hash table is slightly larger than :samp:`{size}` and it is
-  initially empty (all the hash table entries are ``HTAB_EMPTY_ENTRY``).
-  The function returns the created hash table, or ``NULL`` if memory
-  allocation fails.
-
-.. index.c:5
-
-.. function:: char* index (char *s, int c)
-
-  Returns a pointer to the first occurrence of the character :samp:`{c}` in
-  the string :samp:`{s}`, or ``NULL`` if not found.  The use of ``index`` is
-  deprecated in new programs in favor of ``strchr``.
-
-.. insque.c:6
-
-.. function:: void insque (struct qelem *elem, struct qelem *pred)
-              void remque (struct qelem *elem)
-
-  Routines to manipulate queues built from doubly linked lists.  The
-  ``insque`` routine inserts :samp:`{elem}` in the queue immediately
-  after :samp:`{pred}`.  The ``remque`` routine removes :samp:`{elem}` from
-  its containing queue.  These routines expect to be passed pointers to
-  structures which have as their first members a forward pointer and a
-  back pointer, like this prototype (although no prototype is provided):
-
-  .. code-block:: c++
-
-    struct qelem {
-      struct qelem *q_forw;
-      struct qelem *q_back;
-      char q_data[];
-    };
-
-.. safe-ctype.c:45
-
-.. c:macro:: ISALPHA (c)
-             ISALNUM (c)
-             ISBLANK (c)
-             ISCNTRL (c)
-             ISDIGIT (c)
-             ISGRAPH (c)
-             ISLOWER (c)
-             ISPRINT (c)
-             ISPUNCT (c)
-             ISSPACE (c)
-             ISUPPER (c)
-             ISXDIGIT (c)
-
-These twelve macros are defined by :samp:`safe-ctype.h`.  Each has the
-same meaning as the corresponding macro (with name in lowercase)
-defined by the standard header :samp:`ctype.h`.  For example,
-``ISALPHA`` returns true for alphabetic characters and false for
-others.  However, there are two differences between these macros and
-those provided by :samp:`ctype.h`:
-
-* These macros are guaranteed to have well-defined behavior for all
-  values representable by ``signed char`` and ``unsigned char``, and
-  for ``EOF``.
-
-* These macros ignore the current locale; they are true for these
-  fixed sets of characters:
-
-  .. list-table::
-
-     * - ``ALPHA``
-       - A-Za-z
-     * - ``ALNUM``
-       - A-Za-z0-9
-     * - ``BLANK``
-       - space tab
-     * - ``CNTRL``
-       - ``!PRINT``
-     * - ``DIGIT``
-       - 0-9
-     * - ``GRAPH``
-       - ``ALNUM || PUNCT``
-     * - ``LOWER``
-       - a-z
-     * - ``PRINT``
-       - ``GRAPH ||`` space
-     * - ``PUNCT``
-       - `~!@#$%^&\*()_-=+[{]}\|;:'",<.>/?
-     * - ``SPACE``
-       - space tab \n \r \f \v
-     * - ``UPPER``
-       - A-Z
-     * - ``XDIGIT``
-       - 0-9A-Fa-f
-
-  Note that, if the host character set is ASCII or a superset thereof,
-  all these macros will return false for all values of ``char`` outside
-  the range of 7-bit ASCII.  In particular, both ISPRINT and ISCNTRL return
-  false for characters with numeric values from 128 to 255.
-
-.. safe-ctype.c:94
-
-.. c:macro:: ISIDNUM (c)
-             ISIDST (c)
-             IS_VSPACE (c)
-             IS_NVSPACE (c)
-             IS_SPACE_OR_NUL (c)
-             IS_ISOBASIC (c)
-
-These six macros are defined by safe-ctype.h and provide
-additional character classes which are useful when doing lexical
-analysis of C or similar languages.  They are true for the following
-sets of characters:
-
-.. list-table::
-
-   * - ``IDNUM``
-     - A-Za-z0-9\_
-   * - ``IDST``
-     - A-Za-z\_
-   * - ``VSPACE``
-     - \r \n
-   * - ``NVSPACE``
-     - space tab \f \v \0
-   * - ``SPACE_OR_NUL``
-     - ``VSPACE || NVSPACE``
-   * - ``ISOBASIC``
-     - ``VSPACE || NVSPACE || PRINT``
-
-.. lbasename.c:23
-
-.. function:: const char* lbasename (const char *name)
-
-  Given a pointer to a string containing a typical pathname
-  (:samp:`/usr/src/cmd/ls/ls.c` for example), returns a pointer to the
-  last component of the pathname (:samp:`ls.c` in this case).  The
-  returned pointer is guaranteed to lie within the original
-  string.  This latter fact is not true of many vendor C
-  libraries, which return special strings or modify the passed
-  strings for particular input.
-
-  In particular, the empty string returns the same empty string,
-  and a path ending in ``/`` returns the empty string after it.
-
-.. lrealpath.c:25
-
-.. function:: const char* lrealpath (const char *name)
-
-  Given a pointer to a string containing a pathname, returns a canonical
-  version of the filename.  Symlinks will be resolved, and '.' and '..'
-  components will be simplified.  The returned value will be allocated using
-  ``malloc``, or ``NULL`` will be returned on a memory allocation error.
-
-.. make-relative-prefix.c:23
-
-.. function:: const char* make_relative_prefix (const char *progname, const char *bin_prefix, const char *prefix)
-
-  Given three paths :samp:`{progname}`, :samp:`{bin_prefix}`, :samp:`{prefix}`,
-  return the path that is in the same position relative to
-  :samp:`{progname}` 's directory as :samp:`{prefix}` is relative to
-  :samp:`{bin_prefix}`.  That is, a string starting with the directory
-  portion of :samp:`{progname}`, followed by a relative pathname of the
-  difference between :samp:`{bin_prefix}` and :samp:`{prefix}`.
-
-  If :samp:`{progname}` does not contain any directory separators,
-  ``make_relative_prefix`` will search :envvar:`PATH` to find a program
-  named :samp:`{progname}`.  Also, if :samp:`{progname}` is a symbolic link,
-  the symbolic link will be resolved.
-
-  For example, if :samp:`{bin_prefix}` is ``/alpha/beta/gamma/gcc/delta``,
-  :samp:`{prefix}` is ``/alpha/beta/gamma/omega/``, and :samp:`{progname}` is
-  ``/red/green/blue/gcc``, then this function will return
-  ``/red/green/blue/../../omega/``.
-
-  The return value is normally allocated via ``malloc``.  If no
-  relative prefix can be found, return ``NULL``.
-
-.. make-temp-file.c:173
-
-.. function:: char* make_temp_file (const char *suffix)
-
-  Return a temporary file name (as a string) or ``NULL`` if unable to
-  create one.  :samp:`{suffix}` is a suffix to append to the file name.  The
-  string is ``malloc`` ed, and the temporary file has been created.
-
-.. memchr.c:3
-
-.. function:: void* memchr (const void *s, int c, size_t n)
-
-  This function searches memory starting at ``*s`` for the
-  character :samp:`{c}`.  The search only ends with the first occurrence of
-  :samp:`{c}`, or after :samp:`{length}` characters; in particular, a null
-  character does not terminate the search.  If the character :samp:`{c}` is
-  found within :samp:`{length}` characters of ``*s``, a pointer
-  to the character is returned.  If :samp:`{c}` is not found, then ``NULL`` is
-  returned.
-
-.. memcmp.c:6
-
-.. function:: int memcmp (const void *x, const void *y, size_t count)
-
-  Compares the first :samp:`{count}` bytes of two areas of memory.  Returns
-  zero if they are the same, a value less than zero if :samp:`{x}` is
-  lexically less than :samp:`{y}`, or a value greater than zero if :samp:`{x}`
-  is lexically greater than :samp:`{y}`.  Note that lexical order is determined
-  as if comparing unsigned char arrays.
-
-.. memcpy.c:6
-
-.. function:: void* memcpy (void *out, const void *in, size_t length)
-
-  Copies :samp:`{length}` bytes from memory region :samp:`{in}` to region
-  :samp:`{out}`.  Returns a pointer to :samp:`{out}`.
-
-.. memmem.c:20
-
-.. function:: void* memmem (const void *haystack,size_t haystack_len, const void *needle, size_t needle_len)
-
-  Returns a pointer to the first occurrence of :samp:`{needle}` (length
-  :samp:`{needle_len}`) in :samp:`{haystack}` (length :samp:`{haystack_len}`).
-  Returns ``NULL`` if not found.
-
-.. memmove.c:6
-
-.. function:: void* memmove (void *from, const void *to, size_t count)
-
-  Copies :samp:`{count}` bytes from memory area :samp:`{from}` to memory area
-  :samp:`{to}`, returning a pointer to :samp:`{to}`.
-
-.. mempcpy.c:23
-
-.. function:: void* mempcpy (void *out, const void *in, size_t length)
-
-  Copies :samp:`{length}` bytes from memory region :samp:`{in}` to region
-  :samp:`{out}`.  Returns a pointer to :samp:`{out}` + :samp:`{length}`.
-
-.. memset.c:6
-
-.. function:: void* memset (void *s, int c, size_t count)
-
-  Sets the first :samp:`{count}` bytes of :samp:`{s}` to the constant byte
-  :samp:`{c}`, returning a pointer to :samp:`{s}`.
-
-.. mkstemps.c:60
-
-.. function:: int mkstemps (char *pattern, int suffix_len)
-
-  Generate a unique temporary file name from :samp:`{pattern}`.
-  :samp:`{pattern}` has the form:
-
-  .. code-block:: c++
-
-       path/ccXXXXXXsuffix
-
-  :samp:`{suffix_len}` tells us how long :samp:`{suffix}` is (it can be zero
-  length).  The last six characters of :samp:`{pattern}` before :samp:`{suffix}`
-  must be :samp:`XXXXXX`; they are replaced with a string that makes the
-  filename unique.  Returns a file descriptor open on the file for
-  reading and writing.
-
-.. pexecute.txh:278
-
-.. function:: void pex_free (struct pex_obj obj)
-
-  Clean up and free all data associated with :samp:`{obj}`.  If you have not
-  yet called ``pex_get_times`` or ``pex_get_status``, this will
-  try to kill the subprocesses.
-
-.. pexecute.txh:251
-
-.. function:: int pex_get_status (struct pex_obj *obj, int count, int *vector)
-
-  Returns the exit status of all programs run using :samp:`{obj}`.
-  :samp:`{count}` is the number of results expected.  The results will be
-  placed into :samp:`{vector}`.  The results are in the order of the calls
-  to ``pex_run``.  Returns 0 on error, 1 on success.
-
-.. pexecute.txh:261
-
-.. function:: int pex_get_times (struct pex_obj *obj, int count, struct pex_time *vector)
-
-  Returns the process execution times of all programs run using
-  :samp:`{obj}`.  :samp:`{count}` is the number of results expected.  The
-  results will be placed into :samp:`{vector}`.  The results are in the
-  order of the calls to ``pex_run``.  Returns 0 on error, 1 on
-  success.
-
-  ``struct pex_time`` has the following fields of the type
-  ``unsigned long`` : ``user_seconds``,
-  ``user_microseconds``, ``system_seconds``,
-  ``system_microseconds``.  On systems which do not support reporting
-  process times, all the fields will be set to ``0``.
-
-.. pexecute.txh:2
-
-.. function:: struct pex_obj * pex_init (int flags, const char *pname, const char *tempbase)
-
-  Prepare to execute one or more programs, with standard output of each
-  program fed to standard input of the next.  This is a system
-  independent interface to execute a pipeline.
-
-  :samp:`{flags}` is a bitwise combination of the following:
-
-  .. index:: PEX_RECORD_TIMES
-
-  .. envvar:: PEX_RECORD_TIMES
-
-    Record subprocess times if possible.
-
-    .. index:: PEX_USE_PIPES
-
-  .. envvar:: PEX_USE_PIPES
-
-    Use pipes for communication between processes, if possible.
-
-    .. index:: PEX_SAVE_TEMPS
-
-  .. envvar:: PEX_SAVE_TEMPS
-
-    Don't delete temporary files used for communication between
-    processes.
-
-  :samp:`{pname}` is the name of program to be executed, used in error
-  messages.  :samp:`{tempbase}` is a base name to use for any required
-  temporary files; it may be ``NULL`` to use a randomly chosen name.
-
-.. pexecute.txh:161
-
-.. function:: FILE * pex_input_file (struct pex_obj *obj, int flags, const char *in_name)
-
-  Return a stream for a temporary file to pass to the first program in
-  the pipeline as input.
-
-  The name of the input file is chosen according to the same rules
-  ``pex_run`` uses to choose output file names, based on
-  :samp:`{in_name}`, :samp:`{obj}` and the ``PEX_SUFFIX`` bit in :samp:`{flags}`.
-
-  Don't call ``fclose`` on the returned stream; the first call to
-  ``pex_run`` closes it automatically.
-
-  If :samp:`{flags}` includes ``PEX_BINARY_OUTPUT``, open the stream in
-  binary mode; otherwise, open it in the default mode.  Including
-  ``PEX_BINARY_OUTPUT`` in :samp:`{flags}` has no effect on Unix.
-
-.. pexecute.txh:179
-
-.. function:: FILE * pex_input_pipe (struct pex_obj *obj, int binary)
-
-  Return a stream :samp:`{fp}` for a pipe connected to the standard input of
-  the first program in the pipeline; :samp:`{fp}` is opened for writing.
-  You must have passed ``PEX_USE_PIPES`` to the ``pex_init`` call
-  that returned :samp:`{obj}`.
-
-  You must close :samp:`{fp}` using ``fclose`` yourself when you have
-  finished writing data to the pipeline.
-
-  The file descriptor underlying :samp:`{fp}` is marked not to be inherited
-  by child processes.
-
-  On systems that do not support pipes, this function returns
-  ``NULL``, and sets ``errno`` to ``EINVAL``.  If you would
-  like to write code that is portable to all systems the ``pex``
-  functions support, consider using ``pex_input_file`` instead.
-
-  There are two opportunities for deadlock using
-  ``pex_input_pipe`` :
-
-  * Most systems' pipes can buffer only a fixed amount of data; a process
-    that writes to a full pipe blocks.  Thus, if you write to :samp:`fp`
-    before starting the first process, you run the risk of blocking when
-    there is no child process yet to read the data and allow you to
-    continue.  ``pex_input_pipe`` makes no promises about the
-    size of the pipe's buffer, so if you need to write any data at all
-    before starting the first process in the pipeline, consider using
-    ``pex_input_file`` instead.
-
-  * Using ``pex_input_pipe`` and ``pex_read_output`` together
-    may also cause deadlock.  If the output pipe fills up, so that each
-    program in the pipeline is waiting for the next to read more data, and
-    you fill the input pipe by writing more data to :samp:`{fp}`, then there
-    is no way to make progress: the only process that could read data from
-    the output pipe is you, but you are blocked on the input pipe.
-
-.. pexecute.txh:286
-
-.. function:: const char * pex_one (int flags, const char *executable, char * const *argv, const char *pname, const char *outname, const char *errname, int *status, int *err)
-
-  An interface to permit the easy execution of a
-  single program.  The return value and most of the parameters are as
-  for a call to ``pex_run``.  :samp:`{flags}` is restricted to a
-  combination of ``PEX_SEARCH``, ``PEX_STDERR_TO_STDOUT``, and
-  ``PEX_BINARY_OUTPUT``.  :samp:`{outname}` is interpreted as if
-  ``PEX_LAST`` were set.  On a successful return, ``*status`` will
-  be set to the exit status of the program.
-
-.. pexecute.txh:237
-
-.. function:: FILE * pex_read_err (struct pex_obj *obj, int binary)
-
-  Returns a ``FILE`` pointer which may be used to read the standard
-  error of the last program in the pipeline.  When this is used,
-  ``PEX_LAST`` should not be used in a call to ``pex_run``.  After
-  this is called, ``pex_run`` may no longer be called with the same
-  :samp:`{obj}`.  :samp:`{binary}` should be non-zero if the file should be
-  opened in binary mode.  Don't call ``fclose`` on the returned file;
-  it will be closed by ``pex_free``.
-
-.. pexecute.txh:224
-
-.. function:: FILE * pex_read_output (struct pex_obj *obj, int binary)
-
-  Returns a ``FILE`` pointer which may be used to read the standard
-  output of the last program in the pipeline.  When this is used,
-  ``PEX_LAST`` should not be used in a call to ``pex_run``.  After
-  this is called, ``pex_run`` may no longer be called with the same
-  :samp:`{obj}`.  :samp:`{binary}` should be non-zero if the file should be
-  opened in binary mode.  Don't call ``fclose`` on the returned file;
-  it will be closed by ``pex_free``.
-
-.. pexecute.txh:34
-
-.. function:: const char * pex_run (struct pex_obj *obj, int flags, const char *executable, char * const *argv, const char *outname, const char *errname, int *err)
-
-  Execute one program in a pipeline.  On success this returns
-  ``NULL``.  On failure it returns an error message, a statically
-  allocated string.
-
-  :samp:`{obj}` is returned by a previous call to ``pex_init``.
-
-  :samp:`{flags}` is a bitwise combination of the following:
-
-  .. index:: PEX_LAST
-
-  .. envvar:: PEX_LAST
-
-    This must be set on the last program in the pipeline.  In particular,
-    it should be set when executing a single program.  The standard output
-    of the program will be sent to :samp:`{outname}`, or, if :samp:`{outname}` is
-    ``NULL``, to the standard output of the calling program.  Do *not*
-    set this bit if you want to call ``pex_read_output``
-    (described below).  After a call to ``pex_run`` with this bit set,
-    :samp:`{pex_run}` may no longer be called with the same :samp:`{obj}`.
-
-    .. index:: PEX_SEARCH
-
-  .. envvar:: PEX_SEARCH
-
-    Search for the program using the user's executable search path.
-
-    .. index:: PEX_SUFFIX
-
-  .. envvar:: PEX_SUFFIX
-
-    :samp:`{outname}` is a suffix.  See the description of :samp:`{outname}`,
-    below.
-
-    .. index:: PEX_STDERR_TO_STDOUT
-
-  .. envvar:: PEX_STDERR_TO_STDOUT
-
-    Send the program's standard error to standard output, if possible.
-
-    .. index:: PEX_BINARY_INPUT, PEX_BINARY_OUTPUT, PEX_BINARY_ERROR
-
-  .. envvar:: PEX_BINARY_INPUT
-
-    The standard input (output or error) of the program should be read (written) in
-    binary mode rather than text mode.  These flags are ignored on systems
-    which do not distinguish binary mode and text mode, such as Unix.  For
-    proper behavior these flags should match appropriately---a call to
-    ``pex_run`` using ``PEX_BINARY_OUTPUT`` should be followed by a
-    call using ``PEX_BINARY_INPUT``.
-
-    .. index:: PEX_STDERR_TO_PIPE
-
-  .. envvar:: PEX_STDERR_TO_PIPE
-
-    Send the program's standard error to a pipe, if possible.  This flag
-    cannot be specified together with ``PEX_STDERR_TO_STDOUT``.  This
-    flag can be specified only on the last program in pipeline.
-
-  :samp:`{executable}` is the program to execute.  :samp:`{argv}` is the set of
-  arguments to pass to the program; normally ``argv[0]`` will
-  be a copy of :samp:`{executable}`.
-
-  :samp:`{outname}` is used to set the name of the file to use for standard
-  output.  There are two cases in which no output file will be used:
-
-  * if ``PEX_LAST`` is not set in :samp:`{flags}`, and ``PEX_USE_PIPES``
-    was set in the call to ``pex_init``, and the system supports pipes
-
-  * if ``PEX_LAST`` is set in :samp:`{flags}`, and :samp:`{outname}` is
-    ``NULL``
-
-  Otherwise the code will use a file to hold standard
-  output.  If ``PEX_LAST`` is not set, this file is considered to be
-  a temporary file, and it will be removed when no longer needed, unless
-  ``PEX_SAVE_TEMPS`` was set in the call to ``pex_init``.
-
-  There are two cases to consider when setting the name of the file to
-  hold standard output.
-
-  * ``PEX_SUFFIX`` is set in :samp:`{flags}`.  In this case
-    :samp:`{outname}` may not be ``NULL``.  If the :samp:`{tempbase}` parameter
-    to ``pex_init`` was not ``NULL``, then the output file name is
-    the concatenation of :samp:`{tempbase}` and :samp:`{outname}`.  If
-    :samp:`{tempbase}` was ``NULL``, then the output file name is a random
-    file name ending in :samp:`{outname}`.
-
-  * ``PEX_SUFFIX`` was not set in :samp:`{flags}`.  In this
-    case, if :samp:`{outname}` is not ``NULL``, it is used as the output
-    file name.  If :samp:`{outname}` is ``NULL``, and :samp:`{tempbase}` was
-    not NULL, the output file name is randomly chosen using
-    :samp:`{tempbase}`.  Otherwise the output file name is chosen completely
-    at random.
-
-  :samp:`{errname}` is the file name to use for standard error output.  If
-  it is ``NULL``, standard error is the same as the caller's.
-  Otherwise, standard error is written to the named file.
-
-  On an error return, the code sets ``*err`` to an ``errno``
-  value, or to 0 if there is no relevant ``errno``.
-
-.. pexecute.txh:145
-
-.. function:: const char * pex_run_in_environment (struct pex_obj *obj, int flags, const char *executable, char * const *argv, char * const *env, int env_size, const char *outname, const char *errname, int *err)
-
-  Execute one program in a pipeline, permitting the environment for the
-  program to be specified.  Behaviour and parameters not listed below are
-  as for ``pex_run``.
-
-  :samp:`{env}` is the environment for the child process, specified as an array of
-  character pointers.  Each element of the array should point to a string of the
-  form ``VAR=VALUE``, with the exception of the last element that must be
-  ``NULL``.
-
-.. pexecute.txh:301
-
-.. function:: int pexecute (const char *program, char * const *argv, const char *this_pname, const char *temp_base, char **errmsg_fmt, char **errmsg_arg, int flags)
-
-  This is the old interface to execute one or more programs.  It is
-  still supported for compatibility purposes, but is no longer
-  documented.
-
-.. strsignal.c:541
-
-.. function:: void psignal (int signo, char *message)
-
-  Print :samp:`{message}` to the standard error, followed by a colon,
-  followed by the description of the signal specified by :samp:`{signo}`,
-  followed by a newline.
-
-.. putenv.c:21
-
-.. function:: int putenv (const char *string)
-
-  Uses ``setenv`` or ``unsetenv`` to put :samp:`{string}` into
-  the environment or remove it.  If :samp:`{string}` is of the form
-  :samp:`name=value` the string is added; if no :samp:`=` is present the
-  name is unset/removed.
-
-.. pexecute.txh:312
-
-.. function:: int pwait (int pid, int *status, int flags)
-
-  Another part of the old execution interface.
-
-.. random.c:39
-
-.. function:: long int random (void)
-              void srandom (unsigned int seed)
-              void* initstate (unsigned int seed, void *arg_state, unsigned long n)
-              void* setstate (void *arg_state)
-
-  Random number functions.  ``random`` returns a random number in the
-  range 0 to ``LONG_MAX``.  ``srandom`` initializes the random
-  number generator to some starting point determined by :samp:`{seed}`
-  (else, the values returned by ``random`` are always the same for each
-  run of the program).  ``initstate`` and ``setstate`` allow fine-grained
-  control over the state of the random number generator.
-
-.. concat.c:160
-
-.. function:: char* reconcat (char *optr, const char *s1, ..., NULL)
-
-  Same as ``concat``, except that if :samp:`{optr}` is not ``NULL`` it
-  is freed after the string is created.  This is intended to be useful
-  when you're extending an existing string or building up a string in a
-  loop:
-
-  .. code-block:: c++
-
-      str = reconcat (str, "pre-", str, NULL);
-
-.. rename.c:6
-
-.. function:: int rename (const char *old, const char *new)
-
-  Renames a file from :samp:`{old}` to :samp:`{new}`.  If :samp:`{new}` already
-  exists, it is removed.
-
-.. rindex.c:5
-
-.. function:: char* rindex (const char *s, int c)
-
-  Returns a pointer to the last occurrence of the character :samp:`{c}` in
-  the string :samp:`{s}`, or ``NULL`` if not found.  The use of ``rindex`` is
-  deprecated in new programs in favor of ``strrchr``.
-
-.. setenv.c:22
-
-.. function:: int setenv (const char *name, const char *value, int overwrite)
-              void unsetenv (const char *name)
-
-  ``setenv`` adds :samp:`{name}` to the environment with value
-  :samp:`{value}`.  If the name was already present in the environment,
-  the new value will be stored only if :samp:`{overwrite}` is nonzero.
-  The companion ``unsetenv`` function removes :samp:`{name}` from the
-  environment.  This implementation is not safe for multithreaded code.
-
-.. setproctitle.c:31
-
-.. function:: void setproctitle (const char *fmt, ...)
-
-  Set the title of a process to :samp:`{fmt}`. va args not supported for now,
-  but defined for compatibility with BSD.
-
-.. strsignal.c:348
-
-.. function:: int signo_max (void)
-
-  Returns the maximum signal value for which a corresponding symbolic
-  name or message is available.  Note that in the case where we use the
-  ``sys_siglist`` supplied by the system, it is possible for there to
-  be more symbolic names than messages, or vice versa.  In fact, the
-  manual page for ``psignal(3b)`` explicitly warns that one should
-  check the size of the table (``NSIG``) before indexing it, since
-  new signal codes may be added to the system before they are added to
-  the table.  Thus ``NSIG`` might be smaller than value implied by
-  the largest signo value defined in ``<signal.h>``.
-
-  We return the maximum value that can be used to obtain a meaningful
-  symbolic name or message.
-
-.. sigsetmask.c:8
-
-.. function:: int sigsetmask (int set)
-
-  Sets the signal mask to the one provided in :samp:`{set}` and returns
-  the old mask (which, for libiberty's implementation, will always
-  be the value ``1``).
-
-.. simple-object.txh:96
-
-.. function:: const char * simple_object_attributes_compare   (simple_object_attributes *attrs1, simple_object_attributes *attrs2, int *err)
-
-  Compare :samp:`{attrs1}` and :samp:`{attrs2}`.  If they could be linked
-  together without error, return ``NULL``.  Otherwise, return an
-  error message and set ``*err`` to an errno value or ``0``
-  if there is no relevant errno.
-
-.. simple-object.txh:81
-
-.. function:: simple_object_attributes * simple_object_fetch_attributes   (simple_object_read *simple_object, const char **errmsg, int *err)
-
-  Fetch the attributes of :samp:`{simple_object}`.  The attributes are
-  internal information such as the format of the object file, or the
-  architecture it was compiled for.  This information will persist until
-  ``simple_object_attributes_release`` is called, even if
-  :samp:`{simple_object}` itself is released.
-
-  On error this returns ``NULL``, sets ``*errmsg`` to an
-  error message, and sets ``*err`` to an errno value or
-  ``0`` if there is no relevant errno.
-
-.. simple-object.txh:49
-
-.. function:: int simple_object_find_section (simple_object_read *simple_object, off_t *offset, off_t *length, const char **errmsg, int *err)
-
-  Look for the section :samp:`{name}` in :samp:`{simple_object}`.  This returns
-  information for the first section with that name.
-
-  If found, return 1 and set ``*offset`` to the offset in the
-  file of the section contents and set ``*length`` to the
-  length of the section contents.  The value in ``*offset``
-  will be relative to the offset passed to
-  ``simple_object_open_read``.
-
-  If the section is not found, and no error occurs,
-  ``simple_object_find_section`` returns ``0`` and set
-  ``*errmsg`` to ``NULL``.
-
-  If an error occurs, ``simple_object_find_section`` returns
-  ``0``, sets ``*errmsg`` to an error message, and sets
-  ``*err`` to an errno value or ``0`` if there is no
-  relevant errno.
-
-.. simple-object.txh:27
-
-.. function:: const char * simple_object_find_sections   (simple_object_read *simple_object, int (*pfn) (void *data, const char *name, off_t offset, off_t length), void *data, int *err)
-
-  This function calls :samp:`{pfn}` for each section in :samp:`{simple_object}`.
-  It calls :samp:`{pfn}` with the section name, the offset within the file
-  of the section contents, and the length of the section contents.  The
-  offset within the file is relative to the offset passed to
-  ``simple_object_open_read``.  The :samp:`{data}` argument to this
-  function is passed along to :samp:`{pfn}`.
-
-  If :samp:`{pfn}` returns ``0``, the loop over the sections stops and
-  ``simple_object_find_sections`` returns.  If :samp:`{pfn}` returns some
-  other value, the loop continues.
-
-  On success ``simple_object_find_sections`` returns.  On error it
-  returns an error string, and sets ``*err`` to an errno value
-  or ``0`` if there is no relevant errno.
-
-.. simple-object.txh:2
-
-.. function:: simple_object_read * simple_object_open_read   (int descriptor, off_t offset, const char *segment_name, const char **errmsg, int *err)
-
-  Opens an object file for reading.  Creates and returns an
-  ``simple_object_read`` pointer which may be passed to other
-  functions to extract data from the object file.
-
-  :samp:`{descriptor}` holds a file descriptor which permits reading.
-
-  :samp:`{offset}` is the offset into the file; this will be ``0`` in the
-  normal case, but may be a different value when reading an object file
-  in an archive file.
-
-  :samp:`{segment_name}` is only used with the Mach-O file format used on
-  Darwin aka Mac OS X.  It is required on that platform, and means to
-  only look at sections within the segment with that name.  The
-  parameter is ignored on other systems.
-
-  If an error occurs, this functions 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.txh:107
-
-.. function:: void simple_object_release_attributes   (simple_object_attributes *attrs)
-
-  Release all resources associated with :samp:`{attrs}`.
-
-.. simple-object.txh:73
-
-.. function:: void simple_object_release_read   (simple_object_read *simple_object)
-
-  Release all resources associated with :samp:`{simple_object}`.  This does
-  not close the file descriptor.
-
-.. simple-object.txh:184
-
-.. function:: void simple_object_release_write   (simple_object_write *simple_object)
-
-  Release all resources associated with :samp:`{simple_object}`.
-
-.. simple-object.txh:114
-
-.. function:: simple_object_write * simple_object_start_write   (simple_object_attributes attrs, const char *segment_name, const char **errmsg, int *err)
-
-  Start creating a new object file using the object file format
-  described in :samp:`{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.
-
-  :samp:`{segment_name}` is only used with Mach-O as found on Darwin aka Mac
-  OS X.  The parameter is required on that target.  It means that all
-  sections are created within the named segment.  It is ignored for
-  other object file formats.
-
-  On error ``simple_object_start_write`` returns ``NULL``, sets
-  ``*ERRMSG`` to an error message, and sets ``*err``
-  to an errno value or ``0`` if there is no relevant errno.
-
-.. simple-object.txh:153
-
-.. function:: const char * simple_object_write_add_data   (simple_object_write *simple_object, simple_object_write_section *section, const void *buffer, size_t size, int copy, int *err)
-
-  Add data :samp:`{buffer}` / :samp:`{size}` to :samp:`{section}` in
-  :samp:`{simple_object}`.  If :samp:`{copy}` is non-zero, the data will be
-  copied into memory if necessary.  If :samp:`{copy}` is zero, :samp:`{buffer}`
-  must persist until ``simple_object_write_to_file`` is called.  is
-  released.
-
-  On success this returns ``NULL``.  On error this returns an error
-  message, and sets ``*err`` to an errno value or 0 if there is
-  no relevant erro.
-
-.. simple-object.txh:134
-
-.. function:: simple_object_write_section * simple_object_write_create_section   (simple_object_write *simple_object, const char *name, unsigned int align, const char **errmsg, int *err)
-
-  Add a section to :samp:`{simple_object}`.  :samp:`{name}` is the name of the
-  new section.  :samp:`{align}` is the required alignment expressed as the
-  number of required low-order 0 bits (e.g., 2 for alignment to a 32-bit
-  boundary).
-
-  The section is created as containing data, readable, not writable, not
-  executable, not loaded at runtime.  The section is not written to the
-  file until ``simple_object_write_to_file`` is called.
-
-  On error this returns ``NULL``, sets ``*errmsg`` to an
-  error message, and sets ``*err`` to an errno value or
-  ``0`` if there is no relevant errno.
-
-.. simple-object.txh:170
-
-.. function:: const char * simple_object_write_to_file   (simple_object_write *simple_object, int descriptor, int *err)
-
-  Write the complete object file to :samp:`{descriptor}`, an open file
-  descriptor.  This writes out all the data accumulated by calls to
-  ``simple_object_write_create_section`` and
-  :samp:`{simple_object_write_add_data}`.
-
-  This returns ``NULL`` on success.  On error this returns an error
-  message and sets ``*err`` to an errno value or ``0`` if
-  there is no relevant errno.
-
-.. snprintf.c:28
-
-.. function:: int snprintf (char *buf, size_t n, const char *format, ...)
-
-  This function is similar to ``sprintf``, but it will write to
-  :samp:`{buf}` at most ``n-1`` bytes of text, followed by a
-  terminating null byte, for a total of :samp:`{n}` bytes.
-  On error the return value is -1, otherwise it returns the number of
-  bytes, not including the terminating null byte, that would have been
-  written had :samp:`{n}` been sufficiently large, regardless of the actual
-  value of :samp:`{n}`.  Note some pre-C99 system libraries do not implement
-  this correctly so users cannot generally rely on the return value if
-  the system version of this function is used.
-
-.. spaces.c:22
-
-.. function:: char* spaces (int count)
-
-  Returns a pointer to a memory region filled with the specified
-  number of spaces and null terminated.  The returned pointer is
-  valid until at least the next call.
-
-.. splay-tree.c:305
-
-.. function:: splay_tree splay_tree_new_with_typed_alloc (splay_tree_compare_fn compare_fn, splay_tree_delete_key_fn delete_key_fn, splay_tree_delete_value_fn delete_value_fn, splay_tree_allocate_fn tree_allocate_fn, splay_tree_allocate_fn node_allocate_fn, splay_tree_deallocate_fn deallocate_fn, void * allocate_data)
-
-  This function creates a splay tree that uses two different allocators
-  :samp:`{tree_allocate_fn}` and :samp:`{node_allocate_fn}` to use for allocating the
-  tree itself and its nodes respectively.  This is useful when variables of
-  different types need to be allocated with different allocators.
-
-  The splay tree will use :samp:`{compare_fn}` to compare nodes,
-  :samp:`{delete_key_fn}` to deallocate keys, and :samp:`{delete_value_fn}` to
-  deallocate values.  Keys and values will be deallocated when the
-  tree is deleted using splay_tree_delete or when a node is removed
-  using splay_tree_remove.  splay_tree_insert will release the previously
-  inserted key and value using :samp:`{delete_key_fn}` and :samp:`{delete_value_fn}`
-  if the inserted key is already found in the tree.
-
-.. stack-limit.c:28
-
-.. function:: void stack_limit_increase (unsigned long pref)
-
-  Attempt to increase stack size limit to :samp:`{pref}` bytes if possible.
-
-.. stpcpy.c:23
-
-.. function:: char* stpcpy (char *dst, const char *src)
-
-  Copies the string :samp:`{src}` into :samp:`{dst}`.  Returns a pointer to
-  :samp:`{dst}` + strlen(:samp:`{src}`).
-
-.. stpncpy.c:23
-
-.. function:: char* stpncpy (char *dst, const char *src, size_t len)
-
-  Copies the string :samp:`{src}` into :samp:`{dst}`, copying exactly :samp:`{len}`
-  and padding with zeros if necessary.  If :samp:`{len}` < strlen(:samp:`{src}`)
-  then return :samp:`{dst}` + :samp:`{len}`, otherwise returns :samp:`{dst}` +
-  strlen(:samp:`{src}`).
-
-.. strcasecmp.c:15
-
-.. function:: int strcasecmp (const char *s1, const char *s2)
-
-  A case-insensitive ``strcmp``.
-
-.. strchr.c:6
-
-.. function:: char* strchr (const char *s, int c)
-
-  Returns a pointer to the first occurrence of the character :samp:`{c}` in
-  the string :samp:`{s}`, or ``NULL`` if not found.  If :samp:`{c}` is itself the
-  null character, the results are undefined.
-
-.. strdup.c:3
-
-.. function:: char* strdup (const char *s)
-
-  Returns a pointer to a copy of :samp:`{s}` in memory obtained from
-  ``malloc``, or ``NULL`` if insufficient memory was available.
-
-.. strerror.c:675
-
-.. function:: const char* strerrno (int errnum)
-
-  Given an error number returned from a system call (typically returned
-  in ``errno``), returns a pointer to a string containing the
-  symbolic name of that error number, as found in ``<errno.h>``.
-
-  If the supplied error number is within the valid range of indices for
-  symbolic names, but no name is available for the particular error
-  number, then returns the string :samp:`Error {num}`, where :samp:`{num}`
-  is the error number.
-
-  If the supplied error number is not within the range of valid
-  indices, then returns ``NULL``.
-
-  The contents of the location pointed to are only guaranteed to be
-  valid until the next call to ``strerrno``.
-
-.. strerror.c:608
-
-.. function:: char* strerror (int errnoval)
-
-  Maps an ``errno`` number to an error message string, the contents
-  of which are implementation defined.  On systems which have the
-  external variables ``sys_nerr`` and ``sys_errlist``, these
-  strings will be the same as the ones used by ``perror``.
-
-  If the supplied error number is within the valid range of indices for
-  the ``sys_errlist``, but no message is available for the particular
-  error number, then returns the string :samp:`Error {num}`, where
-  :samp:`{num}` is the error number.
-
-  If the supplied error number is not a valid index into
-  ``sys_errlist``, returns ``NULL``.
-
-  The returned string is only guaranteed to be valid only until the
-  next call to ``strerror``.
-
-.. strncasecmp.c:15
-
-.. function:: int strncasecmp (const char *s1, const char *s2)
-
-  A case-insensitive ``strncmp``.
-
-.. strncmp.c:6
-
-.. function:: int strncmp (const char *s1, const char *s2, size_t n)
-
-  Compares the first :samp:`{n}` bytes of two strings, returning a value as
-  ``strcmp``.
-
-.. strndup.c:23
-
-.. function:: char* strndup (const char *s, size_t n)
-
-  Returns a pointer to a copy of :samp:`{s}` with at most :samp:`{n}` characters
-  in memory obtained from ``malloc``, or ``NULL`` if insufficient
-  memory was available.  The result is always NUL terminated.
-
-.. strnlen.c:6
-
-.. function:: size_t strnlen (const char *s, size_t maxlen)
-
-  Returns the length of :samp:`{s}`, as with ``strlen``, but never looks
-  past the first :samp:`{maxlen}` characters in the string.  If there is no
-  '\0' character in the first :samp:`{maxlen}` characters, returns
-  :samp:`{maxlen}`.
-
-.. strrchr.c:6
-
-.. function:: char* strrchr (const char *s, int c)
-
-  Returns a pointer to the last occurrence of the character :samp:`{c}` in
-  the string :samp:`{s}`, or ``NULL`` if not found.  If :samp:`{c}` is itself the
-  null character, the results are undefined.
-
-.. strsignal.c:383
-
-.. function:: const char * strsignal (int signo)
-
-  Maps an signal number to an signal message string, the contents of
-  which are implementation defined.  On systems which have the external
-  variable ``sys_siglist``, these strings will be the same as the
-  ones used by ``psignal()``.
-
-  If the supplied signal number is within the valid range of indices for
-  the ``sys_siglist``, but no message is available for the particular
-  signal number, then returns the string :samp:`Signal {num}`, where
-  :samp:`{num}` is the signal number.
-
-  If the supplied signal number is not a valid index into
-  ``sys_siglist``, returns ``NULL``.
-
-  The returned string is only guaranteed to be valid only until the next
-  call to ``strsignal``.
-
-.. strsignal.c:448
-
-.. function:: const char* strsigno (int signo)
-
-  Given an signal number, returns a pointer to a string containing the
-  symbolic name of that signal number, as found in ``<signal.h>``.
-
-  If the supplied signal number is within the valid range of indices for
-  symbolic names, but no name is available for the particular signal
-  number, then returns the string :samp:`Signal {num}`, where
-  :samp:`{num}` is the signal number.
-
-  If the supplied signal number is not within the range of valid
-  indices, then returns ``NULL``.
-
-  The contents of the location pointed to are only guaranteed to be
-  valid until the next call to ``strsigno``.
-
-.. strstr.c:6
-
-.. function:: char* strstr (const char *string, const char *sub)
-
-  This function searches for the substring :samp:`{sub}` in the string
-  :samp:`{string}`, not including the terminating null characters.  A pointer
-  to the first occurrence of :samp:`{sub}` is returned, or ``NULL`` if the
-  substring is absent.  If :samp:`{sub}` points to a string with zero
-  length, the function returns :samp:`{string}`.
-
-.. strtod.c:27
-
-.. function:: double strtod (const char *string, char **endptr)
-
-  This ISO C function converts the initial portion of :samp:`{string}` to a
-  ``double``.  If :samp:`{endptr}` is not ``NULL``, a pointer to the
-  character after the last character used in the conversion is stored in
-  the location referenced by :samp:`{endptr}`.  If no conversion is
-  performed, zero is returned and the value of :samp:`{string}` is stored in
-  the location referenced by :samp:`{endptr}`.
-
-.. strerror.c:734
-
-.. function:: int strtoerrno (const char *name)
-
-  Given the symbolic name of a error number (e.g., ``EACCES``), map it
-  to an errno value.  If no translation is found, returns 0.
-
-.. strtol.c:33
-
-.. function:: long int strtol (const char *string, char **endptr, int base)
-              unsigned long int strtoul (const char *string, char **endptr, int base)
-
-  The ``strtol`` function converts the string in :samp:`{string}` to a
-  long integer value according to the given :samp:`{base}`, which must be
-  between 2 and 36 inclusive, or be the special value 0.  If :samp:`{base}`
-  is 0, ``strtol`` will look for the prefixes ``0`` and ``0x``
-  to indicate bases 8 and 16, respectively, else default to base 10.
-  When the base is 16 (either explicitly or implicitly), a prefix of
-  ``0x`` is allowed.  The handling of :samp:`{endptr}` is as that of
-  ``strtod`` above.  The ``strtoul`` function is the same, except
-  that the converted value is unsigned.
-
-.. strtoll.c:33
-
-.. function:: long long int strtoll (const char *string, char **endptr, int base)
-              unsigned long long int strtoull (const char *string, char **endptr, int base)
-
-  The ``strtoll`` function converts the string in :samp:`{string}` to a
-  long long integer value according to the given :samp:`{base}`, which must be
-  between 2 and 36 inclusive, or be the special value 0.  If :samp:`{base}`
-  is 0, ``strtoll`` will look for the prefixes ``0`` and ``0x``
-  to indicate bases 8 and 16, respectively, else default to base 10.
-  When the base is 16 (either explicitly or implicitly), a prefix of
-  ``0x`` is allowed.  The handling of :samp:`{endptr}` is as that of
-  ``strtod`` above.  The ``strtoull`` function is the same, except
-  that the converted value is unsigned.
-
-.. strsignal.c:502
-
-.. function:: int strtosigno (const char *name)
-
-  Given the symbolic name of a signal, map it to a signal number.  If no
-  translation is found, returns 0.
-
-.. strverscmp.c:25
-
-.. function:: int strverscmp (const char *s1, const char *s2)
-
-  The ``strverscmp`` function compares the string :samp:`{s1}` against
-  :samp:`{s2}`, considering them as holding indices/version numbers.  Return
-  value follows the same conventions as found in the ``strverscmp``
-  function.  In fact, if :samp:`{s1}` and :samp:`{s2}` contain no digits,
-  ``strverscmp`` behaves like ``strcmp``.
-
-  Basically, we compare strings normally (character by character), until
-  we find a digit in each string - then we enter a special comparison
-  mode, where each sequence of digits is taken as a whole.  If we reach the
-  end of these two parts without noticing a difference, we return to the
-  standard comparison mode.  There are two types of numeric parts:
-  "integral" and "fractional" (those  begin with a '0'). The types
-  of the numeric parts affect the way we sort them:
-
-  * integral/integral: we compare values as you would expect.
-
-  * fractional/integral: the fractional part is less than the integral one.
-    Again, no surprise.
-
-  * fractional/fractional: the things become a bit more complex.
-    If the common prefix contains only leading zeroes, the longest part is less
-    than the other one; else the comparison behaves normally.
-
-  .. code-block::
-
-    strverscmp ("no digit", "no digit")
-        ⇒ 0    // same behavior as strcmp.
-    strverscmp ("item#99", "item#100")
-        ⇒ <0   // same prefix, but 99 < 100.
-    strverscmp ("alpha1", "alpha001")
-        ⇒ >0   // fractional part inferior to integral one.
-    strverscmp ("part1_f012", "part1_f01")
-        ⇒ >0   // two fractional parts.
-    strverscmp ("foo.009", "foo.0")
-        ⇒ <0   // idem, but with leading zeroes only.
-
-  This function is especially useful when dealing with filename sorting,
-  because filenames frequently hold indices/version numbers.
-
-.. timeval-utils.c:43
-
-.. function:: void timeval_add (struct timeval *a, struct timeval *b, struct timeval *result)
-
-  Adds :samp:`{a}` to :samp:`{b}` and stores the result in :samp:`{result}`.
-
-.. timeval-utils.c:67
-
-.. function:: void timeval_sub (struct timeval *a, struct timeval *b, struct timeval *result)
-
-  Subtracts :samp:`{b}` from :samp:`{a}` and stores the result in :samp:`{result}`.
-
-.. tmpnam.c:3
-
-.. function:: char* tmpnam (char *s)
-
-  This function attempts to create a name for a temporary file, which
-  will be a valid file name yet not exist when ``tmpnam`` checks for
-  it.  :samp:`{s}` must point to a buffer of at least ``L_tmpnam`` bytes,
-  or be ``NULL``.  Use of this function creates a security risk, and it must
-  not be used in new projects.  Use ``mkstemp`` instead.
-
-.. unlink-if-ordinary.c:27
-
-.. function:: int unlink_if_ordinary (const char*)
-
-  Unlinks the named file, unless it is special (e.g. a device file).
-  Returns 0 when the file was unlinked, a negative value (and errno set) when
-  there was an error deleting the file, and a positive value if no attempt
-  was made to unlink the file because it is special.
-
-.. fopen_unlocked.c:31
-
-.. function:: void unlock_std_streams (void)
-
-  If the OS supports it, ensure that the standard I/O streams,
-  ``stdin``, ``stdout`` and ``stderr`` are setup to avoid any
-  multi-threaded locking.  Otherwise do nothing.
-
-.. fopen_unlocked.c:23
-
-.. function:: void unlock_stream (FILE * stream)
-
-  If the OS supports it, ensure that the supplied stream is setup to
-  avoid any multi-threaded locking.  Otherwise leave the ``FILE``
-  pointer unchanged.  If the :samp:`{stream}` is ``NULL`` do nothing.
-
-.. vasprintf.c:47
-
-.. function:: int vasprintf (char **resptr, const char *format, va_list args)
-
-  Like ``vsprintf``, but instead of passing a pointer to a buffer,
-  you pass a pointer to a pointer.  This function will compute the size
-  of the buffer needed, allocate memory with ``malloc``, and store a
-  pointer to the allocated memory in ``*resptr``.  The value
-  returned is the same as ``vsprintf`` would return.  If memory could
-  not be allocated, minus one is returned and ``NULL`` is stored in
-  ``*resptr``.
-
-.. vfork.c:6
-
-.. function:: int vfork (void)
-
-  Emulates ``vfork`` by calling ``fork`` and returning its value.
-
-.. vprintf.c:3
-
-.. function:: int vprintf (const char *format, va_list ap)
-              int vfprintf (FILE *stream, const char *format, va_list ap)
-              int vsprintf (char *str, const char *format, va_list ap)
-
-  These functions are the same as ``printf``, ``fprintf``, and
-  ``sprintf``, respectively, except that they are called with a
-  ``va_list`` instead of a variable number of arguments.  Note that
-  they do not call ``va_end`` ; this is the application's
-  responsibility.  In ``libiberty`` they are implemented in terms of the
-  nonstandard but common function ``_doprnt``.
-
-.. vsnprintf.c:28
-
-.. function:: int vsnprintf (char *buf, size_t n, const char *format, va_list ap)
-
-  This function is similar to ``vsprintf``, but it will write to
-  :samp:`{buf}` at most ``n-1`` bytes of text, followed by a
-  terminating null byte, for a total of :samp:`{n}` bytes.  On error the
-  return value is -1, otherwise it returns the number of characters that
-  would have been printed had :samp:`{n}` been sufficiently large,
-  regardless of the actual value of :samp:`{n}`.  Note some pre-C99 system
-  libraries do not implement this correctly so users cannot generally
-  rely on the return value if the system version of this function is
-  used.
-
-.. waitpid.c:3
-
-.. function:: int waitpid (int pid, int *status, int)
-
-  This is a wrapper around the ``wait`` function.  Any 'special'
-  values of :samp:`{pid}` depend on your implementation of ``wait``, as
-  does the return value.  The third argument is unused in ``libiberty``.
-
-.. argv.c:289
-
-.. function:: int writeargv (char * const *argv, FILE *file)
-
-  Write each member of ARGV, handling all necessary quoting, to the file
-  named by FILE, separated by whitespace.  Return 0 on success, non-zero
-  if an error occurred while writing to FILE.
-
-.. xasprintf.c:31
-
-.. function:: char* xasprintf (const char *format, ...)
-
-  Print to allocated string without fail.  If ``xasprintf`` fails,
-  this will print a message to ``stderr`` (using the name set by
-  ``xmalloc_set_program_name``, if any) and then call ``xexit``.
-
-.. xatexit.c:11
-
-.. function:: int xatexit (void (*fn) (void))
-
-  Behaves as the standard ``atexit`` function, but with no limit on
-  the number of registered functions.  Returns 0 on success, or -1 on
-  failure.  If you use ``xatexit`` to register functions, you must use
-  ``xexit`` to terminate your program.
-
-.. xmalloc.c:38
-
-.. function:: void* xcalloc (size_t nelem, size_t elsize)
-
-  Allocate memory without fail, and set it to zero.  This routine functions
-  like ``calloc``, but will behave the same as ``xmalloc`` if memory
-  cannot be found.
-
-.. xexit.c:22
-
-.. function:: void xexit (int code)
-
-  Terminates the program.  If any functions have been registered with
-  the ``xatexit`` replacement function, they will be called first.
-  Termination is handled via the system's normal ``exit`` call.
-
-.. xmalloc.c:22
-
-.. function:: void* xmalloc (size_t)
-
-  Allocate memory without fail.  If ``malloc`` fails, this will print
-  a message to ``stderr`` (using the name set by
-  ``xmalloc_set_program_name``,
-  if any) and then call ``xexit``.  Note that it is therefore safe for
-  a program to contain ``#define malloc xmalloc`` in its source.
-
-.. xmalloc.c:53
-
-.. function:: void xmalloc_failed (size_t)
-
-  This function is not meant to be called by client code, and is listed
-  here for completeness only.  If any of the allocation routines fail, this
-  function will be called to print an error message and terminate execution.
-
-.. xmalloc.c:46
-
-.. function:: void xmalloc_set_program_name (const char *name)
-
-  You can use this to set the name of the program used by
-  ``xmalloc_failed`` when printing a failure message.
-
-.. xmemdup.c:7
-
-.. function:: void* xmemdup (void *input, size_t copy_size, size_t alloc_size)
-
-  Duplicates a region of memory without fail.  First, :samp:`{alloc_size}` bytes
-  are allocated, then :samp:`{copy_size}` bytes from :samp:`{input}` are copied into
-  it, and the new memory is returned.  If fewer bytes are copied than were
-  allocated, the remaining memory is zeroed.
-
-.. xmalloc.c:32
-
-.. function:: void* xrealloc (void *ptr, size_t size)
-
-  Reallocate memory without fail.  This routine functions like ``realloc``,
-  but will behave the same as ``xmalloc`` if memory cannot be found.
-
-.. xstrdup.c:7
-
-.. function:: char* xstrdup (const char *s)
-
-  Duplicates a character string without fail, using ``xmalloc`` to
-  obtain memory.
-
-.. xstrerror.c:7
-
-.. function:: char* xstrerror (int errnum)
-
-  Behaves exactly like the standard ``strerror`` function, but
-  will never return a ``NULL`` pointer.
-
-.. xstrndup.c:23
-
-.. function:: char* xstrndup (const char *s, size_t n)
-
-  Returns a pointer to a copy of :samp:`{s}` with at most :samp:`{n}` characters
-  without fail, using ``xmalloc`` to obtain memory.  The result is
-  always NUL terminated.
-
-.. xvasprintf.c:38
-
-.. function:: char* xvasprintf (const char *format, va_list args)
-
-  Print to allocated string without fail.  If ``xvasprintf`` fails,
-  this will print a message to ``stderr`` (using the name set by
-  ``xmalloc_set_program_name``, if any) and then call ``xexit``.
\ No newline at end of file
diff --git a/libiberty/doc/index.rst b/libiberty/doc/index.rst
deleted file mode 100644
index 6770b9e..0000000
--- a/libiberty/doc/index.rst
+++ /dev/null
@@ -1,23 +0,0 @@
-..
-  Copyright 1988-2022 Free Software Foundation, Inc.
-  This is part of the GCC manual.
-  For copying conditions, see the copyright.rst file.
-
-GNU libiberty
-=============
-
-.. only:: html
-
-  Contents:
-
-.. toctree::
-
-  copyright
-  introduction
-  using
-  overview
-  function-variable-and-macro-listing
-  lesser-general-public-license-2.1
-  bsd
-
-  indices-and-tables
\ No newline at end of file
diff --git a/libiberty/doc/indices-and-tables.rst b/libiberty/doc/indices-and-tables.rst
deleted file mode 100644
index 9799e4e..0000000
--- a/libiberty/doc/indices-and-tables.rst
+++ /dev/null
@@ -1 +0,0 @@
-.. include:: ../../doc/indices-and-tables.rst
\ No newline at end of file
diff --git a/libiberty/doc/introduction.rst b/libiberty/doc/introduction.rst
deleted file mode 100644
index b26f643..0000000
--- a/libiberty/doc/introduction.rst
+++ /dev/null
@@ -1,8 +0,0 @@
-.. _top:
-
-Introduction
-============
-
-The ``libiberty`` library is a collection of subroutines used by various
-GNU programs.  It is available under the Library General Public
-License; for more information, see Library Copying.
\ No newline at end of file
diff --git a/libiberty/doc/lesser-general-public-license-2.1.rst b/libiberty/doc/lesser-general-public-license-2.1.rst
deleted file mode 100644
index a4c8739..0000000
--- a/libiberty/doc/lesser-general-public-license-2.1.rst
+++ /dev/null
@@ -1,6 +0,0 @@
-..
-  Copyright 1988-2022 Free Software Foundation, Inc.
-  This is part of the GCC manual.
-  For copying conditions, see the copyright.rst file.
-
-.. include:: ../../doc/lgpl-2.1.rst
\ No newline at end of file
diff --git a/libiberty/doc/overview.rst b/libiberty/doc/overview.rst
deleted file mode 100644
index e16601e..0000000
--- a/libiberty/doc/overview.rst
+++ /dev/null
@@ -1,20 +0,0 @@
-..
-  Copyright 1988-2022 Free Software Foundation, Inc.
-  This is part of the GCC manual.
-  For copying conditions, see the copyright.rst file.
-
-.. _overview:
-
-Overview
---------
-
-Functions contained in ``libiberty`` can be divided into three general categories.
-
-.. toctree::
-  :maxdepth: 2
-
-  supplemental-functions
-
-  replacement-functions
-
-  extensions
\ No newline at end of file
diff --git a/libiberty/doc/replacement-functions.rst b/libiberty/doc/replacement-functions.rst
deleted file mode 100644
index 4439674..0000000
--- a/libiberty/doc/replacement-functions.rst
+++ /dev/null
@@ -1,62 +0,0 @@
-..
-  Copyright 1988-2022 Free Software Foundation, Inc.
-  This is part of the GCC manual.
-  For copying conditions, see the copyright.rst file.
-
-.. index:: replacement functions, functions, replacement
-
-.. _replacement-functions:
-
-Replacement Functions
-*********************
-
-Some functions have extremely limited implementations on different
-platforms.  Other functions are tedious to use correctly; for example,
-proper use of ``malloc`` calls for the return value to be checked and
-appropriate action taken if memory has been exhausted.  A group of
-'replacement functions' is available in ``libiberty`` to address these issues
-for some of the most commonly used subroutines.
-
-All of these functions are declared in the :samp:`libiberty.h` header
-file.  Many of the implementations will use preprocessor macros set by
-GNU Autoconf, if you decide to make use of that program.  Some of these
-functions may call one another.
-
-.. toctree::
-  :maxdepth: 2
-
-
-.. index:: memory allocation
-
-.. _memory-allocation:
-
-Memory Allocation
-^^^^^^^^^^^^^^^^^
-
-The functions beginning with the letter :samp:`x` are wrappers around
-standard functions; the functions provided by the system environment
-are called and their results checked before the results are passed back
-to client code.  If the standard functions fail, these wrappers will
-terminate the program.  Thus, these versions can be used with impunity.
-
-.. index:: exit handlers
-
-.. _exit-handlers:
-
-Exit Handlers
-^^^^^^^^^^^^^
-
-The existence and implementation of the ``atexit`` routine varies
-amongst the flavors of Unix.  ``libiberty`` provides an unvarying dependable
-implementation via ``xatexit`` and ``xexit``.
-
-.. index:: error reporting
-
-.. _error-reporting:
-
-Error Reporting
-^^^^^^^^^^^^^^^
-
-These are a set of routines to facilitate programming with the system
-``errno`` interface.  The ``libiberty`` source file :samp:`strerror.c`
-contains a good deal of documentation for these functions.
\ No newline at end of file
diff --git a/libiberty/doc/supplemental-functions.rst b/libiberty/doc/supplemental-functions.rst
deleted file mode 100644
index d8387fc..0000000
--- a/libiberty/doc/supplemental-functions.rst
+++ /dev/null
@@ -1,31 +0,0 @@
-..
-  Copyright 1988-2022 Free Software Foundation, Inc.
-  This is part of the GCC manual.
-  For copying conditions, see the copyright.rst file.
-
-.. index:: supplemental functions, functions, supplemental, functions, missing
-
-.. _supplemental-functions:
-
-Supplemental Functions
-**********************
-
-Certain operating systems do not provide functions which have since
-become standardized, or at least common.  For example, the Single
-Unix Specification Version 2 requires that the ``basename``
-function be provided, but an OS which predates that specification
-might not have this function.  This should not prevent well-written
-code from running on such a system.
-
-Similarly, some functions exist only among a particular 'flavor'
-or 'family' of operating systems.  As an example, the ``bzero``
-function is often not present on systems outside the BSD-derived
-family of systems.
-
-Many such functions are provided in ``libiberty``.  They are quickly
-listed here with little description, as systems which lack them
-become less and less common.  Each function :samp:`{foo}` is implemented
-in :samp:`{foo}.c` but not declared in any ``libiberty`` header file; more
-comments and caveats for each function's implementation are often
-available in the source file.  Generally, the function can simply
-be declared as ``extern``.
\ No newline at end of file
diff --git a/libiberty/doc/using.rst b/libiberty/doc/using.rst
deleted file mode 100644
index 16974f3..0000000
--- a/libiberty/doc/using.rst
+++ /dev/null
@@ -1,40 +0,0 @@
-..
-  Copyright 1988-2022 Free Software Foundation, Inc.
-  This is part of the GCC manual.
-  For copying conditions, see the copyright.rst file.
-
-.. index:: using libiberty, libiberty usage, how to use
-
-.. _using:
-
-Using
------
-
-.. THIS SECTION IS CRAP AND NEEDS REWRITING BADLY.
-
-To date, ``libiberty`` is generally not installed on its own.  It has evolved
-over years but does not have its own version number nor release schedule.
-
-Possibly the easiest way to use ``libiberty`` in your projects is to drop the
-``libiberty`` code into your project's sources, and to build the library along
-with your own sources; the library would then be linked in at the end.  This
-prevents any possible version mismatches with other copies of libiberty
-elsewhere on the system.
-
-Passing :option:`--enable-install-libiberty` to the :command:`configure`
-script when building ``libiberty`` causes the header files and archive library
-to be installed when make install is run.  This option also takes
-an (optional) argument to specify the installation location, in the same
-manner as :option:`--prefix`.
-
-For your own projects, an approach which offers stability and flexibility
-is to include ``libiberty`` with your code, but allow the end user to optionally
-choose to use a previously-installed version instead.  In this way the
-user may choose (for example) to install ``libiberty`` as part of GCC, and use
-that version for all software built with that compiler.  (This approach
-has proven useful with software using the GNU ``readline`` library.)
-
-Making use of ``libiberty`` code usually requires that you include one or more
-header files from the ``libiberty`` distribution.  (They will be named as
-necessary in the function descriptions.)  At link time, you will need to
-add :option:`-liberty` to your link command invocation.
\ No newline at end of file