Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / system / util / fileutil.cc

// ========== Copyright Header Begin ==========================================
// 
// OpenSPARC T2 Processor File: fileutil.cc
// 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 ============================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>		// gid_t
#include <sys/stat.h>		// gid_t
#include <unistd.h>		// getuid
#include <errno.h>
#include <signal.h>

#include <sys/wait.h>
#include <stdarg.h>

#include "types.h"
#include "fileutil.h"

#pragma ident "@(#)1.12	06/05/22	fileutil.cc"

static char buff[256];


#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

typedef void (*sigfunc_t)(int);

#ifdef __cplusplus
}
#endif /* __cplusplus */

/* 
 * This routine is used to perform a waitpid() call that will work.
 * It disables the SIGCHLD signal handler (used by window command)
 * before the waitpid() and then restores it.
 */
int
fw_waitpid(pid_t pid, int* statusp, int options)
{
	pid_t		w;
	/* static void     (*sigchld_func)(int); */
	sigfunc_t sigchld_func;

	/*
	 * Set handling of sigchld to default (ignored) -- needed because we 
	 * call waitpid() below.
 	 */
	sigchld_func = signal(SIGCHLD, SIG_DFL);

	/* Wait for child to die. */
	w = waitpid(pid, statusp, options);

	/* Restore sigchld handling. */
	signal(SIGCHLD, sigchld_func);

	return w;
}

/* A safe interface for the wait() routine. */
int
fw_wait(int* statusp)
{
	pid_t		w;
	/* void (*sigchld_func)(int); */
	sigfunc_t sigchld_func;

	/* Set handling of sigchld to default (ignored) -- needed because we
	 * call waitpid() below.
   	 */
	sigchld_func = signal(SIGCHLD, SIG_DFL);

	/* Wait for child to die. */
	w = wait(statusp);

	/* Restore sigchld handling. */
	signal(SIGCHLD, sigchld_func);

	return w;
}


/*
 * This routine executes the specified UNIX command and examines the status.
 * If the command passed, 0 is returned, otherwise 1.
 */
int
system_command(char* cmd)
{
	int		status;
	pid_t		pid;
	pid_t		w;

#if 0
	int             tty_flags;
#endif

	/*
	 * Put the tty into blocking mode.  This also stops the simulator from
	 * handling SIGIO signals until it gets back into non-blocking
	 * mode.
	 */

#if 0   ////////   TODO

	tty_flags = sigio_make_tty_blocking();
#endif

	if ((pid = fork()) == 0) {
		(void) execl("/bin/sh", "sh", "-c", cmd, NULL);
		_exit(127);
	}

	if (pid == -1) {

#if 0 //// TODO
		/* Restore the tty mode. */
		sigio_set_tty_flags(tty_flags);
#endif
		printf("Fork for UNIX command %s failed.\n", cmd);
		perror("fork");

		return 1;
	}

	/* Wait for child to die. */
	w = fw_waitpid(pid, &status, 0);

#if 0  ///// TODO
	/* Restore the tty mode. */
	sigio_set_tty_flags(tty_flags);
#endif

	if (w == -1) {
		if (errno == ECHILD) {
			printf("Child did not exist for UNIX command %s.\n", cmd);
		}

		perror("waitpid");
		return 1;
	}

	if (WIFSTOPPED(status)) {
		printf("UNIX command %s stopped by signal %d.\n",
		    cmd, WSTOPSIG(status));
		printf("May not be enough memory.\n");
		return 1;
	}

	if (WIFSIGNALED(status)) {
		printf("UNIX command %s terminated by signal %d.\n",
		    cmd, WTERMSIG(status));
		return 1;
	}

	if (WIFEXITED(status)) {
		if (WEXITSTATUS(status)) {
			return 1;
		}

		return 0;
	}

	/* Command didn't call exit() so assume it failed. */
	return 1;
}



FILE *fopen_dir_path(const char *dir, const char *a, const char *b,
		     const char *mode)
{
	if (b != NULL) {
		sprintf(buff, "%s%s%s", dir, a, b);
	} else {
		sprintf(buff, "%s%s", dir, a);
	}
	{
		FILE *f = fopen(buff, mode);
		if (f == NULL) {
			perror(buff);
		}
		return f;
	}
}				/* fopen_dir_path */

FILE *fopen_as_uid(const char *filename, const char *mode)
{
	int uid = getuid();
	FILE *fp = fopen(filename, mode);
	if (fp == NULL) {
		perror(filename);
	} else {
		if (*mode == 'w') {	// change owner if writing a file
			int fd = fileno(fp);
			fchown(fd, uid, -1);	// change owner to the actual user
		}
	}
	return fp;
}

// just a template for defining other fns
static int statTest(const char *dirname)
{
	struct stat statbuf;
	int status = stat(dirname, &statbuf);
	if (status == 0) {
		int reg = (S_ISREG(statbuf.st_mode));
		int fifo = (S_ISFIFO(statbuf.st_mode));
		int chr = (S_ISCHR(statbuf.st_mode));
		int dir = (S_ISDIR(statbuf.st_mode));
		int blk = (S_ISBLK(statbuf.st_mode));
		int lnk = (S_ISLNK(statbuf.st_mode));
	}
	return 0;
}				/* statTest */

int isDir(const char *dirname)
{
	struct stat statbuf;
	int status = stat(dirname, &statbuf);
	if (status == 0) {
		int dir = (S_ISDIR(statbuf.st_mode));
		return dir;
	}
	return 0;
}

int isFile(const char *filename)
{
	struct stat statbuf;
	int status = stat(filename, &statbuf);
	if (status == 0) {
		int reg = (S_ISREG(statbuf.st_mode));
		return reg;
	}
	return 0;
}

int fileExists(const char *filename)
{
	struct stat statbuf;
	int status = stat(filename, &statbuf);
	return (status == 0) || (errno != ENOENT);
}				/* fileExists */


/////////////////////////////////////////////////////////////////

void write_double (FILE *fp, const char * name, double v)
{
        fprintf (fp, "%s          %f\n", name, v);
}


void write_scalar_64 (FILE *fp, const char * name, uint64_t v)
{
        fprintf (fp, "%s          0x%llx\n", name, v);
}

void write_scalar_2_64 (FILE *fp, const char * name, uint64_t v1, uint64_t v2)
{
        fprintf (fp, "%s    2\n", name);
        fprintf (fp, "       0x%llx\n ", v1);
        fprintf (fp, "       0x%llx\n", v2);
}

void write_scalar_32 (FILE *fp, const char * name, uint32_t v)
{
        fprintf (fp, "%s          0x%x\n", name, v);
}

void write_scalar_8 (FILE *fp, const char * name, uint8_t v)
{
        fprintf (fp, "%s          0x%x\n", name, v);
}


void write_string (FILE *fp, const char * name, char *s)
{
        fprintf (fp, "%s         \"%s\"\n", name, s);
}

void write_vector_64 (FILE *fp, const char * name, int n, uint64_t *v) 
{
        int i;
	fprintf (fp, "%s   %d\n", name, n);
        for (i = 0; i < n; i++) {
	    fprintf (fp, " 0x%llx\n", v[i]);
        }
}

void write_vector_32 (FILE *fp, const char * name, int n, uint32_t *v) 
{
        int i;
	fprintf (fp, "%s   %d\n", name, n);
        for (i = 0; i < n; i++) {
	    fprintf (fp, " 0x%x\n", v[i]);
        }
}

///////////////////

void dump_uint32(FILE * fp, uint32_t val)
{
	fwrite(&val, sizeof(uint32_t), 1, fp);
}

void dump_uint64(FILE * fp, uint64_t val)
{
	fwrite(&val, sizeof(uint64_t), 1, fp);
}

uint64_t restore_uint64(FILE * fp)
{
	uint64_t val;
	fread((void*)&val, sizeof(val), 1, fp);
	return val;
}

bool_t read_double (FILE *fp, const char * name, double *v)
{
        char s[128], sn[128];
        float ff;

        if (fgets (s, 128, fp) == NULL) {
	    return FALSE;
        }
        if (sscanf (s, "%s %f", sn, &ff) != 2) {
	    return FALSE;
        }
        *v = ff;
        if (strcmp(sn, name) != NULL) {
	    return FALSE;
        }
	return TRUE;
}


bool_t read_scalar_64 (FILE *fp, const char * name, uint64_t *v)
{
        char s[128], sn[128];

        if (fgets (s, 128, fp) == NULL) {
	    return FALSE;
        }

        if (sscanf (s, "%s %lli", sn, v) != 2) {
	    return FALSE;
        }
        if (strcmp(sn, name) != NULL) {
	    return FALSE;
        }
	return TRUE;
}

bool_t read_scalar_32 (FILE *fp, const char * name, uint32_t *v)
{
        char s[128], sn[128];

        if (fgets (s, 128, fp) == NULL) {
	    return FALSE;
        }

        if (sscanf (s, "%s %i", sn, v) != 2) {
	    return FALSE;
        }
        if (strcmp(sn, name) != NULL) {
	    return FALSE;
        }
	return TRUE;
}

bool_t read_scalar_8 (FILE *fp, const char * name, Byte *v)
{
        int i;
        char s[128], sn[128];

        if (fgets (s, 128, fp) == NULL) {
	    return FALSE;
        }

        if (sscanf (s, "%s %i", sn, &i) != 2) {
	    return FALSE;
        }
        if (strcmp(sn, name) != NULL) {
	    return FALSE;
        }
	*v = (Byte)i;
	return TRUE;
}

bool_t read_scalar_2_64 (FILE *fp, const char * name, uint64_t *v1, uint64_t *v2)
{

        int i;
        char s[128], sn[128];

        if (fgets (s, 128, fp) == NULL) {
	    return FALSE;
        }

        if (sscanf (s, "%s %i", sn, &i) != 2) {
	    return FALSE;
        }
        if (strcmp(sn, name) != NULL) {
	    return FALSE;
        }

        if (fgets (s, 128, fp) == NULL) {
	    return FALSE;
        }

        if (sscanf (s, "%lli", v1) != 1) {
	    return FALSE;
        }

        if (fgets (s, 128, fp) == NULL) {
	    return FALSE;
        }

        if (sscanf (s, "%lli", v2) != 1) {
	    return FALSE;
        }
        return TRUE;
}

/////////////////////////////////////////

char * read_string (FILE *fp, const char * name, int n, char *ss)
{
        int i = 0;
        char s[128], sn[128];

        char *ps = ss, *ps1, *ps2;

        if (fgets (s, 128, fp) == NULL)
	    return NULL;

        if (sscanf (s, "%s", sn) != 1) {
	    return NULL;
        }

        if (strcmp(sn, name) != NULL) {
	    fprintf (stderr, "restore err S = <%s>; pattern <%s>, %d\n", s, name, n);
	    return NULL;
        }

        ps1 = strchr (s, '"');
        ps2 = strrchr (s, '"');

        if ((ps1 == NULL) || (ps2 == NULL)) {
	    fprintf (stderr, "restore err <%s> \n", s);
	    return NULL;
        }
        ++ps1;
	for (;ps1 != ps2; ps1++, i++) {
	    if (i >= n)
	        break;
	    *ps++ = *ps1;
        }

        *ps = '\0';
        return ps;
}

char * read_string_2 (FILE *fp, const char * name, const char * alt_name, int n, char *ss)
{
        int i = 0;
        char s[128], sn[128];

        char *ps = ss, *ps1, *ps2;

        if (fgets (s, 128, fp) == NULL)
	    return NULL;

        if (sscanf (s, "%s", sn) != 1) {
	    return NULL;
        }

        if ((strcmp(sn, name) != NULL) && (strcmp(sn, alt_name) != NULL)) {
	    fprintf (stderr, "restore err S = <%s>; pattern <%s>, %d\n", s, name, n);
	    return NULL;
        }

        ps1 = strchr (s, '"');
        ps2 = strrchr (s, '"');

        if ((ps1 == NULL) || (ps2 == NULL)) {
	    fprintf (stderr, "restore err <%s> \n", s);
	    return NULL;
        }
        ++ps1;
	for (;ps1 != ps2; ps1++, i++) {
	    if (i >= n)
	        break;
	    *ps++ = *ps1;
        }

        *ps = '\0';
        return ps;
}


bool_t read_vector_64 (FILE *fp, const char * name, int n, uint64_t *v) 
{
        int i;
        char s[128], sn[128];
        if (fgets (s, 128, fp) == NULL)
	    return FALSE;

        if (sscanf (s, "%s %d", sn, &i) != 2) {
	    return FALSE;
        }

        if ((i != n) || (strcmp(sn, name) != NULL)) {
	    fprintf (stderr, "restore err S = <%s>; pattern <%s>, %d\n", s, name, n);
	    return FALSE;
        }

        for (i = 0; i < n; i++) {
	    if (fgets (s, 128, fp) == NULL)
	        return FALSE;
	    if (sscanf (s, "%lli", &v[i]) != 1) {
	        return FALSE;
	    }
        }
	return TRUE;
}

bool_t read_vector_32 (FILE *fp, const char * name, int n, uint32_t *v) 
{
        int i;
        char s[128], sn[128];
        if (fgets (s, 128, fp) == NULL)
	    return FALSE;

        if (sscanf (s, "%s %d", sn, &i) != 2) {
	    return FALSE;
        }

        if ((i != n) || (strcmp(sn, name) != NULL)) {
	    fprintf (stderr, "restore err S = <%s>; pattern <%s>, %d\n", s, name, n);
	    return FALSE;
        }

        for (i = 0; i < n; i++) {
	    if (fgets (s, 128, fp) == NULL)
	        return FALSE;
	    if (sscanf (s, "%i", &v[i]) != 1) {
	        return FALSE;
	    }
        }
	return TRUE;
}


///////////////////////////////////////////
// Thw following routines borrowed
// form BLAZE V3 without modifocation
//


/*
 * This routine converts a pointer into an array into its equivalent integer
 * index and then writes it to a file.  It handles null pointers.
 * Returns 1 on error, 0 no error.

 * Borrowed from Blaze v3 without changes
 *
 */
int dump_array_ptr (
	FILE*		fp,
	char*		array_base,
	u_int		element_size,
	char*		ptr
)
{
	char		is_ptr_null = 0;
	u_int		index = 0;

	if (ptr == NULL) {
		is_ptr_null = 1;
	} else {
		if (ptr < array_base) {
			/* Address of pointer is less than the base. */
			return 1;
		}

		index = ((u_int) (ptr - array_base)) / element_size;

		if (ptr != array_base + index * element_size) {
			/* 
			 * If reconstructing the address from the index
			 * doesn't give the original pointer value, return
			 * with and error.  This can happen when the pointer
			 * doesn't point to the start of an element.
			 */
			return 1;
		}
			
	}

	/* Write out flag that indicates if pointer is null. */
	if (fwrite((char*)&is_ptr_null, sizeof(is_ptr_null), 1, fp) != 1) {
		return 1;
	}

	/* Write out index (even if pointer is null). */
	if (fwrite((char*)&index, sizeof(index), 1, fp) != 1) {
		return 1;
	}

	return 0;
}

int restore_array_ptr (
	FILE*		fp,
	char*		array_base,
	u_int		element_size,
	char**		ptr
)
{
	char		is_ptr_null = 0;
	u_int		index = 0;

	/* Read in flag that indicates if pointer is null. */
	if (fread((char*)&is_ptr_null, sizeof(is_ptr_null), 1, fp) != 1) {
		return 1;
	}

	/* Read in index (even if pointer is null). */
	if (fread((char*)&index, sizeof(index), 1, fp) != 1) {
		return 1;
	}

	if (is_ptr_null) {
		*ptr = NULL;
	} else {
		*ptr = array_base + index * element_size;
	}

	return 0;
}


/*
 * Remove directory tree recursively by calling "rm -rf <dirname>".
 * It cannot return status since rm -f doesn't set it.
 */
void rm_rf_directory (char* dir_name)
{
	char		buf[FILENAME_MAX];
	sprintf(buf, "rm -rf %s", dir_name);
	system_command(buf);
}




//
// 32 vs 64 bit stuff
//
void print_addr (FILE *f, void *vp) {
#if HOST32BIT == 1
  fprintf (f, "0x%08x", vp);
#elif HOST64BIT == 1
  fprintf (f, "0x%016llx", vp);
#else
  printf ("Print_addr error: neither HOST32BIT nor HOST64BIT defined\n");
#endif
}


//
// DUMP FUNCTIONS
//

void dumpStructAddr (FILE *f, char *addr, const char *name, int size, int arrlen) {
  fprintf (f, "StructAddr %d %d ", size, arrlen);
  print_addr (f, addr);
  fprintf (f, " %s\n", name);
}


void dumpDynArrDelm (FILE *f, const char *name, int idx, int total) {
  fprintf (f, "DynArrDelm %d %d %s\n", idx, total, name);
}


void dumpScalar (FILE *f, const char *name, char *data, size_t size) {
  int i;
  
  fprintf (f, "%s %d 0x", name, size);
  for (i = 0; i < size; i++) {
    fprintf (f, "%02x", *(data + i) & 0xff);
  }
  fprintf (f, "\n");
  fflush(f);
}

void dumpArr (FILE *f, const char *name, unsigned char *data, size_t num, size_t size) {
  int i, j;

  for (i = 0; i < num; i++) {
    fprintf (f, "%s[%d] %d 0x", name, i, size);
    for (j = 0; j < size; j++) {
      fprintf (f, "%02x", *(data + size*i + j) & 0xff);
    }
    fprintf (f, "\n");
  }
}

///////////////////////////////////////////////

char *get_substr_until (char *src, char *tgt, char stop_symbol)
{
    char *ps = src, *pt = tgt;
    *pt = '\0';

    while (*ps == ' ') 
       ps++;
    
    if (*ps == '\0')
        return NULL;

    if (*ps == 0xA)
        return NULL;

    if ((*ps == '#') || (*ps == '!'))
        return NULL;

    while ((*ps != stop_symbol) && (*ps != ' ')) {
        *pt++ = *ps;
        ++ps;
    }

    *pt = '\0';
    if (*ps == stop_symbol) {
         return ps + 1;
    } 
    else {
        while ((*ps != stop_symbol) && (*ps != '\0')) {
	    ++ps;
	}
        if (*ps == '\0')
	    return ps;
        else
	    return ps + 1;
    }
}

///////////////////////////////////////////////

char * get_quoted_substr (char *src, char *tgt)
{
    char *ps = src, *pt = tgt;
    while (*ps == ' ') 
       ps++;
    
    if (*ps == '\0')
        return NULL;

    if (*ps == 0xA)
        return NULL;

    if ((*ps == '#') || (*ps == '!'))
        return NULL;

    if (*ps == '\"') {
       *pt = '\0';
    }
    else {
        return NULL;
    }
    ++ps;

    while (*ps != '\"') {
        *pt++ = *ps++;
        if (*ps == '\0')
	  return NULL;

    }

    *pt = '\0';
    return ps + 1;
}

///////////////////////////////////////////////
//
//  Microsecs --> cycles
//

uint64_t usec2cycles (uint64_t usecs, uint64_t sfreq, uint32_t loopticks)
{
     double tau = ((double)(1000000.0) / (double) sfreq) / (double) loopticks ; 
     return (uint64_t) ((double) usecs / tau);
}

///////////////////////////////////////////////

#define NNN 16

AddrPair * eval_mem_image (FILE *fp, int *ret_size)
{
     int       index = -1, len = NNN;
     char      s[512 + 4], *ps;
     uint64_t  v[4], pa;

     AddrPair *ppp = (AddrPair*) calloc (NNN, sizeof(AddrPair));
     if (ppp == NULL) {
         return NULL;
     }

     *ret_size = 0;

     while (fgets (s, 512, fp)) {
         if (s[0] == '\0') {
	     continue;
	 }
	 if (s[0] == '@') {      /// address
	     ps = &s[1];
	     int ret = sscanf (ps, "%llx",  &pa);
             if (ret != 1) {
	         goto error;
             }
             index++;
	     ppp[index].addr = pa;
	     ppp[index].size = 0;

	     if (index >= len - 1) {
                 len <<= 1;
	         ppp = (AddrPair*)realloc (ppp, sizeof(AddrPair) * len); 
	     }
	 }
	 else {
	    int ret = sscanf (s, "%llx %llx %llx %llx", &v[0], &v[1], &v[2], &v[3]);
	    if (ret != 4) {
	        ret = sscanf (s, "%llx %llx %llx", &v[0], &v[1], &v[2]);
		if (ret != 3) {
		    ret = sscanf (s, "%llx %llx", &v[0], &v[1]);
		    if (ret != 2) {
		        ret = sscanf (s, "%llx", &v[0]);
		        if (ret != 1) {
			    continue;
		        }
		    }
		}
	    }
            ppp[index].size += (ret<<3);
	 }
     }

     *ret_size = index + 1;
     return ppp;

error:

     free ((char*) ppp);
     return NULL;

}