freebsd-dev/gnu/usr.bin/ld/rrs.c

/*
 * Copyright (c) 1993 Paul Kranenburg
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by Paul Kranenburg.
 * 4. The name of the author may not be used to endorse or promote products
 *    derived from this software withough specific prior written permission
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *	$Id: rrs.c,v 1.2 1993/11/09 04:19:02 paul Exp $
 */

#include <sys/param.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <fcntl.h>
#include <ar.h>
#include <ranlib.h>
#include <a.out.h>
#include <stab.h>
#include <string.h>
#include <strings.h>

#include "ld.h"

static struct link_dynamic	rrs_dyn;		/* defined in link.h */
static struct ld_debug		rrs_ld_debug;		/* defined in link.h */
static struct link_dynamic_2	rrs_dyn2;		/* defined in link.h */
static got_t			*rrs_got;
static jmpslot_t		*rrs_plt;		/* defined in md.h */
static struct relocation_info	*rrs_reloc;
static struct nzlist		*rrs_symbols;		/* RRS symbol table */
static char			*rrs_strtab;		/* RRS strings */
static struct rrs_hash		*rrs_hashtab;		/* RT hash table */
static struct shobj		*rrs_shobjs;

static int	reserved_rrs_relocs;
static int	claimed_rrs_relocs;

static int	number_of_gotslots;
static int	number_of_jmpslots;
static int	number_of_rrs_hash_entries;
static int	number_of_rrs_symbols;
static int	rrs_strtab_size;
static int	rrs_symbol_size;

static int	current_jmpslot_offset;
static int	current_got_offset;
static int	current_reloc_offset;
static int	current_hash_index;
static int	number_of_shobjs;

struct shobj {
	struct shobj		*next;
	struct file_entry	*entry;
};

/*
RRS text segment:
		+-------------------+  <-- ld_rel (rrs_text_start)
		|                   |
		|    relocation     |
		|                   |
		+-------------------+  <-- <link_dynamic_2>.ld_hash
		|                   |
		|    hash buckets   |
		|                   |
		+-------------------+  <-- <link_dynamic_2>.ld_stab
		|                   |
		|     symbols       |
		|                   |
		+-------------------+  <-- <link_dynamic_2>.ld_strings
		|                   |
		|     strings       |
		|                   |
		+-------------------+  <-- <link_dynamic_2>.ld_need
		|                   |
		|     shobjs        |
		|                   |
		+-------------------+
		|                   |
		|  shobjs strings   |  <-- <shobj>.lo_name
		|                   |
		+-------------------+


RRS data segment:

		+-------------------+  <-- __DYNAMIC (rrs_data_start)
		|                   |
		|   link_dymamic    |
		|                   |
		+-------------------+  <-- __DYNAMIC.ldd
		|                   |
		|   ld_debug        |
		|                   |
		+-------------------+  <-- __DYNAMIC.ld_un.ld_2
		|                   |
		|   link_dymamic_2  |
		|                   |
		+-------------------+  <-- _GLOBAL_OFFSET_TABLE_ (ld_got)
		|                   |
		|      _GOT_        |
		|                   |
		+-------------------+  <-- ld_plt
		|                   |
		|       PLT         |
		|                   |
		+-------------------+
*/

/*
 * Initialize RRS
 */

void
init_rrs()
{
	reserved_rrs_relocs = 0;
	claimed_rrs_relocs = 0;

	number_of_rrs_symbols = 0;
	rrs_strtab_size = 0;

	/* First jmpslot reserved for run-time binder */
	current_jmpslot_offset = sizeof(jmpslot_t);
	number_of_jmpslots = 1;

	/* First gotslot reserved for __DYNAMIC */
	current_got_offset = sizeof(got_t);
	number_of_gotslots = 1;

	current_reloc_offset = 0;
}

/*
 * Add NAME to the list of needed run-time objects.
 */
void
rrs_add_shobj(entry)
struct file_entry	*entry;
{
	struct shobj	**p;

	for (p = &rrs_shobjs; *p != NULL; p = &(*p)->next);
	*p = (struct shobj *)xmalloc(sizeof(struct shobj));
	(*p)->next = NULL;
	(*p)->entry = entry;

	number_of_shobjs++;
}

void
alloc_rrs_reloc(sp)
symbol *sp;
{
#ifdef DEBUG
printf("alloc_rrs_reloc: %s\n", sp->name);
#endif
	reserved_rrs_relocs++;
}

void
alloc_rrs_segment_reloc(r)
struct relocation_info	*r;
{
#ifdef DEBUG
printf("alloc_rrs_segment_reloc at %#x\n", r->r_address);
#endif
	reserved_rrs_relocs++;
}

void
alloc_rrs_jmpslot(sp)
symbol *sp;
{
	if (sp->jmpslot_offset == -1) {
		sp->jmpslot_offset = current_jmpslot_offset;
		current_jmpslot_offset += sizeof(jmpslot_t);
		number_of_jmpslots++;
		if (!(link_mode & SYMBOLIC) || JMPSLOT_NEEDS_RELOC) {
			reserved_rrs_relocs++;
		}
	}
}

void
alloc_rrs_gotslot(r, lsp)
struct relocation_info	*r;
struct localsymbol	*lsp;
{
	symbol	*sp = lsp->symbol;

	if (!RELOC_EXTERN_P(r)) {

		if (sp != NULL)
			fatal("internal error: lsp->symbol not NULL");

		if (!RELOC_STATICS_THROUGH_GOT_P(r))
			/* No need for a GOT slot */
			return;

		if (lsp->gotslot_offset == -1) {
			lsp->gotslot_offset = current_got_offset;
			current_got_offset += sizeof(got_t);
			number_of_gotslots++;
			/*
			 * Now, see if slot needs run-time fixing
			 * If the load address is known (entry_symbol), this
			 * slot will have its final value set by `claim_got'
			 */
			if ((link_mode & SHAREABLE) || (link_mode & SYMBOLIC))
				reserved_rrs_relocs++;
		}

	} else if (sp->gotslot_offset == -1) {

		if (sp->alias)
			sp = sp->alias;

		/*
		 * External symbols always get a relocation entry
		 */
		sp->gotslot_offset = current_got_offset;
		reserved_rrs_relocs++;
		current_got_offset += sizeof(got_t);
		number_of_gotslots++;
	}

}

void
alloc_rrs_cpy_reloc(sp)
symbol *sp;
{
	if (sp->cpyreloc_reserved)
		return;
#ifdef DEBUG
printf("alloc_rrs_copy: %s\n", sp->name);
#endif
	sp->cpyreloc_reserved = 1;
	reserved_rrs_relocs++;
}

static struct relocation_info *
rrs_next_reloc()
{
	struct relocation_info	*r;

	r = rrs_reloc + claimed_rrs_relocs++;
	if (claimed_rrs_relocs > reserved_rrs_relocs)
		fatal("internal error: RRS relocs exceed allocation %d",
			reserved_rrs_relocs);
	return r;
}

/*
 * Claim a RRS relocation as a result of a regular (ie. non-PIC)
 * relocation record in a rel file.
 *
 * Return 1 if the output file needs no further updating.
 * Return 0 if the relocation value pointed to by RELOCATION must
 * written to a.out.
 */
int
claim_rrs_reloc(rp, sp, relocation)
struct relocation_info	*rp;
symbol	*sp;
long	*relocation;
{
	struct relocation_info	*r = rrs_next_reloc();
#ifdef DEBUG
	if (rp->r_address < text_start + text_size)
		error("RRS text relocation at %#x (symbol %s)",
				rp->r_address, sp->name);
#endif
#ifdef DEBUG
printf("claim_rrs_reloc: %s\n", sp->name);
#endif
	r->r_address = rp->r_address;
	r->r_symbolnum = sp->rrs_symbolnum;

	if (link_mode & SYMBOLIC) {
		if (!sp->defined)
			error("Cannot reduce symbol %s", sp->name);
		RELOC_EXTERN_P(r) = 0;
		*relocation += sp->value;
		(void) md_make_reloc(rp, r, RELTYPE_RELATIVE);
		return 0;
	} else {
		RELOC_EXTERN_P(r) = 1;
		return md_make_reloc(rp, r, RELTYPE_EXTERN);
	}
}

/*
 * Claim a jmpslot. Setup RRS relocation if claimed for the first time.
 */
long
claim_rrs_jmpslot(rp, sp, addend)
struct relocation_info	*rp;
symbol			*sp;
long			addend;
{
	struct relocation_info *r;

	if (sp->jmpslot_claimed)
		return rrs_dyn2.ld_plt + sp->jmpslot_offset;

#ifdef DEBUG
printf("claim_rrs_jmpslot: %s(%d) -> offset %x (textreloc %#x)\n",
	sp->name, sp->rrs_symbolnum, sp->jmpslot_offset, text_relocation);
#endif

	if (sp->jmpslot_offset == -1)
		fatal(
		"internal error: claim_rrs_jmpslot: %s: jmpslot_offset == -1\n",
		sp->name);

	if ((link_mode & SYMBOLIC) || rrs_section_type == RRS_PARTIAL) {
		if (!sp->defined)
			error("Cannot reduce symbol %s", sp->name);

		md_fix_jmpslot( rrs_plt + sp->jmpslot_offset/sizeof(jmpslot_t),
				rrs_dyn2.ld_plt + sp->jmpslot_offset,
				sp->value);
		if (!JMPSLOT_NEEDS_RELOC) {
			return rrs_dyn2.ld_plt + sp->jmpslot_offset;
		}
	} else {
		md_make_jmpslot( rrs_plt + sp->jmpslot_offset/sizeof(jmpslot_t),
				sp->jmpslot_offset,
				claimed_rrs_relocs);
	}

	if (rrs_section_type == RRS_PARTIAL)
		/* PLT is self-contained */
		return rrs_dyn2.ld_plt + sp->jmpslot_offset;

	/*
	 * Install a run-time relocation for this PLT entry.
	 */
	r = rrs_next_reloc();
	sp->jmpslot_claimed = 1;

	RELOC_SYMBOL(r) = sp->rrs_symbolnum;

	r->r_address = (long)rrs_dyn2.ld_plt + sp->jmpslot_offset;

	if (link_mode & SYMBOLIC) {
		RELOC_EXTERN_P(r) = 0;
		md_make_jmpreloc(rp, r, RELTYPE_RELATIVE);
	} else {
		RELOC_EXTERN_P(r) = 1;
		md_make_jmpreloc(rp, r, 0);
	}

	return rrs_dyn2.ld_plt + sp->jmpslot_offset;
}

/*
 * Claim GOT entry for a global symbol. If this is the first relocation
 * claiming the entry, setup a RRS relocation for it.
 * Return offset into the GOT allocated to this symbol.
 */
long
claim_rrs_gotslot(rp, lsp, addend)
struct relocation_info	*rp;
struct localsymbol	*lsp;
long			addend;
{
	struct relocation_info	*r;
	symbol	*sp = lsp->symbol;
	int	reloc_type = 0;

	if (sp->alias)
		sp = sp->alias;

#ifdef DEBUG
printf("claim_rrs_gotslot: %s(%d) slot offset %#x, addend %#x\n",
	 sp->name, sp->rrs_symbolnum, sp->gotslot_offset, addend);
#endif
	if (sp->gotslot_offset == -1)
		fatal(
		"internal error: claim_rrs_gotslot: %s: gotslot_offset == -1\n",
		sp->name);

	if (sp->gotslot_claimed)
		/* This symbol already passed here before. */
		return sp->gotslot_offset;

	if (sp->defined &&
		(!(link_mode & SHAREABLE) || (link_mode & SYMBOLIC))) {

		/*
		 * Reduce to just a base-relative translation.
		 */

		*(got_t *)((long)rrs_got + sp->gotslot_offset) =
						sp->value + addend;
		reloc_type = RELTYPE_RELATIVE;

	} else if ((link_mode & SYMBOLIC) || rrs_section_type == RRS_PARTIAL) {
		/*
		 * SYMBOLIC: all symbols must be known.
		 * RRS_PARTIAL: we don't link against shared objects,
		 * so again all symbols must be known.
		 */
		error("Cannot reduce symbol %s", sp->name);

	} else {

		/*
		 * This gotslot will be updated with symbol value at run-rime.
		 */

		*(got_t *)((long)rrs_got + sp->gotslot_offset) = addend;
	}

	if (rrs_section_type == RRS_PARTIAL) {
		/*
		 * Base address is known, gotslot should be fully
		 * relocated by now.
		 * NOTE: RRS_PARTIAL implies !SHAREABLE.
		 */
		if (!sp->defined)
			error("Cannot reduce symbol %s", sp->name);
		return sp->gotslot_offset;
	}

	/*
	 * Claim a relocation entry.
	 * If symbol is defined and in "main" (!SHAREABLE)
	 * we still put out a relocation as we cannot easily
	 * undo the allocation.
	 * `RELTYPE_RELATIVE' relocations have the external bit off
	 * as no symbol need be looked up at run-time.
	 */
	r = rrs_next_reloc();
	sp->gotslot_claimed = 1;
	r->r_address = rrs_dyn2.ld_got + sp->gotslot_offset;
	RELOC_SYMBOL(r) = sp->rrs_symbolnum;
	RELOC_EXTERN_P(r) = !(reloc_type == RELTYPE_RELATIVE);
	md_make_gotreloc(rp, r, reloc_type);

	return sp->gotslot_offset;
}

/*
 * Claim a GOT entry for a static symbol. Return offset of the
 * allocated GOT entry. If RELOC_STATICS_THROUGH_GOT_P is in effect
 * return the offset of the symbol with respect to the *location* of
 * the GOT.
 */
long
claim_rrs_internal_gotslot(entry, rp, lsp, addend)
struct file_entry	*entry;
struct relocation_info	*rp;
struct localsymbol	*lsp;
long			addend;
{
	struct relocation_info	*r;

	addend += lsp->nzlist.nz_value;

	if (!RELOC_STATICS_THROUGH_GOT_P(r))
		return addend - rrs_dyn2.ld_got;

#ifdef DEBUG
printf("claim_rrsinternal__gotslot: slot offset %#x, addend = %#x\n",
	lsp->gotslot_offset, addend);
#endif

	if (lsp->gotslot_offset == -1)
		fatal(
		"internal error: claim_rrs_internal_gotslot: slot_offset == -1\n");

	if (lsp->gotslot_claimed)
		/* Already done */
		return lsp->gotslot_offset;

	*(long *)((long)rrs_got + lsp->gotslot_offset) = addend;

	if (!(link_mode & SHAREABLE))
		return lsp->gotslot_offset;

	/*
	 * Relocation entry needed for this static GOT entry.
	 */
	r = rrs_next_reloc();
	lsp->gotslot_claimed = 1;
	r->r_address = rrs_dyn2.ld_got + lsp->gotslot_offset;
	RELOC_EXTERN_P(r) = 0;
	md_make_gotreloc(rp, r, RELTYPE_RELATIVE);
	return lsp->gotslot_offset;
}

void
claim_rrs_cpy_reloc(rp, sp)
struct relocation_info	*rp;
symbol *sp;
{
	struct relocation_info	*r;

	if (sp->cpyreloc_claimed)
		return;

	if (!sp->cpyreloc_reserved)
		fatal("internal error: claim_cpy_reloc: %s: no reservation\n",
				sp->name);

#ifdef DEBUG
printf("claim_rrs_copy: %s -> %x\n", sp->name, sp->so_defined);
#endif

	r = rrs_next_reloc();
	sp->cpyreloc_claimed = 1;
	r->r_address = rp->r_address;
	RELOC_SYMBOL(r) = sp->rrs_symbolnum;
	RELOC_EXTERN_P(r) = RELOC_EXTERN_P(rp);
	md_make_cpyreloc(rp, r);
}

void
claim_rrs_segment_reloc(rp)
struct relocation_info	*rp;
{
	struct relocation_info	*r = rrs_next_reloc();

#ifdef DEBUG
printf("claim_rrs_segment_reloc: %x\n", rp->r_address);
#endif
	r->r_address = rp->r_address;
	RELOC_TYPE(r) = RELOC_TYPE(rp);
	RELOC_EXTERN_P(r) = 0;
	md_make_reloc(rp, r, RELTYPE_RELATIVE);

}

/*
 * Fill the RRS hash table for the given symbol name.
 * NOTE: the hash value computation must match the one in rtld.
 */
void
rrs_insert_hash(cp, index)
char	*cp;
int	index;
{
	int		hashval = 0;
	struct rrs_hash	*hp;

	for (; *cp; cp++)
		hashval = (hashval << 1) + *cp;

	hashval = (hashval & 0x7fffffff) % rrs_dyn2.ld_buckets;

	/* Get to the bucket */
	hp = rrs_hashtab + hashval;
	if (hp->rh_symbolnum == -1) {
		/* Empty bucket, use it */
		hp->rh_symbolnum = index;
		hp->rh_next = 0;
		return;
	}

	while (hp->rh_next != 0)
		hp = rrs_hashtab + hp->rh_next;

	hp->rh_next = current_hash_index++;
	hp = rrs_hashtab + hp->rh_next;
	hp->rh_symbolnum = index;
	hp->rh_next = 0;
}

/*
 * There are two interesting cases to consider here.
 *
 * 1) No shared objects were loaded, but there were PIC input rel files.
 *    In this case we must output a _GLOBAL_OFFSET_TABLE_ but no other
 *    RRS data. Also, the entries in the GOT must be fully resolved.
 *
 * 2) It's a genuine dynamically linked program, so the whole RRS scoop
 *    goes into a.out.
 */
void
consider_rrs_section_lengths()
{
	int		n;
	struct shobj	*shp;
	int		symbolsize;

	/* First, determine what of the RRS we want */

	if (relocatable_output)
		rrs_section_type = RRS_NONE;
	else if (link_mode & SHAREABLE)
		rrs_section_type = RRS_FULL;
	else if (number_of_shobjs == 0 /*&& !(link_mode & DYNAMIC)*/) {
		/*
		 * First slots in both tables are reserved
		 * hence the "> 1" condition
		 */
		if (number_of_gotslots > 1 || number_of_jmpslots > 1)
			rrs_section_type = RRS_PARTIAL;
		else
			rrs_section_type = RRS_NONE;
	} else
		rrs_section_type = RRS_FULL;

	if (rrs_section_type == RRS_NONE) {
		got_symbol->defined = 0;
		return;
	}

	rrs_symbol_size = LD_VERSION_NZLIST_P(soversion) ?
			sizeof(struct nzlist) : sizeof(struct nlist);

	/*
	 * If there is an entry point, __DYNAMIC must be referenced (usually
	 * from crt0), as this is the method used to determine whether the
	 * run-time linker must be called.
	 */
	if (!(link_mode & SHAREABLE) && !dynamic_symbol->referenced)
		fatal("No reference to __DYNAMIC");

	dynamic_symbol->referenced = 1;

	if (number_of_gotslots > 1)
		got_symbol->referenced = 1;


	/* Next, allocate relocs, got and plt */
	n = reserved_rrs_relocs * sizeof(struct relocation_info);
	rrs_reloc = (struct relocation_info *)xmalloc(n);
	bzero(rrs_reloc, n);

	n = number_of_gotslots * sizeof(got_t);
	rrs_got = (got_t *)xmalloc(n);
	bzero(rrs_got, n);

	n = number_of_jmpslots * sizeof(jmpslot_t);
	rrs_plt = (jmpslot_t *)xmalloc(n);
	bzero(rrs_plt, n);

	/* Initialize first jmpslot */
	md_fix_jmpslot(rrs_plt, 0, 0);

	if (rrs_section_type == RRS_PARTIAL) {
		rrs_data_size = number_of_gotslots * sizeof(got_t);
		rrs_data_size += number_of_jmpslots * sizeof(jmpslot_t);
		return;
	}

	/*
	 * Walk the symbol table, assign RRS symbol numbers
	 * Assign number 0 to __DYNAMIC (!! Sun compatibility)
	 */
	dynamic_symbol->rrs_symbolnum = number_of_rrs_symbols++;
	FOR_EACH_SYMBOL(i ,sp) {
		if (sp->referenced) {
			rrs_strtab_size += 1 + strlen(sp->name);
			if (sp != dynamic_symbol)
				sp->rrs_symbolnum = number_of_rrs_symbols++;
		}
	} END_EACH_SYMBOL;

	/*
	 * Now that we know how many RRS symbols there are going to be,
	 * allocate and initialize the RRS symbol hash table.
	 */
	rrs_dyn2.ld_buckets = number_of_rrs_symbols/4;
	if (rrs_dyn2.ld_buckets < 4)
		rrs_dyn2.ld_buckets = 4;

	number_of_rrs_hash_entries = rrs_dyn2.ld_buckets + number_of_rrs_symbols;
	rrs_hashtab = (struct rrs_hash *)xmalloc(
			number_of_rrs_hash_entries * sizeof(struct rrs_hash));
	for (n = 0; n < rrs_dyn2.ld_buckets; n++)
		rrs_hashtab[n].rh_symbolnum = -1;
	current_hash_index = rrs_dyn2.ld_buckets;

	/*
	 * Get symbols into hash table now, so we can fine tune the size
	 * of the latter. We adjust the value of `number_of_rrs_hash_entries'
	 * to the number of hash link slots actually used.
	 */
	FOR_EACH_SYMBOL(i ,sp) {
		if (sp->referenced)
			rrs_insert_hash(sp->name, sp->rrs_symbolnum);
	} END_EACH_SYMBOL;
	number_of_rrs_hash_entries = current_hash_index;

	/*
	 * Calculate RRS section sizes.
	 */
	rrs_data_size = sizeof(struct link_dynamic);
	rrs_data_size += sizeof(struct ld_debug);
	rrs_data_size += sizeof(struct link_dynamic_2);
	rrs_data_size += number_of_gotslots * sizeof(got_t);
	rrs_data_size += number_of_jmpslots * sizeof(jmpslot_t);
	rrs_data_size = MALIGN(rrs_data_size);

	rrs_text_size = reserved_rrs_relocs * sizeof(struct relocation_info);
	rrs_text_size += number_of_rrs_hash_entries * sizeof(struct rrs_hash);
	rrs_text_size += number_of_rrs_symbols * rrs_symbol_size;

	/* Align strings size */
	rrs_strtab_size = MALIGN(rrs_strtab_size);
	rrs_text_size += rrs_strtab_size;

	/* Process needed shared objects */
	for (shp = rrs_shobjs; shp; shp = shp->next) {
		char	*name = shp->entry->local_sym_name;

		if (*name == '-' && *(name+1) == 'l')
			name += 2;

		rrs_text_size += sizeof(struct link_object);
		rrs_text_size += 1 + strlen(name);
	}

	/* Finally, align size */
	rrs_text_size = MALIGN(rrs_text_size);
}

void
relocate_rrs_addresses()
{

	dynamic_symbol->value = 0;

	if (rrs_section_type == RRS_NONE)
		return;

	if (rrs_section_type == RRS_PARTIAL) {
		got_symbol->value = rrs_dyn2.ld_got = rrs_data_start;
		rrs_dyn2.ld_plt = rrs_dyn2.ld_got +
					number_of_gotslots * sizeof(got_t);
		return;
	}

	/*
	 * RRS data relocations.
	 */
	rrs_dyn.ld_version = soversion;
	rrs_dyn.ldd = (struct ld_debug *)
			(rrs_data_start + sizeof(struct link_dynamic));
	rrs_dyn.ld_un.ld_2 = (struct link_dynamic_2 *)
				((long)rrs_dyn.ldd + sizeof(struct ld_debug));

	rrs_dyn2.ld_got = (long)rrs_dyn.ld_un.ld_2 +
					sizeof(struct link_dynamic_2);
	rrs_dyn2.ld_plt = rrs_dyn2.ld_got + number_of_gotslots*sizeof(got_t);

	/*
	 * RRS text relocations.
	 */
	rrs_dyn2.ld_rel = rrs_text_start;
	/*
	 * Sun BUG compatibility alert.
	 * Main program's RRS text values are relative to TXTADDR? WHY??
	 */
#ifdef SUN_COMPAT
	if (soversion == LD_VERSION_SUN && !(link_mode & SHAREABLE))
		rrs_dyn2.ld_rel -= N_TXTADDR(outheader);
#endif

	rrs_dyn2.ld_hash = rrs_dyn2.ld_rel +
			reserved_rrs_relocs * sizeof(struct relocation_info);
	rrs_dyn2.ld_symbols = rrs_dyn2.ld_hash +
			number_of_rrs_hash_entries * sizeof(struct rrs_hash);
	rrs_dyn2.ld_strings = rrs_dyn2.ld_symbols +
			number_of_rrs_symbols * rrs_symbol_size;
	rrs_dyn2.ld_str_sz = rrs_strtab_size;
	rrs_dyn2.ld_text_sz = text_size;
	rrs_dyn2.ld_plt_sz = number_of_jmpslots * sizeof(jmpslot_t);

	rrs_dyn2.ld_need = rrs_shobjs ? rrs_dyn2.ld_strings+rrs_strtab_size : 0;
	rrs_dyn2.ld_stab_hash = 0;
	rrs_dyn2.ld_rules = 0;

	/*
	 * Assign addresses to _GLOBAL_OFFSET_TABLE_ and __DYNAMIC
	 * &__DYNAMIC is also in the first GOT entry.
	 */
	got_symbol->value = rrs_dyn2.ld_got;

	*rrs_got = dynamic_symbol->value = rrs_data_start;

}

void
write_rrs_data()
{
	long	pos;

	if (rrs_section_type == RRS_NONE)
		return;

	pos = rrs_data_start + (N_DATOFF(outheader) - DATA_START(outheader));
	if (lseek(outdesc, pos, L_SET) != pos)
		fatal("write_rrs_data: cant position in output file");

	if (rrs_section_type == RRS_PARTIAL) {
		/*
		 * Only a GOT and PLT are needed.
		 */
		if (number_of_gotslots <= 1)
			fatal("write_rrs_data: # gotslots <= 1");

		md_swapout_got(rrs_got, number_of_gotslots);
		mywrite(rrs_got, number_of_gotslots,
					sizeof(got_t), outdesc);

		if (number_of_jmpslots <= 1)
			fatal("write_rrs_data: # jmpslots <= 1");

		md_swapout_jmpslot(rrs_plt, number_of_jmpslots);
		mywrite(rrs_plt, number_of_jmpslots,
					sizeof(jmpslot_t), outdesc);
		return;
	}

	md_swapout_link_dynamic(&rrs_dyn);
	mywrite(&rrs_dyn, 1, sizeof(struct link_dynamic), outdesc);

	md_swapout_ld_debug(&rrs_ld_debug);
	mywrite(&rrs_ld_debug, 1, sizeof(struct ld_debug), outdesc);

	md_swapout_link_dynamic_2(&rrs_dyn2);
	mywrite(&rrs_dyn2, 1, sizeof(struct link_dynamic_2), outdesc);

	md_swapout_got(rrs_got, number_of_gotslots);
	mywrite(rrs_got, number_of_gotslots, sizeof(got_t), outdesc);

	md_swapout_jmpslot(rrs_plt, number_of_jmpslots);
	mywrite(rrs_plt, number_of_jmpslots, sizeof(jmpslot_t), outdesc);
}

void
write_rrs_text()
{
	long			pos;
	int			i;
	int			symsize;
	struct nzlist		*nlp;
	int			offset = 0;
	struct shobj		*shp;
	struct link_object	*lo;

	if (rrs_section_type == RRS_PARTIAL)
		return;

	pos = rrs_text_start + (N_TXTOFF(outheader) - TEXT_START(outheader));
	if (lseek(outdesc, pos, L_SET) != pos)
		fatal("write_rrs_text: cant position in output file");

	/* Write relocation records */
	md_swapout_reloc(rrs_reloc, reserved_rrs_relocs);
	mywrite(rrs_reloc, reserved_rrs_relocs,
				sizeof(struct relocation_info), outdesc);

	/* Write the RRS symbol hash tables */
	md_swapout_rrs_hash(rrs_hashtab, number_of_rrs_hash_entries);
	mywrite(rrs_hashtab, number_of_rrs_hash_entries, sizeof(struct rrs_hash), outdesc);

	/*
	 * Determine size of an RRS symbol entry, allocate space
	 * to collect them in.
	 */
	symsize = number_of_rrs_symbols * rrs_symbol_size;
	nlp = rrs_symbols = (struct nzlist *)alloca(symsize);
	rrs_strtab = (char *)alloca(rrs_strtab_size);

#define INCR_NLP(p)	((p) = (struct nzlist *)((long)(p) + rrs_symbol_size))

	/* __DYNAMIC symbol *must* be first for Sun compatibility */
	nlp->nz_desc = nlp->nz_other = 0;
	if (LD_VERSION_NZLIST_P(soversion))
		nlp->nz_size = 0;
	nlp->nz_type = dynamic_symbol->defined;
	nlp->nz_value = dynamic_symbol->value;
	nlp->nz_value = dynamic_symbol->value;
	nlp->nz_strx = offset;
	strcpy(rrs_strtab + offset, dynamic_symbol->name);
	offset += 1 + strlen(dynamic_symbol->name);
	INCR_NLP(nlp);

	/*
	 * Now, for each global symbol, construct a nzlist element
	 * for inclusion in the RRS symbol table.
	 */
	FOR_EACH_SYMBOL(i, sp) {

		if (!sp->referenced || sp == dynamic_symbol)
			continue;

		if ((long)nlp - (long)rrs_symbols >=
					number_of_rrs_symbols * rrs_symbol_size)
			fatal(
			    "internal error: rrs symbols exceed allocation %d ",
				number_of_rrs_symbols);

		nlp->nz_desc = 0;
		nlp->nz_other = 0;
		if (LD_VERSION_NZLIST_P(soversion))
			nlp->nz_size = 0;

		if (sp->defined > 1) {
			/* defined with known type */
			if (sp->defined == N_SIZE) {
				/*
				 * Make sure this symbol isn't going
				 * to define anything.
				 */
				nlp->nz_type = N_UNDF;
				nlp->nz_value = 0;
			} else {
				nlp->nz_type = sp->defined;
				nlp->nz_value = sp->value;
			}
			if (LD_VERSION_NZLIST_P(soversion))
				nlp->nz_size = sp->size;
		} else if (sp->max_common_size) {
			/*
			 * a common definition
			 */
			nlp->nz_type = N_UNDF | N_EXT;
			nlp->nz_value = sp->max_common_size;
		} else if (!sp->defined) {
			/* undefined */
			nlp->nz_type = N_UNDF | N_EXT;
			nlp->nz_value = 0;
		} else
			fatal(
			      "internal error: %s defined in mysterious way",
			      sp->name);

		nlp->nz_strx = offset;
		strcpy(rrs_strtab + offset, sp->name);
		offset += 1 + strlen(sp->name);

		INCR_NLP(nlp);

	} END_EACH_SYMBOL;

	if (MALIGN(offset) != rrs_strtab_size)
		fatal(
		"internal error: inconsistent RRS string table length: %d",
			offset);

	/* Write the symbol table */
	if (rrs_symbol_size == sizeof(struct nlist))
		md_swapout_symbols(rrs_symbols, number_of_rrs_symbols);
	else
		md_swapout_zsymbols(rrs_symbols, number_of_rrs_symbols);
	mywrite(rrs_symbols, symsize, 1, outdesc);

	/* Write the strings */
	mywrite(rrs_strtab, rrs_strtab_size, 1, outdesc);

	/*
	 * Write the names of the shared objects needed at run-time
	 */
	pos = rrs_dyn2.ld_need + number_of_shobjs * sizeof(struct link_object);
	lo = (struct link_object *)alloca(
				number_of_shobjs * sizeof(struct link_object));

	for (i = 0, shp = rrs_shobjs; shp; i++, shp = shp->next) {
		char	*name = shp->entry->local_sym_name;

		if (shp == NULL)
			fatal("internal error: shp == NULL");

		lo[i].lo_name = pos;
		lo[i].lo_major = shp->entry->lib_major;
		lo[i].lo_minor = shp->entry->lib_minor;

		if (*name == '-' && *(name+1) == 'l') {
			name += 2;
			lo[i].lo_library = 1;
		} else
			lo[i].lo_library = 0;

		pos += 1 + strlen(name);
		lo[i].lo_next = (i == number_of_shobjs - 1) ? 0 :
			(rrs_dyn2.ld_need + (i+1)*sizeof(struct link_object));

	}
	if (shp != NULL)
		fatal("internal error: shp != NULL");

	md_swapout_link_object(lo, number_of_shobjs);
	mywrite(lo, number_of_shobjs, sizeof(struct link_object), outdesc);

	for (i = 0, shp = rrs_shobjs; shp; i++, shp = shp->next) {
		char	*name = shp->entry->local_sym_name;

		if (*name == '-' && *(name+1) == 'l') {
			name += 2;
		}

		mywrite(name, strlen(name) + 1, 1, outdesc);
	}
}

void
write_rrs()
{

	/*
	 * First, do some consistency checks on the RRS segment.
	 */
	if (rrs_section_type == RRS_NONE) {
		if (reserved_rrs_relocs > 1)
			fatal(
			"internal error: RRS relocs in static program: %d",
				reserved_rrs_relocs-1);
		return;
	}

#ifdef DEBUG
printf("rrs_relocs %d, gotslots %d, jmpslots %d\n",
	reserved_rrs_relocs, number_of_gotslots-1, number_of_jmpslots-1);
#endif

	if (claimed_rrs_relocs != reserved_rrs_relocs) {
/*
		fatal("internal error: reserved relocs(%d) != claimed(%d)",
			reserved_rrs_relocs, claimed_rrs_relocs);
*/
		printf("FIX:internal error: reserved relocs(%d) != claimed(%d)\n",
			reserved_rrs_relocs, claimed_rrs_relocs);
	}

	/* Write the RRS segments. */
	write_rrs_text ();
	write_rrs_data ();
}