ctf/cvt/fixup_tdescs.c

	fixup_tdescs.c revision e824d57f8160a27ac5e650005c7a4f037109c2be
/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * Workarounds for stabs generation bugs in the compiler and general needed
 * fixups.
 */

#include <stdio.h>
#include <strings.h>

#include "ctf_headers.h"
#include "ctftools.h"
#include "hash.h"
#include "memory.h"

/*
 * Due to 4432619, the 6.1 compiler will sometimes incorrectly generate pointer
 * stabs.  Given a struct foo, and a corresponding typedef struct foo foo_t.
 * In some cases, when faced with a pointer to a foo_t, the compiler will
 * sometimes generate a stab that describes a pointer to a struct foo.
 * Regardless of correctness, this breaks merges, as it occurs inconsistently
 * by file.  The following two routines know how to recognize and repair foo_t *
 * and foo_t ** bugs in a specific set of cases.  There is no general way to
 * solve this problem without a fix to the compiler.  In general, cases should
 * only be added to these routines to fix merging problems in genunix.
 */
static void
fix_ptrptr_to_struct(tdata_t *td)
{
    char *strs[2] = { "as", "fdbuffer" };
    char *mems[2] = { "a_objectdir", "fd_shadow" };
    char *acts[2] = { "vnode", "page" };
    char *tgts[2] = { "vnode_t", "page_t" };
    tdesc_t *str;
    tdesc_t *act, *tgt;
    tdesc_t *p1, *p2;
    mlist_t *ml;
    int i;

    for (i = 0; i < sizeof (strs) / sizeof (strs[0]); i++) {
        if (!(str = lookupname(strs[i])) || str->t_type != STRUCT)
            continue;

        for (ml = str->t_members; ml; ml = ml->ml_next) {
            if (streq(ml->ml_name, mems[i]))
                break;
        }
        if (!ml)
            continue;

        if (ml->ml_type->t_type != POINTER || ml->ml_type->t_name ||
            ml->ml_type->t_tdesc->t_type != POINTER ||
            ml->ml_type->t_tdesc->t_name)
            continue;

        act = ml->ml_type->t_tdesc->t_tdesc;
        if (act->t_type != STRUCT || !streq(act->t_name, acts[i]))
            continue;

        if (!(tgt = lookupname(tgts[i])) || tgt->t_type != TYPEDEF)
            continue;

        /* We have an instance of the bug */
        p2 = xcalloc(sizeof (*p2));
        p2->t_type = POINTER;
        p2->t_id = td->td_nextid++;
        p2->t_tdesc = tgt;

        p1 = xcalloc(sizeof (*p1));
        p1->t_type = POINTER;
        p1->t_id = td->td_nextid++;
        p1->t_tdesc = p2;

        ml->ml_type = p1;

        debug(3, "Fixed %s->%s => ptrptr struct %s bug\n",
            strs[i], mems[i], acts[i]);
    }
}

static void
fix_ptr_to_struct(tdata_t *td)
{
    char *strs[2] = { "vmem", "id_space" };
    char *mems[2] = { NULL, "is_vmem" };
    tdesc_t *ptr = NULL;
    tdesc_t *str, *vmt;
    mlist_t *ml;
    int i;

    if ((vmt = lookupname("vmem_t")) == NULL || vmt->t_type != TYPEDEF)
        return;

    for (i = 0; i < sizeof (strs) / sizeof (strs[0]); i++) {
        if (!(str = lookupname(strs[i])) || str->t_type != STRUCT)
            continue;

        for (ml = str->t_members; ml; ml = ml->ml_next) {
            if (mems[i] && !streq(ml->ml_name, mems[i]))
                continue;

            if (ml->ml_type->t_type != POINTER ||
                ml->ml_type->t_name ||
                (ml->ml_type->t_tdesc->t_type != STRUCT &&
                ml->ml_type->t_tdesc->t_type != FORWARD) ||
                !streq(ml->ml_type->t_tdesc->t_name, "vmem"))
                continue;

            debug(3, "Fixed %s->%s => ptr struct vmem bug\n",
                strs[i], ml->ml_name);

            if (!ptr) {
                ptr = xcalloc(sizeof (*ptr));
                ptr->t_type = POINTER;
                ptr->t_id = td->td_nextid++;
                ptr->t_tdesc = vmt;
            }

            ml->ml_type = ptr;
        }
    }
}

/*
 * Fix stabs generation bugs.  These routines must be run before the
 * post-conversion merge
 */
void
cvt_fixstabs(tdata_t *td)
{
    fix_ptrptr_to_struct(td);
    fix_ptr_to_struct(td);
}

struct match {
    tdesc_t *m_ret;
    const char *m_name;
};

static int
matching_iidesc(iidesc_t *iidesc, struct match *match)
{
    if (!streq(iidesc->ii_name, match->m_name))
        return (0);

    if (iidesc->ii_type != II_TYPE && iidesc->ii_type != II_SOU)
        return (0);

    match->m_ret = iidesc->ii_dtype;
    return (-1);
}

static tdesc_t *
lookup_tdesc(tdata_t *td, const char *name)
{
    struct match match = { NULL, name };
    iter_iidescs_by_name(td, name, (int (*)())matching_iidesc, &match);
    return (match.m_ret);
}

/*
 * The cpu structure grows, with the addition of a machcpu member, if
 * _MACHDEP is defined.  This means that, for example, the cpu structure
 * in unix is different from the cpu structure in genunix.  As one might
 * expect, this causes merges to fail.  Since everyone indirectly contains
 * a pointer to a CPU structure, the failed merges can cause massive amounts
 * of duplication.  In the case of unix uniquifying against genunix, upwards
 * of 50% of the structures were unmerged due to this problem.  We fix this
 * by adding a cpu_m member.  If machcpu hasn't been defined in our module,
 * we make a forward node for it.
 */
static void
fix_small_cpu_struct(tdata_t *td, size_t ptrsize)
{
    tdesc_t *cput, *cpu;
    tdesc_t *machcpu;
    mlist_t *ml, *lml;
    mlist_t *cpum;
    int foundcpucyc = 0;

    /*
     * We're going to take the circuitous route finding the cpu structure,
     * because we want to make sure that we find the right one.  It would
     * be nice if we could verify the header name too.  DWARF might not
     * have the cpu_t, so we let this pass.
     */
    if ((cput = lookup_tdesc(td, "cpu_t")) != NULL) {
        if (cput->t_type != TYPEDEF)
            return;
        cpu = cput->t_tdesc;
    } else {
        cpu = lookup_tdesc(td, "cpu");
    }

    if (cpu == NULL)
        return;

    if (!streq(cpu->t_name, "cpu") || cpu->t_type != STRUCT)
        return;

    for (ml = cpu->t_members, lml = NULL; ml;
        lml = ml, ml = ml->ml_next) {
        if (strcmp(ml->ml_name, "cpu_cyclic") == 0)
            foundcpucyc = 1;
    }

    if (foundcpucyc == 0 || lml == NULL ||
        strcmp(lml->ml_name, "cpu_m") == 0)
        return;

    /*
     * We need to derive the right offset for the fake cpu_m member.  To do
     * that, we require a special unused member to be the last member
     * before the 'cpu_m', that we encode knowledge of here.  ABI alignment
     * on all platforms is such that we only need to add a pointer-size
     * number of bits to get the right offset for cpu_m.  This would most
     * likely break if gcc's -malign-double were ever used, but that option
     * breaks the ABI anyway.
     */
    if (!streq(lml->ml_name, "cpu_m_pad") &&
        getenv("CTFCONVERT_PERMISSIVE") == NULL) {
        terminate("last cpu_t member before cpu_m is %s; "
            "it must be cpu_m_pad.\n", lml->ml_name);
    }

    if ((machcpu = lookup_tdesc(td, "machcpu")) == NULL) {
        machcpu = xcalloc(sizeof (*machcpu));
        machcpu->t_name = xstrdup("machcpu");
        machcpu->t_id = td->td_nextid++;
        machcpu->t_type = FORWARD;
    } else if (machcpu->t_type != STRUCT) {
        return;
    }

    debug(3, "Adding cpu_m machcpu %s to cpu struct\n",
        (machcpu->t_type == FORWARD ? "forward" : "struct"));

    cpum = xmalloc(sizeof (*cpum));
    cpum->ml_offset = lml->ml_offset + (ptrsize * NBBY);
    cpum->ml_size = 0;
    cpum->ml_name = xstrdup("cpu_m");
    cpum->ml_type = machcpu;
    cpum->ml_next = NULL;

    lml->ml_next = cpum;
}

void
cvt_fixups(tdata_t *td, size_t ptrsize)
{
    fix_small_cpu_struct(td, ptrsize);
}