path: root/covoar/GcovData.cc

/*
 *  TODO: use strings instead of cstrings for reliability and saving memory
 *  TODO: use global buffers
 *
 */

/*! @file GcovData.cc
 *  @brief GcovData Implementation
 *
 *  This file contains the implementation of the functions supporting
 *  reading *.gcno and writing *.gcda files for gcov support
 */

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

//#include "app_common.h"
#include "GcovData.h"
//#include "ExecutableInfo.h"
//#include "CoverageMap.h"
//#include "qemu-traces.h"


namespace Gcov {

  GcovData::GcovData()
  {
	  	numberOfFunctions = 0;
  }

  GcovData::~GcovData()
  {
  }

  bool GcovData::readGcnoFile( const char* const  fileName )
  {
    int                 status;
    FILE*               gcovFile;
    char*		tempString;
    char*		tempString2;
    char*		tempString3;

    if ( strlen(fileName) >= FILE_NAME_LENGTH ){
      fprintf(
        stderr,
        "ERROR: File name is too long to be correctly stored: %u\n",
        (unsigned int) strlen(fileName)
      );
      return false;
    }
    strcpy( gcnoFileName, fileName );
    strcpy( gcdaFileName, fileName );
    strcpy( textFileName, fileName );
    strcpy( cFileName, fileName );
    tempString = strstr( gcdaFileName,".gcno" );
    tempString2 = strstr( textFileName,".gcno" );
    tempString3 = strstr( cFileName,".gcno" );

    if ( (tempString == NULL) && (tempString2 == NULL) ){
      fprintf(stderr, "ERROR: incorrect name of *.gcno file\n");
    } 
    else
    {
      strcpy( tempString, ".gcda");		// construct gcda file name
      strcpy( tempString2, ".txt");		// construct report file name
      strcpy( tempString3, ".c");		// construct source file name
    }

    // Debug message
    // fprintf( stderr, "Readning file: %s\n",  gcnoFileName);

    // Open the notes file.
    gcovFile = fopen( gcnoFileName, "r" );
    if ( !gcovFile ) {
    	fprintf( stderr, "Unable to open %s\n", gcnoFileName );
    	return false;
    }

    // Read and validate the gcnoPreamble (magic, version, timestamp) from the file
    status = readFilePreamble( &gcnoPreamble, gcovFile, GCNO_MAGIC );
    if ( status <= 0 ){
    	fprintf( stderr, "Unable to read %s\n", gcnoFileName );
	fclose( gcovFile );
    	return false;
    }

    //Read all remaining frames from file
    while( readFrame(gcovFile) ){}

    fclose( gcovFile );
    return true;
  }


  bool GcovData::writeGcdaFile ()
  {
	  gcov_preamble 		preamble;
	  gcov_frame_header		header;
	  FILE*				gcdaFile;
	  functions_iterator_t	currentFunction;
	  arcs_iterator_t		currentArc;
	  uint32_t			buffer;
	  uint32_t			countersFound;
	  uint32_t			countersFoundSum;
	  uint64_t			countersSum;
	  uint64_t			countersMax;
	  uint64_t			llBuffer[4096];		// TODO: Use common buffer
	  gcov_statistics		objectStats;
	  gcov_statistics		programStats;
	  size_t			status;

	  // Debug message
	  // fprintf( stderr, "Writing file: %s\n",  gcdaFileName);

	  // Lets clear counters sumators
	  countersSum 		= 0;
	  countersMax 		= 0;
	  countersFoundSum 	= 0;

	  // Open the data file.
	  gcdaFile = fopen( gcdaFileName, "w" );
	  if ( !gcdaFile ) {
		  fprintf( stderr, "Unable to create %s\n", gcdaFileName );
		  return false;
	  }

	  //Form preamble
	  preamble.magic	= GCDA_MAGIC;
	  preamble.version	= gcnoPreamble.version;
	  preamble.timestamp	= gcnoPreamble.timestamp;

	  //Write preamble
	  status = fwrite (&preamble , sizeof( preamble ), 1 , gcdaFile );
	  if ( status != 1 )
            fprintf( stderr, "Error while writing gcda preamble to a file %s\n", gcdaFileName );

	  //Write function info and counter counts
	  for (
			  currentFunction = functions.begin();
			  currentFunction != functions.end();
			  currentFunction++
	  )
	  {
		  //Write function announcement frame header (length always equals 2)
		  header.tag = GCOV_TAG_FUNCTION;
		  header.length = 2;
		  status = fwrite (&header, sizeof(header), 1, gcdaFile );
	          if ( status != 1 )
                    fprintf( stderr, "Error while writing function announcement to a file %s\n", gcdaFileName );

		  //Write function id
		  buffer = (*currentFunction)->getId();
		  status = fwrite (&buffer, sizeof( buffer ), 1, gcdaFile );
	          if ( status != 1 )
                    fprintf( stderr, "Error while writing function id to a file %s\n", gcdaFileName );

		  //Write function checksum
		  buffer = (*currentFunction)->getChecksum();
		  status = fwrite (&buffer, sizeof( buffer ), 1, gcdaFile );
	          if ( status != 1 )
                    fprintf( stderr, "Error while writing function checksum to a file %s\n", gcdaFileName );

		  // Determine how many counters there are
		  // and store their counts in buffer
		  countersFound = 0;
		  (*currentFunction)->getCounters( llBuffer, countersFound, countersSum, countersMax );
		  countersFoundSum += countersFound;

		  //Write info about counters
		  header.tag = GCOV_TAG_COUNTER;
		  header.length = countersFound * 2;
		  status = fwrite (&header, sizeof( header ), 1, gcdaFile );
	          if ( status != 1 )
                    fprintf( stderr, "Error while writing counter header to a file %s\n", gcdaFileName );

		  status = fwrite (llBuffer, sizeof( uint64_t ), countersFound , gcdaFile );
	          if ( status != countersFound )
                    fprintf( stderr, "Error while writing counter data to a file %s\n", gcdaFileName );
	  }

	  // Prepare frame with object file statistics
	  header.tag = GCOV_TAG_OBJECT_SUMMARY;
	  header.length = 9;
	  objectStats.checksum = 0;			// TODO: have no idea hov to calculates it :)
	  objectStats.counters = countersFoundSum;
	  objectStats.runs = 1;				// We are lying for now, we have no means of figuring this out
	  objectStats.sum = countersSum;		// Sum of all counters
	  objectStats.max = countersMax;		// max value for counter on last run, we have no clue
	  objectStats.sumMax = countersMax;		// we have no clue

	  // Write data
	  status = fwrite (&header, sizeof( header ), 1, gcdaFile );
	  if ( status != 1 )
            fprintf( stderr, "Error while writing stats header to a file %s\n", gcdaFileName );
	  status = fwrite (&objectStats, sizeof( objectStats ), 1, gcdaFile );
	  if ( status != 1 )
            fprintf( stderr, "Error while writing object stats to a file %s\n", gcdaFileName );


	  // Prepare frame with program statistics
	  header.tag = GCOV_TAG_PROGRAM_SUMMARY;
	  header.length = 9;
	  programStats.checksum = 0;			// TODO: have no idea hov to calculate it :)
	  programStats.counters = countersFoundSum;
	  programStats.runs = 1;			// We are lying for now, we have no clue
	  programStats.sum = countersSum;		// Sum of all counters
	  programStats.max = countersMax;		// max value for counter on last run, we have no clue
	  programStats.sumMax = countersMax;		// we have no clue

	  // Write data
	  status = fwrite (&header, sizeof( header ), 1, gcdaFile );
	  if ( status != 1 )
            fprintf( stderr, "Error while writing stats header to a file %s\n", gcdaFileName );
	  status = fwrite (&programStats, sizeof( programStats ), 1, gcdaFile );
	  if ( status != 1 )
            fprintf( stderr, "Error while writing program stats to a file %s\n", gcdaFileName );

	  fclose( gcdaFile );

	  return true;
  }

  bool GcovData::readFrame(
	       FILE*         gcovFile
   )
  {
	    gcov_frame_header 	header;
	    char 		buffer[512];
	    uint32_t            intBuffer[4096];
	    uint32_t            tempBlockId;
	    blocks_iterator_t	tempBlockIterator;
	    int                 status;
	    GcovFunctionData*	newFunction;

	    status = readFrameHeader( &header, gcovFile);

	    if ( status <= 0 ){
                // Not printing error message because this 
		// happenns at the end of each file
	    	return false;
	    }

	    switch (header.tag){

			case GCOV_TAG_FUNCTION:

				numberOfFunctions++;
				newFunction = new GcovFunctionData;
				if ( !readFunctionFrame(header, gcovFile, newFunction) ){
					fprintf( stderr, "Error while reading FUNCTION from gcov file...\n" );
					return false;
				}
				functions.push_back(newFunction);
				break;

			case GCOV_TAG_BLOCKS:

				status = fread( &intBuffer, 4, header.length, gcovFile );
				if ( status != (int) header.length){
					fprintf( 
						stderr, "Error while reading BLOCKS from gcov file...\n"
						"Header lenght is %u instead of %u\n", 
						header.length, 
						status 
					);
					return false;
				}

				for( uint32_t i = 0; i < header.length; i++ )
					functions.back()->addBlock(i, intBuffer[i], "");

				break;

			case GCOV_TAG_ARCS:

				status = fread( &intBuffer, 4, header.length, gcovFile );
				if (status != (int) header.length){
					return false;
				}

				for ( int i = 1; i < (int) header.length; i += 2 )
					functions.back()->addArc(intBuffer[0], intBuffer[i], intBuffer[i+1]);

				break;

			case GCOV_TAG_LINES:

				status = fread( &intBuffer, 4, 2, gcovFile );
				if (status != 2 || intBuffer[1] != 0){
					fprintf(
						stderr,
						"Error while reading block id for LINES from gcov file..."
					);
					return false;
				}
				tempBlockId = intBuffer[0];
				header.length -= 2;

				// Find the right block
				tempBlockIterator =functions.back()->findBlockById(tempBlockId);

				header.length -= readString(buffer, gcovFile);
				functions.back()->setBlockFileName( tempBlockIterator, buffer );

				status = fread( &intBuffer, 4, header.length, gcovFile );
				if (status != (int) header.length){
					fprintf( stderr, "Error while reading LINES from gcov file..." );
					return false;
				}

				else
					for (int i = 0; i < (int) (header.length - 2); i++)
						functions.back()->addBlockLine( tempBlockIterator, intBuffer[i] );

				break;

			default:

				fprintf( stderr, "\n\nERROR - encountered unknown *.gcno tag : 0x%x\n", header.tag );
				break;
	    }

	    return true;
  }

  int GcovData::readString(
		   char*		 buffer,   //TODO: use global buffer here
	       FILE*         gcovFile
  )
  {
	    int					status;
	    int					length;

	    status = fread( &length, sizeof(int), 1, gcovFile );
	    if (status != 1){
              fprintf( stderr, "ERROR: Unable to read string length from gcov file\n" );
	      return -1;
            }

	    status = fread( buffer, length * 4 , 1, gcovFile );
	    if (status != 1){
              fprintf( stderr, "ERROR: Unable to read string from gcov file\n" );
	      return -1;
            }

	    buffer[length * 4] = '\0';

	    return length +1;
  }

  int GcovData::readFrameHeader(
	       gcov_frame_header* 	header,
	       FILE*         		gcovFile
   )
  {
	    int					status;
	    int					length;

	    length = sizeof(gcov_frame_header);
	    status = fread( header, length, 1, gcovFile );
	    if (status != 1){
		//fprintf( stderr, "ERROR: Unable to read frame header from gcov file\n" );
	    	return -1;
	    }

	    return length / 4;
  }

  int GcovData::readFilePreamble(
  	   gcov_preamble* 	    preamble,
	   FILE*         		gcovFile,
	   uint32_t				desiredMagic
  )
  {
	    int					status;
	    int					length;

	    length = sizeof( gcov_preamble );
	    status = fread( preamble, sizeof( gcov_preamble), 1, gcovFile );
	    if (status <= 0) {
	      fprintf( stderr, "Error while reading file preamble\n" );
	      return -1;
	    }

	    if ( preamble->magic != GCNO_MAGIC ) {
	      fprintf( stderr, "File is not a valid *.gcno output (magic: 0x%4x)\n", preamble->magic );
	      return -1;
	    }

	    return length / 4;
  }

  bool GcovData::readFunctionFrame(
	   gcov_frame_header 	header,
	   FILE*         	gcovFile,
	   GcovFunctionData*	function
  )
  {
	  char 		    buffer[512];		//TODO: use common buffers
	  uint32_t          intBuffer[4096];
	  int               status;

	  status = fread( &intBuffer, 8, 1, gcovFile );
	  if (status != 1){
		fprintf( stderr, "ERROR: Unable to read Function ID & checksum\n" );
	  	return false;
	  }
	  header.length -= 2;
	  function->setId( intBuffer[0] );
	  function->setChecksum( intBuffer[1] );

	  header.length -= readString( buffer, gcovFile );
	  function->setFunctionName( buffer );
	  header.length -= readString( buffer, gcovFile );
	  function->setFileName( buffer );
	  status = fread( &intBuffer, 4, header.length, gcovFile );
	  if (status <= 0){
		fprintf( stderr, "ERROR: Unable to read Function starting line number\n" );
	  	return false;
	  }
	  function->setFirstLineNumber( intBuffer[0] );

	  return true;
  }

  bool GcovData::writeReportFile()
  {
	  functions_iterator_t 		currentFunction;
	  uint32_t			i = 1;					//iterator
	  FILE*				textFile;

	  // Debug message
	  // fprintf( stderr, "Writing file: %s\n",  textFileName);

        // Open the data file.
        textFile = fopen( textFileName, "w" );
	if ( !textFile ) {
	  fprintf( stderr, "Unable to create %s\n", textFileName );
	  return false;
	}

	printGcnoFileInfo( textFile );

	for (
			currentFunction = functions.begin();
			currentFunction != functions.end();
			currentFunction++
		)
	{
		(*currentFunction)->printFunctionInfo( textFile, i );
                (*currentFunction)->printCoverageInfo( textFile, i );
		i++;
	}

	fclose ( textFile );
	return true;
  }

  void GcovData::printGcnoFileInfo( FILE * textFile )
  {
      fprintf(
        textFile,
        "\nFILE:\t\t\t%s\n"
        "magic:\t\t\t%x\n"
        "version:\t\t%x\n"
        "timestamp:\t\t%x\n"
        "functions found: \t%u\n\n",
        gcnoFileName,
        gcnoPreamble.magic,
        gcnoPreamble.version,
        gcnoPreamble.timestamp,
        numberOfFunctions
      );
  }

  void GcovData::writeGcovFile( )
  {
    char        path[512];
    char        command[512];

    //fprintf (stderr, "Attempting to run gcov for: %s\n", cFileName );
    strcpy( path, cFileName );
    dirname( path );
    sprintf( command, "( cd %s && gcov %s &>> gcov.log)", path, basename( cFileName ) );
    //fprintf (stderr, "> %s\n", command );
    system( command );
  }

  bool GcovData::processCounters(  )
  {
    functions_iterator_t 	currentFunction;
    bool			status = true;
    for (
      currentFunction = functions.begin();
      currentFunction != functions.end();
      currentFunction++
    )
    {
      if ( !(*currentFunction)->processFunctionCounters(  ) )
        status = false;
    }

    return status;
  }
}