Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / hypervisor / src / support / mdgen / mdmain.c

/*
* ========== Copyright Header Begin ==========================================
*
* Hypervisor Software File: mdmain.c
* 
* Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
* 
*  - Do no alter or remove copyright notices
* 
*  - Redistribution and use of this software in source and binary forms, with 
*    or without modification, are permitted provided that the following 
*    conditions are met: 
* 
*  - Redistribution of source code must retain the above copyright notice, 
*    this list of conditions and the following disclaimer.
* 
*  - Redistribution 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 Sun Microsystems, Inc. or the names of contributors 
* may be used to endorse or promote products derived from this software 
* without specific prior written permission. 
* 
*     This software is provided "AS IS," without a warranty of any kind. 
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, 
* INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A 
* PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN 
* MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR 
* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR 
* DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN 
* OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR 
* FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE 
* DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, 
* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF 
* SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* 
* You acknowledge that this software is not designed, licensed or
* intended for use in the design, construction, operation or maintenance of
* any nuclear facility. 
* 
* ========== Copyright Header End ============================================
*/
/*
 * Copyright 2007 Sun Microsystems, Inc.	 All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"@(#)mdmain.c	1.3	07/06/07 SMI"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <ctype.h>
#include <strings.h>

#include <md/md_impl.h>

#include "basics.h"
#include "allocate.h"
#include "fatal.h"
#include "lexer.h"

#include "dagtypes.h"
#include "outputtypes.h"


#define	DBGD(s)




extern void dt_write_hdr(FILE *fd, char *name, md_hdr_t *root);

extern void parse_dag(char *fnamep, FILE *fp);
void stichin_reqd_properties(void);
void connect_dag(void);
#if ENABLE_PROTO /* { */
void delete_protos(void);
#endif		/* } */


enum {
	Out_binary, Out_text, Out_dot
} output_type;
char *output_dot_dagp;
bool_t output_dot_flag_none = false;

bool_t flag_verbose = false;


dag_node_t *dag_listp = NULL;
dag_node_t *dag_list_endp = NULL;




int
main(int argc, char **argv)
{
	int i;
	char *fnamep;
	FILE *fp;
	char *outfnp;	/* output filename */

	output_type = Out_binary;

	for (i = 1; i < argc && argv[i][0] == '-'; i++) {
		if (strcmp(argv[i], "-h") == 0 ||
		    strcmp(argv[i], "--help") == 0) {
			fprintf(stderr, "usage: %s "
			    "[--text|--binary|--header|--dot <arc>"
			    "|-t|-b|-H|--d <arc>] [--outfile <fname>]"
			    " <filename>\n", argv[0]);
			fprintf(stderr,
			    "\t--help         : this message\n"
			    "\t-b | --binary  : write binary file (default)\n"
			    "\t-o | --outfile : output file (default=stdout)\n"
			    "\t-t | --text    : rewrite as text\n"
			    "\t-d | --dot     :"
			    " output in dot format using arcs\n"
			    "\t\t-n | --noprop :"
			    "  Omit properties in dot format\n"
			    "\t-v | --verbose : be loquacious\n");
			exit(0);
		} else
		if ((strcmp(argv[i], "-b") == 0) ||
		    (strcmp(argv[i], "--binary") == 0)) {
			output_type = Out_binary;
			continue;
		}
		if ((strcmp(argv[i], "-t") == 0) ||
		    (strcmp(argv[i], "--text") == 0)) {
			output_type = Out_text;
			continue;
		} else
		if ((strcmp(argv[i], "-d") == 0) ||
		    (strcmp(argv[i], "--dot") == 0)) {
			output_type = Out_dot;
			output_dot_dagp = argv[++i];
			continue;
		} else
		if ((strcmp(argv[i], "-n") == 0) ||
		    (strcmp(argv[i], "--noprop") == 0)) {
			if (output_type != Out_dot) {
				fprintf(stderr, "Need to specify dot output \
format before -n/--noprop\n");
				exit(1);
			}
			output_dot_flag_none = true;
			continue;
		} else
		if ((strcmp(argv[i], "-v") == 0) ||
		    (strcmp(argv[i], "--verbose") == 0)) {
			flag_verbose = true;
			continue;
		} else
		if (strcmp(argv[i], "-o") == 0 ||
		    strcmp(argv[i], "--outfile") == 0) {
			outfnp = argv[++i];
		} else
		if (argv[i][1] == 'o' && argv[i][2] != '\0') {
			outfnp = &argv[i][2];
		} else
		fatal("Unrecognised option %s\n", argv[i]);
	}

	if ((argc - i) != 1)
		fatal("Input filename name expected");

	fnamep = argv[i];

	fp = fopen(fnamep, "r");
	if (fp == NULL)
		fatal("Cannot open input file %s", fnamep);

	parse_dag(fnamep, fp);
	fclose(fp);

#if ENABLE_PROTO /* { */
		/* remove prototypes after parse phase */
	delete_protos();
	DBGD(dump_dag_nodes(stderr));
#endif		/* } */

	DBGD(dump_dag_nodes(stderr));

	connect_dag();

	stichin_reqd_properties();

	DBGD(dump_dag_nodes(stderr));

	validate_dag();

	if (outfnp != NULL) {
		fp = fopen(outfnp, "w");
		if (fp == NULL) fatal("Opening %s for output", outfnp);
	} else {
		fp = stdout;
	}

	switch (output_type) {
	case Out_binary:
		output_bin(fp);
		break;

	case Out_text:
		output_text(fp);
		break;

	case Out_dot:
		output_dot(fp);
		break;
	}
	fclose(fp);

	return (0);
}






void
validate_dag()
{
	/* no validation just yet */
}







dag_node_t *
new_dag_node(void)
{
	dag_node_t *dnp;

	dnp = Xcalloc(1, dag_node_t);

	dnp->typep = NULL;
	dnp->namep = NULL;
#if ENABLE_PROTOTYPES
	dnp->is_proto = false;
#endif

	dnp->properties.num = 0;
	dnp->properties.space = 0;
	dnp->properties.listp = NULL;

		/* add to list */
	dnp->prevp = dag_list_endp;
	dnp->nextp = NULL;
	if (NULL == dag_listp) {
		dag_listp = dnp;
	} else {
		dag_list_endp->nextp = dnp;
	}
	dag_list_endp = dnp;

	return (dnp);
}


pair_entry_t *
add_pair_entry(pair_list_t *plp)
{
	pair_entry_t *pep;

	if (plp->num >= plp->space) {
		plp->space = plp->num + 5;
		plp->listp = Xrealloc(plp->listp,
		    plp->space * sizeof (plp->listp[0]));
	}

	pep = &(plp->listp[plp->num]);
	plp->num++;

	pep->namep = NULL;
	pep->utype = PE_none;
	pep->u.val = 0;
	pep->u.data.len = 0;
	return (pep);
}


pair_entry_t *
find_pair_by_name(pair_list_t *plp, char *namep)
{
	pair_entry_t *pep;
	int i;

	for (i = 0; i < plp->num; i++) {
		pep = &(plp->listp[i]);
		if (strcmp(pep->namep, namep) == 0)
			return (pep);
	}

	return (NULL);
}

dag_node_t *
find_dag_node_by_type(char *namep)
{
	dag_node_t *dnp;

	for (dnp = dag_listp; dnp != NULL; dnp = dnp->nextp) {
		if (strcmp(dnp->typep, namep) == 0)
			return (dnp);
	}

	return (NULL);
}

dag_node_t *
find_dag_node_by_name(char *namep)
{
	dag_node_t *dnp;

	for (dnp = dag_listp; dnp != NULL; dnp = dnp->nextp) {
		if (strcmp(dnp->namep, namep) == 0)
			return (dnp);
	}

	return (NULL);
}

dag_node_t *
grab_node(char *message)
{
	lexer_tok_t tok;
	dag_node_t *dnp = NULL;

	tok = lex_get_token();
	if (tok == T_Token) {
		dnp = find_dag_node_by_name(lex.strp);
		if (dnp == NULL) {
			lex_fatal("%s: %s", message, lex.strp);
		}
	} else {
		lex_fatal("%s: %s", message, lex.strp);
	}
	return (dnp);
}

pair_entry_t *
grab_prop(char *message, dag_node_t *node)
{
	lexer_tok_t tok;
	pair_entry_t *prop = NULL;

	tok = lex_get_token();
	if (tok == T_Token) {
		prop = find_pair_by_name(&node->properties, lex.strp);
		if (prop == NULL) {
			lex_fatal("%s: %s property must exist\n",
			    message, lex.strp);
		}
	} else {
		lex_fatal("%s: %s", message, lex.strp);
	}
	return (prop);
}


void
dump_dag_nodes(FILE *fp)
{
	dag_node_t *dnp;

	for (dnp = dag_listp; dnp != NULL; dnp = dnp->nextp) {
		int i;
		pair_entry_t *pep;

#if ENABLE_PROTO	/* { */
		fprintf(fp, "node %s%s %s {\n", dnp->is_proto ? " proto" : "",
		    dnp->typep, dnp->namep);
#else			/* } { */
		fprintf(fp, "node %s %s {\n", dnp->typep, dnp->namep);
#endif			/* } */

		pep = dnp->properties.listp;
		for (i = 0; i < dnp->properties.num; i++) {
			switch (pep->utype) {
			case PE_none:
				fprintf(fp, "\n");
				break;
			case PE_string:
				fprintf(fp, "\t%s = \"%s\";\n", pep->namep,
				    pep->u.strp);
				break;
			case PE_int:
				fprintf(fp, "\t%s = 0x%llx;\n", pep->namep,
				    pep->u.val);
				break;
			case PE_arc:
				fprintf(fp, "\t%s -> %s;\n", pep->namep,
				    pep->u.dnp->namep);
				break;
			case PE_noderef:
				fprintf(fp, "\t%s -> %s;\n", pep->namep,
				    pep->u.strp);
				break;
			case PE_data:
				fprintf(fp, "\t%s = XXXXXXXX;\n", pep->namep);
				break;
			default:
				fprintf(stderr, "%s:%d: Bad Encoding.. %d\n",
				    __FILE__, __LINE__, pep->utype);
				exit(1);
			}
			pep ++;
		}

		fprintf(fp, "}\n");
		fflush(fp);
	}
}

#if ENABLE_PROTO /* { */
void
free_node(dag_node_t *dnp)
{
	int i;

	for (i = 0; i < dnp->properties.num; i++) {
		pair_entry_t *pep;

		pep = &(dnp->properties.listp[i]);

		switch (pep->utype) {
		case PE_none:
			fatal("free_node: node %s : %d : PE_none element",
			    dnp->namep, i);
		case PE_arc:
			fatal("free_node: node %s : %d : PE_arc element",
			    dnp->namep, i);
		case PE_int:
		case PE_data:
			break;
		case PE_string:
		case PE_noderef:
			Xfree(pep->u.strp);
			break;
		default:
			fatal("free_node: node %s : %d : unknown type %d",
			    dnp->namep, i, pep->utype);
		}
	}

	Xfree(dnp->properties.listp);
	Xfree(dnp);
}


void
delete_protos(void)
{
	bool_t failed;
	dag_node_t *dnp;
	dag_node_t **pp;

	pp = &dag_listp;
	dnp = *pp;

	while (dnp != NULL) {
		dag_node_t *nextp;

		nextp = dnp->nextp;

		if (dnp->is_proto) {
			free_node(dnp);
		} else {
			*pp = dnp;
			pp = &(dnp->nextp);
		}
		dnp = nextp;
	}

	*pp = NULL;

}
#endif		/* } */

void
connect_dag(void)
{
	bool_t failed;
	dag_node_t *dnp;
	FILE *errfp = stderr;
	int idx;

	failed = false;

	idx = 0;
	for (dnp = dag_listp; dnp != NULL; dnp = dnp->nextp, idx++) {
		int i;

		/* Give this node an id number */
		dnp->idx = idx;

		/* stitch all property node references */
		if (dnp->properties.num > 0) {
			for (i = 0; i < dnp->properties.num; i++) {
				pair_entry_t *pep;

				pep = &(dnp->properties.listp[i]);

				if (pep->utype == PE_noderef) {
					dag_node_t *rnp;
					rnp = find_dag_node_by_name(
					    pep->u.strp);
					if (NULL != rnp) {
						Xfree(pep->u.strp);
						pep->u.dnp = rnp;
						pep->utype = PE_arc;
					} else {
						failed = true;
						fprintf(errfp, "Referenced "
						    "node %s not found\n",
						    pep->u.strp);
					}
				}
			}
		}
	}

	if (failed)
		goto failed;
	return;

failed:;
	fatal("errors found");
}


/*
 * We must have a "root" node ... look for it,
 * and hike it to the first entry in the table.
 */
void
stichin_reqd_properties(void)
{
	dag_node_t *dnp;

	dnp = find_dag_node_by_type("root");
	if (dnp == NULL)
		fatal("A root node is required for a valid description");

	/*
	 * Hike the root node to be the first element.
	 */
	if (dnp->prevp != NULL) {
		dnp->prevp->nextp = dnp->nextp;
		if (dnp->nextp != NULL) {
			dnp->nextp->prevp = dnp->prevp;
		} else {
			dag_list_endp = dnp->prevp;
		}

		dnp->nextp = dag_listp;
		dag_listp->prevp = dnp;
		dag_listp = dnp;
	}
}