Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/gnu/usr.bin/ld/rrs.c

1065 lines
27 KiB
C
Raw Blame History

/*
* 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.5 1993/11/01 16:26:18 pk 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();
if (rp->r_address < text_start + text_size)
error("RRS text relocation at %#x (symbol %s)",
rp->r_address, sp->name);
#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 ();
}
Reference in New Issue View Git Blame Copy Permalink