/*
 * 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 (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */
#ifndef _INLINE_RELOC_H
#define _INLINE_RELOC_H

#include        <sys/types.h>
#include        <rtld.h>
#include        <debug.h>

/*
 * Generic relative relocation function.
 */
inline static ulong_t
/* LINTED */
/* ARGSUSED4 */
_elf_reloc_relative(ulong_t rbgn, ulong_t base, Rt_map *lmp, APlist **textrel,
    int add)
{
        mmapobj_result_t        *mpp;
        ulong_t                 roffset;

        roffset = ((M_RELOC *)rbgn)->r_offset;
        roffset += base;

        /*
         * If this relocation is against an address that is not associated with
         * a mapped segment, fall back to the generic relocation loop to
         * collect the associated error.
         */
        if ((mpp = find_segment((caddr_t)roffset, lmp)) == NULL)
                return (0);

        /*
         * If this relocation is against a segment that does not provide write
         * access, set the write permission for all non-writable mappings.
         */
        if (((mpp->mr_prot & PROT_WRITE) == 0) && textrel &&
            ((set_prot(lmp, mpp, 1) == 0) ||
            (aplist_append(textrel, mpp, AL_CNT_TEXTREL) == NULL)))
                return (0);

        /*
         * Perform a base address update.  This simple operation is required
         * for updating .plt relocations in preparation for lazy binding.
         */
#if     defined(__x86)
        if (add) {
                *((ulong_t *)roffset) += base;
                return (1);
        }
#endif
        /*
         * Perform the actual relocation.  Note, for backward compatibility,
         * SPARC relocations are added to the offset contents (there was a time
         * when the offset was used to contain the addend, rather than using
         * the addend itself).
         */
#if     defined(__sparc)
        *((ulong_t *)roffset) += base + ((M_RELOC *)rbgn)->r_addend;
#elif   defined(__amd64)
        *((ulong_t *)roffset) = base + ((M_RELOC *)rbgn)->r_addend;
#else
        *((ulong_t *)roffset) += base;
#endif
        return (1);
}

/*
 * When a generic relocation loop realizes that it's dealing with relative
 * relocations, but no DT_RELCOUNT .dynamic tag is present, this tighter loop
 * is entered as an optimization.
 */
inline static ulong_t
/* LINTED */
elf_reloc_relative(ulong_t rbgn, ulong_t rend, ulong_t rsize, ulong_t base,
    Rt_map *lmp, APlist **textrel, int add)
{
        uchar_t rtype;

        do {
                if (_elf_reloc_relative(rbgn, base, lmp, textrel, add) == 0)
                        break;

                rbgn += rsize;
                if (rbgn >= rend)
                        break;

                /*
                 * Make sure the next type is a relative relocation.
                 */
                rtype = ELF_R_TYPE(((M_RELOC *)rbgn)->r_info, M_MACH);

        } while (rtype == M_R_RELATIVE);

        return (rbgn);
}

/*
 * This is the tightest loop for RELATIVE relocations for those objects built
 * with the DT_RELACOUNT .dynamic entry.
 */
inline static ulong_t
/* LINTED */
elf_reloc_relative_count(ulong_t rbgn, ulong_t rcount, ulong_t rsize,
    ulong_t base, Rt_map *lmp, APlist **textrel, int add)
{
        for (; rcount; rcount--) {
                if (_elf_reloc_relative(rbgn, base, lmp, textrel, add) == 0)
                        break;

                rbgn += rsize;
        }
        return (rbgn);
}

/*
 * Determine, from a symbols Syminfo information, whether a symbol reference
 * is deferred.  This routine is called from elf_reloc() as part of processing
 * an objects relocations.
 */
inline static int
/* LINTED */
is_sym_deferred(ulong_t rbgn, ulong_t base, Rt_map *lmp, APlist **textrel,
    Syminfo *sip, ulong_t sndx)
{
        Syminfo *sipe;

        /*
         * ldd(1) by default, sets LD_DEFERRED to force deferred dependency
         * processing.  ldd -D disables LD_DEFERRED, which allows ld.so.1's
         * default action of skipping deferred dependencies.
         */
        if (rtld_flags & RT_FL_DEFERRED)
                return (0);

        /* LINTED */
        sipe = (Syminfo *)((char *)sip + (sndx * SYMINENT(lmp)));
        if (sipe->si_flags & SYMINFO_FLG_DEFERRED) {
                /*
                 * This .plt relocation should be skipped at this time, as
                 * deferred references are only processed when the associated
                 * function is explicitly called.
                 *
                 * On i386 and amd64 platforms the relocation offset needs
                 * adjusting to add this objects base address.  If the object
                 * has already been relocated without RTLD_NOW, then this
                 * update will have already been carried out.  However, if this
                 * is an initial RTLD_NOW relocation pass, this relocation
                 * offset needs updating now.
                 */
#if     defined(__x86)
                if ((FLAGS(lmp) & FLG_RT_RELOCED) == 0)
                        (void) _elf_reloc_relative(rbgn, base, lmp, textrel, 1);
#endif
                return (1);
        }
        return (0);
}

#endif  /* _INLINE_RELOC_H */