gem5/util/statetrace/printer.cc

/*
 * Copyright (c) 2006-2007 The Regents of The University of Michigan
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Authors: Gabe Black
 */

#include "tracechild.hh"
#include "printer.hh"

using namespace std;

//Types of printers. If none is found, or there is an error in the input,
//there are psuedo types to return.
enum PrinterType {PRINTER_NONE, PRINTER_ERROR, PRINTER_NESTING, PRINTER_REG};

int findEndOfRegPrinter(string, int);
int findEndOfNestingPrinter(string, int);
PrinterType findSub(string, int &, int &);

//This is pretty easy. Just find the closing parenthesis.
int findEndOfRegPrinter(string config, int startPos)
{
    int pos = config.find(")", startPos);
    if(pos == string::npos)
    {
        cerr << "Couldn't find the closing parenthesis for a reg printer" << endl;
        return 0;
    }
    return pos;
}

//This is a little harder. We need to make sure we don't
//grab an ending parenthesis that belongs to the nesting printer.
int findEndOfNestingPrinter(string config, int startPos)
{
    int length = config.length();
    int pos = startPos;
    int endPos = length;
    int parenPos = config.find(")", pos);
    //If we didn't find an ending parenthesis at all, we're in trouble
    if(parenPos == string::npos)
    {
        cerr << "Couldn't find the closing parenthesis for a nesting printer on the first try" << endl;
        return 0;
    }
    //Keep pulling out embedded stuff until we can't any more
    //we need to make sure we aren't skipping over the parenthesis
    //that ends -this- printer.
    PrinterType type = findSub(config, pos, endPos);
    if(type == PRINTER_ERROR)
        return 0;
    while(type != PRINTER_NONE && endPos >= parenPos)
    {
        //Find the next closest ending parenthesis since we passed
        //up the last one
        parenPos = config.find(")", endPos + 1);
        //If we didn't find one, we're in trouble
        if(parenPos == string::npos)
        {
            cerr << "Couldn't find the closing parenthesis for a nested printer on later tries" << endl;
            return 0;
        }
        //Start looking for the end of this printer and embedded
        //stuff past the one we just found
        pos = endPos + 1;
        //Reset endPos so we search to the end of config
        endPos = length;
        type = findSub(config, pos, endPos);
        if(type == PRINTER_ERROR)
            return 0;
    }
    //We ran out of embedded items, and we didn't pass up our last
    //closing paren. This must be the end of this printer.
    return parenPos;
}

//Find a sub printer. This looks for things which have a type defining
//character and then an opening parenthesis. The type is returned, and
//startPos and endPos are set to the beginning and end of the sub printer
//On entry, the search starts at index startPos and ends at either index
//endPos or a closing parenthesis, whichever comes first
PrinterType findSub(string config, int & startPos, int & endPos)
{
    int length = config.length();
    //Figure out where the different types of sub printers may start
    int regPos = config.find("%(", startPos);
    int nestingPos = config.find("~(", startPos);
    //If a type of printer wasn't found, say it was found too far away.
    //This simplifies things later
    if(regPos == string::npos)
        regPos = endPos;
    if(nestingPos == string::npos)
        nestingPos = endPos;
    //If we find a closing paren, that marks the
    //end of the region we're searching.
    int closingPos = config.find(")", startPos);
    if(closingPos != string::npos &&
            closingPos < regPos &&
            closingPos < nestingPos)
        return PRINTER_NONE;
    //If we didn't find anything close enough, say so.
    if(regPos >= endPos && nestingPos >= endPos)
        return PRINTER_NONE;
    //At this point, we know that one of the options starts legally
    //We need to find which one is first and return that
    if(regPos < nestingPos)
    {
        int regEnd = findEndOfRegPrinter(config, regPos + 2);
        //If we couldn't find the end...
        if(!regEnd)
        {
            cerr << "Couldn't find the end of the reg printer" << endl;
            return PRINTER_ERROR;
        }
        //Report the sub printer's vitals.
        startPos = regPos;
        endPos = regEnd;
        return PRINTER_REG;
    }
    else
    {
        int nestingEnd = findEndOfNestingPrinter(config, nestingPos + 2);
        //If we couldn't find the end...
        if(!nestingEnd)
        {
            cerr << "Couldn't find the end of the nesting printer" << endl;
            return PRINTER_ERROR;
        }
        //Report the sub printer's vitals.
        startPos = nestingPos;
        endPos = nestingEnd;
        return PRINTER_NESTING;
    }
    return PRINTER_NONE;
}

//Set up a nesting printer. This printer can contain sub printers
bool NestingPrinter::configure(string config)
{
    //Clear out any old stuff
    constStrings.clear();
    numPrinters = 0;
    printers.clear();
    int length = config.length();
    int startPos = 0, endPos = length;
    int lastEndPos = -1;
    //Try to find a sub printer
    PrinterType type = findSub(config, startPos, endPos);
    if(type == PRINTER_ERROR)
    {
        cerr << "Problem finding first sub printer" << endl;
        return false;
    }
    while(type != PRINTER_NONE)
    {
        string prefix = config.substr(lastEndPos + 1, startPos - lastEndPos - 1);
        lastEndPos = endPos;
        constStrings.push_back(prefix);
        string subConfig, subString;
        long int commaPos, lastCommaPos, childSwitchVar;
        //Set up the register printer
        RegPrinter * regPrinter = new RegPrinter(child);
        NestingPrinter * nestingPrinter = new NestingPrinter(child);
        switch(type)
        {
            //If we found a plain register printer
          case PRINTER_REG:
            numPrinters++;
            //Get the register name
            subConfig = config.substr(startPos + 2, endPos - startPos - 2);
            if(!regPrinter->configure(subConfig))
            {
                delete regPrinter;
                cerr << "Error configuring reg printer" << endl;
                return false;
            }
            printers.push_back(regPrinter);
            break;
            //If we found an embedded nesting printer
          case PRINTER_NESTING:
            numPrinters++;
            //Punt on reading in all the parameters of the nesting printer
            subConfig = config.substr(startPos + 2, endPos - startPos - 2);
            lastCommaPos = string::npos;
            commaPos = subConfig.find(",");
            if(commaPos == string::npos)
                return false;
            childSwitchVar = child->getRegNum(subConfig.substr(0, commaPos));
            if(childSwitchVar == -1)
            {
                cerr << "Couldn't configure switching variable!" << endl;
                return false;
            }
            //Eat up remaining arguments
            while(commaPos != string::npos)
            {
                lastCommaPos = commaPos;
                commaPos = subConfig.find(",", commaPos + 1);
            }
            if(lastCommaPos != string::npos)
            {
                subConfig = subConfig.substr(lastCommaPos + 1, subConfig.length() - lastCommaPos - 1);
            }
            if(!nestingPrinter->configure(subConfig))
            {
                delete nestingPrinter;
                cerr << "Error configuring nesting printer" << endl;
                return false;
            }
            nestingPrinter->switchVar = childSwitchVar;
            printers.push_back(nestingPrinter);
            break;
          default:
            cerr << "Unrecognized printer type" << endl;
            return false;
        }
        //Move down past what we just parsed
        startPos = endPos + 1;
        endPos = length;
        type = findSub(config, startPos, endPos);
        if(type == PRINTER_ERROR)
        {
            cerr << "Unable to find subprinters on later tries" << endl;
            return false;
        }
    }
    //Put in the trailing stuff
    string trailer = config.substr(startPos, length - startPos);
    constStrings.push_back(trailer);
    return true;
}

bool RegPrinter::configure(string config)
{
    //Figure out what our register number is based on the name we're given
    int num = child->getRegNum(config);
    if(num == -1)
    {
        cerr << "Couldn't find register " << config << endl;
        return false;
    }
    regNum(num);
    return true;
}

ostream & NestingPrinter::writeOut(ostream & os)
{
    if(switchVar == -1 || child->diffSinceUpdate(switchVar))
    {
        int x;
        for(x = 0; x < numPrinters; x++)
        {
            os << constStrings[x];
            os << printers[x];
        }
        os << constStrings[x];
    }
    return os;
}

ostream & RegPrinter::writeOut(ostream & os)
{
    os << child->printReg(intRegNum);
    return os;
}