/*
 * RTEMS Tools Project (http://www.rtems.org/)
 * Copyright 2014 OAR Corporation
 * All rights reserved.
 *
 * This file is part of the RTEMS Tools package in 'rtems-tools'.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. 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.
 *
 * 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 HOLDER 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.
 */

/*! @file TraceReaderLogQEMU.cc
 *  @brief TraceReaderLogQEMU Implementation
 *
 *  This file contains the implementation of the functions supporting
 *  reading the QEMU coverage data files.
 */

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <string.h>

#include <iostream>
#include <fstream>

#include "qemu-log.h"
#include "TraceReaderBase.h"
#include "TraceReaderLogQEMU.h"
#include "TraceList.h"
#include "qemu-traces.h"

#include "rld-process.h"

bool ReadUntilFound( std::ifstream& file, const char* line )
{
  char   discardBuff[100] = {};
  size_t len = strlen( line );

  if ( len > sizeof( discardBuff ) ) {
    std::cerr << "ReadUntilFound(): parameter 'line' is too long" << std::endl;
    return false;
  }

  do {
    file.read( discardBuff, sizeof( discardBuff ) - 2 );
    if ( file.fail() ) {
      return false;
    }

    if ( strncmp( discardBuff, line, len ) == 0 ) {
      return true;
    }

  } while( true );
}

namespace Trace {

  TraceReaderLogQEMU::TraceReaderLogQEMU()
  {
  }

  TraceReaderLogQEMU::~TraceReaderLogQEMU()
  {
  }

  bool TraceReaderLogQEMU::processFile(
    const std::string&          file,
    Coverage::ObjdumpProcessor& objdumpProcessor
  )
  {
    bool                done          = false;
    QEMU_LOG_IN_Block_t first         = { 0, "", "" };
    QEMU_LOG_IN_Block_t last          = { 0, "", "" };
    QEMU_LOG_IN_Block_t nextExecuted  = { 0, "", "" };
    uint32_t            nextlogical;
    int                 status;
    std::ifstream       logFile;
    int                 result;
    int                 fileSize;
    char                ignore;

    //
    // Verify that the log file has a non-zero size.
    //
    logFile.open( file, std::ifstream::in | std::ifstream::binary );
    if ( !logFile.is_open() ) {
      std::cerr << "Unable to open " << file << std::endl;
      return false;
    }

    logFile.seekg( 0, std::ios::end );
    fileSize = logFile.tellg();

    if ( fileSize == 0 ) {
      std::cerr << file << " is 0 bytes long" << std::endl;
      return false;
    }

    logFile.close();

    //
    // Open the coverage file and discard the header.
    //
    logFile.open( file );

    //
    //  Discard Header section
    //
    if ( !ReadUntilFound( logFile, QEMU_LOG_SECTION_END ) ) {
      std::cerr << "Unable to locate end of log file header" << std::endl;
      return false;
    }

    //
    //  Find first IN block
    //
    if ( !ReadUntilFound( logFile, QEMU_LOG_IN_KEY ) ) {
      std::cerr << "Error: Unable to locate first IN: Block in Log file"
                << std::endl;
      return false;
    }

    //
    //  Read First Start Address
    //
    logFile >> std::hex >> first.address >> std::dec
            >> ignore
            >> first.instruction
            >> first.data;

    if ( logFile.fail() ) {
      std::cerr << "Error Unable to Read Initial First Block" << std::endl;
      done = true;
    }

    while ( !done ) {

      last = first;

      // Read until we get to the last instruction in the block.
      do {
        logFile >> std::hex >> last.address >> std::dec
                >> ignore
                >> last.instruction
                >> last.data;
      } while( !logFile.fail() );

      nextlogical = objdumpProcessor.getAddressAfter( last.address );

      if ( !ReadUntilFound( logFile, QEMU_LOG_IN_KEY ) ) {
        done = true;
        nextExecuted = last;
      } else {
        logFile >> std::hex >> nextExecuted.address >> std::dec
                >> ignore
                >> nextExecuted.instruction
                >> nextExecuted.data;

        if ( logFile.fail() ) {
          std::cerr << "Error Unable to Read First Block" << std::endl;
        }
      }

      // If the nextlogical was not found we are throwing away
      // the block; otherwise add the block to the trace list.
      if ( nextlogical != 0 ) {
        TraceList::exitReason_t reason = TraceList::EXIT_REASON_OTHER;

        if ( objdumpProcessor.IsBranch( last.instruction ) ) {
          if ( nextExecuted.address == nextlogical ) {
            reason = TraceList::EXIT_REASON_BRANCH_NOT_TAKEN;
          }  else {
            reason = TraceList::EXIT_REASON_BRANCH_TAKEN;
          }
        }
        Trace.add( first.address, nextlogical, reason );
      }
      first = nextExecuted;
    }

    return true;
  }
}