dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / cmd / sgs / librtld / common / relocate.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include        <libelf.h>
#include        <dlfcn.h>
#include        "machdep.h"
#include        <krtld/reloc.h>
#include        "msg.h"
#include        "_librtld.h"
#include        "alist.h"

static const char       *unknown = 0;   /* Stash MSG_INTL(MSG_STR_UNKNOWN) */

/*
 * Process all relocation records.  A new `Reloc' structure is allocated to
 * cache the processing decisions deduced, and these will be applied during
 * update_reloc().
 * A count of the number of null relocations (i.e., relocations that will be
 * fixed and whoes records will be nulled out), data and function relocations
 * is maintained.  This allows the relocation records themselves to be
 * rearranged (localized) later if necessary.  Note that the number of function
 * relocations, although coounted, shouldn't differ from the original file,
 * the index of a .plt must be maintained to the index of its relocation record
 * within the associated relocation section.
 *
 * The intention behind this file is to maintain as much relocation logic as
 * possible in a generic form.
 */
int
count_reloc(Cache *cache, Cache *_cache, Rt_map *lmp, int flags, Addr addr,
    Xword *null, Xword *data, Xword *func, Alist *nodirect)
{
        Rel             *rel;
        Reloc           *reloc;
        Shdr            *shdr;
        Xword           ent, cnt, _cnt;
        Sym             *syms;
        const char      *strs;
        Cache           *__cache;
        Xword           pltndx = 0;

        /*
         * Determine the number of relocation entries we'll be dealing with.
         */
        shdr = _cache->c_shdr;
        rel = (Rel *)_cache->c_data->d_buf;
        ent = shdr->sh_entsize;
        cnt = shdr->sh_size / ent;

        /*
         * Allocate a relocation structure for this relocation section.
         */
        if ((reloc = calloc(cnt, sizeof (Reloc))) == 0)
                return (1);
        _cache->c_info = (void *)reloc;

        /*
         * Determine the relocations associated symbol and string table.
         */
        __cache = &cache[shdr->sh_link];
        syms = (Sym *)__cache->c_data->d_buf;
        shdr = __cache->c_shdr;
        __cache = &cache[shdr->sh_link];
        strs = (const char *)__cache->c_data->d_buf;

        /*
         * Loop through the relocation table.
         */
        for (_cnt = 0; _cnt < cnt; _cnt++, reloc++,
            rel = (Rel *)((uintptr_t)rel + ent)) {
                const char      *name;
                /* LINTED */
                uchar_t         type = (uchar_t)ELF_R_TYPE(rel->r_info, M_MACH);
                uchar_t         bind;
                ulong_t         offset = rel->r_offset + addr;
                Rt_map          *_lmp;
                int             _bound, _weak;
                ulong_t         rsymndx = ELF_R_SYM(rel->r_info);
                Slookup         sl;
                Sresult         sr;
                uint_t          binfo;
                Sym             *_sym, *sym = (syms + rsymndx);

                if (type == M_R_JMP_SLOT)
                        reloc->r_pltndx = ++pltndx;

                /*
                 * Analyze the case where no relocations are to be applied.
                 */
                if ((flags & RTLD_REL_ALL) == 0) {
                        /*
                         * Don't apply any relocations to the new image but
                         * insure their offsets are incremented to reflect any
                         * new fixed address.
                         */
                        reloc->r_flags = FLG_R_INC;

                        /*
                         * Undo any relocations that might have already been
                         * applied to the memory image.
                         */
                        if (flags & RTLD_MEMORY) {
                                reloc->r_flags |= FLG_R_UNDO;

                                /*
                                 * If a copy relocation is involved we'll need
                                 * to know the size of the copy.
                                 */
                                if (type == M_R_COPY)
                                        reloc->r_size = sym->st_size;
                                else
                                        reloc->r_size = 0;
                        }

                        /*
                         * Save the objects new address.
                         */
                        reloc->r_value = addr;

                        if (type == M_R_JMP_SLOT)
                                (*func)++;
                        else
                                (*data)++;
                        continue;
                }

                /*
                 * Determine the symbol binding of the relocation. Don't assume
                 * that relative relocations are simply M_R_RELATIVE.  Although
                 * a pic generated shared object can normally be viewed as
                 * having relative and non-relative relocations, a non-pic
                 * shared object will contain a number of relocations against
                 * local symbols (normally sections).  If a relocation is
                 * against a local symbol it qualifies as a relative relocation.
                 */
                if ((type == M_R_RELATIVE) || (type == M_R_NONE) ||
                    (ELF_ST_BIND(sym->st_info) == STB_LOCAL))
                        bind = STB_LOCAL;
                else
                        bind = STB_GLOBAL;

                /*
                 * Analyze the case where only relative relocations are to be
                 * applied.
                 */
                if ((flags & RTLD_REL_ALL) == RTLD_REL_RELATIVE) {
                        if (flags & RTLD_MEMORY) {
                                if (bind == STB_LOCAL) {
                                        /*
                                         * Save the relative relocations from
                                         * the memory image.  The data itself
                                         * might already have been relocated,
                                         * thus clear the relocation record so
                                         * that it will not be performed again.
                                         */
                                        reloc->r_flags = FLG_R_CLR;
                                        (*null)++;
                                } else {
                                        /*
                                         * Any non-relative relocation must be
                                         * undone, and the relocation records
                                         * offset updated to any new fixed
                                         * address.
                                         */
                                        reloc->r_flags =
                                            (FLG_R_UNDO | FLG_R_INC);
                                        reloc->r_value = addr;
                                        if (type == M_R_JMP_SLOT)
                                                (*func)++;
                                        else
                                                (*data)++;
                                }
                        } else {
                                if (bind == STB_LOCAL) {
                                        /*
                                         * Apply relative relocation to the
                                         * file image.  Clear the relocation
                                         * record so that it will not be
                                         * performed again.
                                         */
                                        reloc->r_flags =
                                            (FLG_R_APPLY | FLG_R_CLR);
                                        reloc->r_value = addr;
                                        if (IS_PC_RELATIVE(type))
                                                reloc->r_value -= offset;

                                        if (unknown == 0)
                                                unknown =
                                                    MSG_INTL(MSG_STR_UNKNOWN);
                                        reloc->r_name = unknown;
                                        (*null)++;
                                } else {
                                        /*
                                         * Any non-relative relocation should be
                                         * left alone, but its offset should be
                                         * updated to any new fixed address.
                                         */
                                        reloc->r_flags = FLG_R_INC;
                                        reloc->r_value = addr;
                                        if (type == M_R_JMP_SLOT)
                                                (*func)++;
                                        else
                                                (*data)++;
                                }
                        }
                        continue;
                }

                /*
                 * Analyze the case where more than just relative relocations
                 * are to be applied.
                 */
                if (bind == STB_LOCAL) {
                        if (flags & RTLD_MEMORY) {
                                /*
                                 * Save the relative relocations from the memory
                                 * image.  The data itself has already been
                                 * relocated, thus clear the relocation record
                                 * so that it will not be performed again.
                                 */
                                reloc->r_flags = FLG_R_CLR;
                        } else {
                                /*
                                 * Apply relative relocation to the file image.
                                 * Clear the relocation record so that it will
                                 * not be performed again.
                                 */
                                reloc->r_flags = (FLG_R_APPLY | FLG_R_CLR);
                                reloc->r_value = addr;
                                if (IS_PC_RELATIVE(type))
                                        reloc->r_value -= offset;

                                if (unknown == 0)
                                        unknown = MSG_INTL(MSG_STR_UNKNOWN);
                                reloc->r_name = unknown;
                        }
                        (*null)++;
                        continue;
                }

                /*
                 * At this point we're dealing with a non-relative relocation
                 * that requires the symbol definition.
                 */
                name = strs + sym->st_name;

                /*
                 * Find the symbol.  As the object being investigated is already
                 * a part of this process, the symbol lookup will likely
                 * succeed.  However, because of lazy binding, there is still
                 * the possibility of a dangling .plt relocation.  dldump()
                 * users might be encouraged to set LD_FLAGS=loadavail (crle(1)
                 * does this for them).
                 *
                 * Initialize the symbol lookup, and symbol result, data
                 * structures.
                 */
                SLOOKUP_INIT(sl, name, lmp, LIST(lmp)->lm_head, ld_entry_cnt,
                    0, rsymndx, sym, type, LKUP_STDRELOC);
                SRESULT_INIT(sr, name);

                _bound = _weak = 0;
                _sym = sym;
                if (lookup_sym(&sl, &sr, &binfo, NULL)) {
                        _lmp = sr.sr_dmap;
                        sym = sr.sr_sym;

                        /*
                         * Determine from the various relocation requirements
                         * whether this binding is appropriate.  If we're called
                         * from crle(1), RTLD_CONFSET is set, then only inspect
                         * objects selected from the configuration file
                         * (FL1_RT_CONFSET was set during load()).
                         */
                        if (!(flags & RTLD_CONFSET) ||
                            (FLAGS1(_lmp) & FL1_RT_CONFSET)) {
                                if (((flags & RTLD_REL_ALL) == RTLD_REL_ALL) ||
                                    ((flags & RTLD_REL_EXEC) &&
                                    (FLAGS(_lmp) & FLG_RT_ISMAIN)) ||
                                    ((flags & RTLD_REL_DEPENDS) &&
                                    (!(FLAGS(_lmp) & FLG_RT_ISMAIN))) ||
                                    ((flags & RTLD_REL_PRELOAD) &&
                                    (FLAGS(_lmp) & FLG_RT_PRELOAD)) ||
                                    ((flags & RTLD_REL_SELF) &&
                                    (lmp == _lmp))) {
                                        Aliste  idx;
                                        Word    *ndx;

                                        _bound = 1;

                                        /*
                                         * If this symbol is explicitly defined
                                         * as nodirect, don't allow any local
                                         * binding.
                                         */
                                        for (ALIST_TRAVERSE(nodirect, idx,
                                            ndx)) {
                                                if (*ndx == rsymndx) {
                                                        _bound = 0;
                                                        break;
                                                }
                                        }
                                }
                        }
                } else {
                        /*
                         * If this is a weak reference and we've been asked to
                         * bind unresolved weak references consider ourself
                         * bound.  This category is typically set by clre(1) for
                         * an application cache.
                         */
                        if ((ELF_ST_BIND(_sym->st_info) == STB_WEAK) &&
                            (_sym->st_shndx == SHN_UNDEF) &&
                            (flags & RTLD_REL_WEAK))
                                _bound = _weak = 1;
                }

                if (flags & RTLD_MEMORY) {
                        if (_bound) {
                                /*
                                 * We know that all data relocations will have
                                 * been performed at process startup thus clear
                                 * the relocation record so that it will not be
                                 * performed again.  However, we don't know what
                                 * function relocations have been performed
                                 * because of lazy binding - regardless, we can
                                 * leave all the function relocation records in
                                 * place, because if the function has already
                                 * been bound the record won't be referenced
                                 * anyway.  In the case of using LD_BIND_NOW,
                                 * a function may be bound twice - so what.
                                 */
                                if (type == M_R_JMP_SLOT) {
                                        reloc->r_flags = FLG_R_INC;
                                        (*func)++;
                                } else {
                                        if (type != M_R_COPY)
                                                reloc->r_flags = FLG_R_CLR;
                                        (*null)++;
                                }
                        } else {
                                /*
                                 * Clear any unrequired relocation.
                                 */
                                reloc->r_flags = FLG_R_UNDO | FLG_R_INC;
                                reloc->r_value = addr;
                                if (type == M_R_JMP_SLOT)
                                        (*func)++;
                                else
                                        (*data)++;
                        }
                } else {
                        if (_bound) {
                                /*
                                 * Apply the global relocation to the file
                                 * image.  Clear the relocation record so that
                                 * it will not be performed again.
                                 */
                                if (_weak) {
                                        reloc->r_value = 0;
                                        reloc->r_size = 0;
                                } else {
                                        reloc->r_value = sym->st_value;
                                        if (IS_PC_RELATIVE(type))
                                                reloc->r_value -= offset;
                                        if ((!(FLAGS(_lmp) & FLG_RT_FIXED)) &&
                                            (sym->st_shndx != SHN_ABS))
                                                reloc->r_value += ADDR(_lmp);
                                        reloc->r_size = sym->st_size;
                                }

                                reloc->r_flags = FLG_R_APPLY | FLG_R_CLR;
                                reloc->r_name = name;
                                if (type == M_R_JMP_SLOT)
                                        (*func)++;
                                else
                                        (*null)++;
                        } else {
                                /*
                                 * Do not apply any unrequired relocations.
                                 */
                                reloc->r_flags = FLG_R_INC;
                                reloc->r_value = addr;
                                if (type == M_R_JMP_SLOT)
                                        (*func)++;
                                else
                                        (*data)++;
                        }
                }
        }
        return (0);
}


/*
 * Perform any relocation updates to the new image using the information from
 * the `Reloc' structure constructed during count_reloc().
 */
void
update_reloc(Cache *ocache, Cache *icache, Cache *_icache, const char *name,
    Rt_map *lmp, Rel **null, Rel **data, Rel **func)
{
        Shdr    *shdr;
        Rel     *rel;
        Reloc   *reloc;
        Xword   ent, cnt, _cnt;
        Cache   *orcache, *ircache = 0;
        Half    ndx;

        /*
         * Set up to read the output relocation table.
         */
        shdr = _icache->c_shdr;
        rel = (Rel *)_icache->c_data->d_buf;
        reloc = (Reloc *)_icache->c_info;
        ent = shdr->sh_entsize;
        cnt = shdr->sh_size / ent;

        /*
         * Loop through the relocation table.
         */
        for (_cnt = 0; _cnt < cnt; _cnt++, reloc++,
            rel = (Rel *)((uintptr_t)rel + ent)) {
                uchar_t         *iaddr, *oaddr;
                /* LINTED */
                uchar_t         type = (uchar_t)ELF_R_TYPE(rel->r_info, M_MACH);
                Addr            off, bgn, end;

                /*
                 * Ignore null relocations (these may have been created from a
                 * previous dldump() of this image).
                 */
                if (type == M_R_NONE) {
                        (*null)++;
                        continue;
                }

                /*
                 * Determine the section being relocated if we haven't already
                 * done so (we may have had to skip over some null relocation to
                 * get to the first valid offset).  The System V ABI states that
                 * a relocation sections sh_info field indicates the section
                 * that must be relocated.  However, on Intel it seems that the
                 * .rel.plt sh_info records the section index of the .plt, when
                 * in fact it's the .got that gets relocated.  In addition we
                 * now create combined relocation sections with -zcomreloc.  To
                 * generically be able to cope with these anomalies, search for
                 * the appropriate section to be relocated by comparing the
                 * offset of the first relocation record against each sections
                 * offset and size.
                 */
                /* BEGIN CSTYLED */
                if ((ircache == (Cache *)0) || (rel->r_offset < bgn) ||
                        (rel->r_offset > end)) {
                        _icache = icache;
                        _icache++;

                        for (ndx = 1; _icache->c_flags != FLG_C_END; ndx++,
                            _icache++) {

                                shdr = _icache->c_shdr;
                                bgn = shdr->sh_addr;
                                end = bgn + shdr->sh_size;

                                if ((rel->r_offset >= bgn) &&
                                    (rel->r_offset <= end))
                                        break;
                        }
                        ircache = &icache[ndx];
                        orcache = &ocache[ndx];
                }
                /* END CSTYLED */

                /*
                 * Determine the relocation location of both the input and
                 * output data.  Take into account that an input section may be
                 * NOBITS (ppc .plt for example).
                 */
                off = rel->r_offset - ircache->c_shdr->sh_addr;
                if (ircache->c_data->d_buf)
                        iaddr = (uchar_t *)ircache->c_data->d_buf + off;
                else
                        iaddr = 0;
                oaddr = (uchar_t *)orcache->c_data->d_buf + off;

                /*
                 * Apply the relocation to the new output image.  Any base
                 * address, or symbol value, will have been saved in the reloc
                 * structure during count_reloc().
                 */
                if (reloc->r_flags & FLG_R_APPLY)
                        apply_reloc(rel, reloc, name, oaddr, lmp);

                /*
                 * Undo any relocation that might already been applied to the
                 * memory image by the runtime linker.  Using the original
                 * file, determine the relocation offset original value and
                 * restore the new image to that value.
                 */
                if ((reloc->r_flags & FLG_R_UNDO) &&
                    (FLAGS(lmp) & FLG_RT_RELOCED))
                        undo_reloc(rel, oaddr, iaddr, reloc);

                /*
                 * If a relocation has been applied then the relocation record
                 * should be cleared so that the relocation isn't applied again
                 * when the new image is used.
                 */
                if (reloc->r_flags & FLG_R_CLR) {
                        if (type == M_R_JMP_SLOT) {
                                clear_reloc(*func);
                                *func = (Rel *)((uintptr_t)*func + ent);
                        } else {
                                clear_reloc(*null);
                                *null = (Rel *)((uintptr_t)*null + ent);
                        }
                }

                /*
                 * If a relocation isn't applied, update the relocation record
                 * to take into account the new address of the image.
                 */
                if (reloc->r_flags & FLG_R_INC) {
                        if (type == M_R_JMP_SLOT) {
                                inc_reloc(*func, rel, reloc, oaddr, iaddr);
                                *func = (Rel *)((uintptr_t)*func + ent);
                        } else {
                                inc_reloc(*data, rel, reloc, oaddr, iaddr);
                                *data = (Rel *)((uintptr_t)*data + ent);
                        }
                }
        }
}