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

/*
* ========== Copyright Header Begin ==========================================
*
* OpenSPARC T2 Processor File: coverage.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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
#pragma ident   "@(#)coverage.c 1.5     06/10/25 SMI"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <assert.h>
#include <string.h>
#include <strings.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <thread.h>
#include <synch.h>

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

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

void dbg_coverage(simcpu_t *sp, uint32_t rawi);
void dbg_coverage_parse(void);
void dbg_coverage_dump(void);

/* start/end for pc,instn coverage analysis */
uint32_t        coverage_mode;
uint64_t        start_pc = 0x0;
uint64_t        end_pc = 0x0;
bool_t          decode_instn = false;
void            *coverage_data_filep;

coverage_info_t *coverage_bufp;

        /*
         * This will be called while parsing the conf file
         * to allow this hook to parse specific options from
         * the conf file.
         *
         * Format of coverage directive is:
         * debug_hook [coverage] [start] [end];
         *
         * [coverage]   - we've already parsed this. That's how we got here.
         * [data_file]  - name of the file to mmap (will contain coverage data)
         * [start]
         * [end]        - only trace when %pc is within [start]-[end] range
         *
         * All samples for %pc within the range supplied will be stored
         * in a data file (using the name provided in the directive). The
         * results of the coverage run can be viewed by running the
         * coverage_dump tool (in the build directory) at any time during
         * or after the run.
         * NOTE: this feature will not overwrite the data_file
         */
void
dbg_coverage_parse(void)
{
        lexer_tok_t     tok;
        uint64_t        num_of_pcs;
        int             shmflg;
        uint64_t        buf_size;
        char            data_file[256];
        struct stat     sb;
        mode_t          mode = S_IRWXU | S_IRWXG | S_IRWXO;
        int             fd;


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

        /* Parse data_file to mmap in */
        tok = lex_get_token();
        strcpy(data_file, lex.strp);


        lex_get(T_Number);      /* start pc */
        start_pc = lex.val;
        lex_get(T_Number);      /* end pc */
        end_pc = lex.val;

        if (end_pc < start_pc)
            lex_fatal("end_pc needs to be larger than start_pc in conf file");

        num_of_pcs = ((end_pc - start_pc) / 4) + 1;
        buf_size = ((sizeof (coverage_info_t)) * num_of_pcs);

        DBGP(printf("\ncoverage: start_pc=0x%llx, end_pc=0x%llx "\
                "num_of_pcs=0x%llx, buf_size=0x%llx",
                start_pc, end_pc, num_of_pcs, buf_size));

        /*
         * Setup mmap file.
         *
         * Create the empty data_file of size buf_size
         * Then mmap it into memory.
         */

        /* Make sure file does not exist */
        if (stat(data_file, &sb) == 0)
                lex_fatal("coverage: file %s already exists. Check conf file ",
                    data_file);

        /* Create a new file */
        if ((fd = open(data_file, O_RDWR | O_CREAT | O_TRUNC, mode)) == -1)
                fatal("Could not create data_file %s\n", data_file);

        /* Set the size of the file by seeking to the end and write NULL */
        if (lseek(fd, (off_t)buf_size-1, SEEK_SET) < 0)
                fatal("Could not create data_file of size [0x%llx]", buf_size);

        if (write(fd, "", 1) != 1)
            fatal("Could not write to data_file of size [0x%llx]", buf_size);

        /* mmap file file */
        coverage_data_filep = mmap(NULL, buf_size, PROT_READ | PROT_WRITE,
            MAP_SHARED, fd, 0);
        if (coverage_data_filep == MAP_FAILED)
                fatal("Failed to mmap %s\n", data_file);

        coverage_bufp = coverage_data_filep;

        /*
         * 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 in execloop(). We use the coverage_dump tool
         * in legion to read the datafile.
         */
void
dbg_coverage(simcpu_t *sp, uint32_t rawi)
{
        extern uint32_t sim_atomic_add_32_nv(uint32_t *target, int32_t delta);
        int idx = 0;
        sparcv9_cpu_t *v9p = (sparcv9_cpu_t *)(sp->specificp);

        /*
         * Only store data when %pc is in Hypervisor and it is in range
         * XXX FIXME: we could parse the state from the config file.
         */
        if ((v9p->state != V9_HyperPriv) ||
            (sp->pc <= start_pc) || (sp->pc >= end_pc)) {
                return;
        }

        idx = ((sp->pc - start_pc) / 4);

        /* Increment counter and copy instn into buffer once */
        if (sim_atomic_add_32_nv(&(coverage_bufp[idx].count), 1) == 1) {
                coverage_bufp[idx].pc = sp->pc;
                coverage_bufp[idx].rawi = rawi;
        }
}

void
dbg_coverage_dump(void)
{
        printf("\ndbg_coverage_dump: caled with start=0x%llx, end=0x%llx",
            start_pc, end_pc);
        printf("\nuse legion's coverage_dump tool to read the data file");
}