legion/src/procs/sunsparc/debug/trace.c

/*
* ========== Copyright Header Begin ==========================================
*
* OpenSPARC T2 Processor File: trace.c
* Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
*
* The above named program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2 as published by the Free Software Foundation.
*
* The above named program is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public
* License along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
*
* ========== Copyright Header End ============================================
*/
/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
#pragma ident   "@(#)trace.c    1.8     07/01/09 SMI"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <assert.h>
#include <string.h>

#include "ss_common.h"
#include "niagara.h"

#if 1
#define DBGP(s)  do { s } while (0)
#endif

void dbg_trace(simcpu_t *sp, uint32_t rawi);
void dbg_trace_parse(void);
void dbg_trace_dump(void);

static void dump_intregs(uint64_t  *data);

/*
 * Trace modes
 * ALL   = trace all instns for all values of %pc
 * PC    = start trace when "start" %pc is encountered
 *         stop when 'end' %pc is encountered.
 * INSTN = only trace when instn count is within start-end range
 */
enum trace_modes { ALL, PC, INSTN };

/* start/end for pc,instn tracing */
uint32_t        trace_mode;
char            trace_mode_str[64];
uint64_t        start_trace = 0x0;
uint64_t        end_trace = 0x0;
bool_t          dump_regs = false;

        /*
         * This will be called while parsing the conf file
         * to allow this hook to parse specific options from
         * the conf file.
         *
         * Format of trace directive is:
         * debug_hook [trace] [mode] [regs] [start] [end];
         *
         * [trace] - we've already parsed this. That's how we got here.
         * [mode]  - is one of [all, pc, instn]
         *              all   : traces all instns (no start, end values)
         *              pc    : just trace when %pc is withing start-end range
         *              instn : just trace when instn count is within start-end
         * [regs]  - if defined, we dump the %g,%o,%l,%i regs with each sample.
         * [start]
         * [end]   - only trace when %pc or inst_cnt is within [start]-[end]
         *              range
         *
         * examples:
         * trace all;
         * trace all regs;
         * trace pc 0x123 0x456;
         * trace pc regs 0x123 0x456;
         * trace instn 0x123 0x456;
         * trace instn regs 0x123 0x456;
         */
void
dbg_trace_parse(void)
{
        lexer_tok_t     tok;

        DBGP(printf("\nInside dbg_trace_parse()"););

        tok = lex_get_token();  /* trace mode */
        strcpy(trace_mode_str, lex.strp);

        if (streq(lex.strp, "all"))
                trace_mode = ALL;
        else if (streq(lex.strp, "pc"))
                trace_mode = PC;
        else if (streq(lex.strp, "instn"))
                trace_mode = INSTN;
        else
                lex_fatal("unknown trace_mode [%s] parsing config", lex.strp);

        /* parse optional regs token */
        tok = lex_get_token();
        if (streq(lex.strp, "regs")) {
                dump_regs = true;
        } else {
                lex_unget();    /* no regs option, continue */
        }

        /*
         * continue parsing conf file
         */
        switch (trace_mode) {
        case ALL:
                break;  /* no more parsing for 'all' mode */
        case PC:
        case INSTN:
                lex_get(T_Number);      /* start pc/instn */
                start_trace = lex.val;
                lex_get(T_Number);      /* end pc/instn */
                end_trace = lex.val;
                break;
        }

        DBGP(printf("\ndbg_trace_parse: mode=%s, start=0x%llx, end=0x%llx",
                trace_mode_str, start_trace, end_trace););

        /*
         * return to parse_debug_hook() which will take care
         * of parsing the last semi colon.
         */
}

        /*
         * This function will get called before each instruction
         * gets executed. For performance reasons, we may want to
         * store the data in a buffer and post-process it later.
         */
void
dbg_trace(simcpu_t *sp, uint32_t rawi)
{
        sparcv9_cpu_t   *v9p;
        char            trace_buf[64];
        static bool_t   first_time = true;

        /*
         * If a trace range is given, we only trace within that
         * range
         */
        switch (trace_mode) {
        case ALL:
                break;  /* trace everything */
        case PC:
                if ((sp->pc < start_trace) || (sp->pc > end_trace)) {
                        return; /* only trace when %pc is in range */
                }
                break;
        case INSTN:
                if ((sp->cycle < start_trace) ||
                    (sp->cycle > end_trace)) {
                        return; /* only trace when instn count is in range */
                }
                break;
        }

        v9p = (sparcv9_cpu_t *)sp->specificp;
        sparcv9_idis(trace_buf, sizeof (trace_buf),
            FE_INSTN(rawi), sp->pc);

        if (first_time) {
                printf("\n[cpu] Instn_# tl:tt/gl    state %%pc [raw_instn]"
                    "\tinstn\n");
                first_time = false;
        }

        /*
         * When printing registers, we print them in their state prior to
         * executing the instruction in question.
         */
        if (dump_regs)
                dump_intregs(sp->intreg);

        printf("\n[0x%llx] 0x%llx %x:%x/%x     0x%x 0x%llx [0x%08x]\t%s",
            sp->gid,  sp->cycle,
            v9p->tl,
            (v9p->tl == 0) ? 0 : N_TT(v9p, v9p->tl),
            v9p->gl,
            v9p->state,
            sp->pc,
            FE_INSTN(rawi),
            trace_buf);
}

static void
dump_intregs(uint64_t  *intreg)
{
        int i;

        for (i = 0; i < 8; i++) {
            printf("\ng%d=0x%016llx o%d=0x%016llx l%d=0x%016llx i%d=0x%016llx",
                i, intreg[i],
                i, intreg[i+8],
                i, intreg[i+16],
                i, intreg[i+24]);
        }
}

void
dbg_trace_dump(void)
{
        printf("\ndbg_trace_dump: caled with mode=%s, start=0x%llx, "\
            "end=0x%llx\n", trace_mode_str, start_trace, end_trace);
}