/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1999 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <libintl.h>

#include "itmcomp.h"

struct itm_opt_outer *itm_op_outer = NULL;

#if defined(ENABLE_TRACE)
static char	*itmc_obj_names[] = {
	"ITMC_OBJ_NONE(0)",
	"ITMC_OBJ_ITM(1)",
	"ITMC_OBJ_STRING(2)",
	"ITMC_OBJ_DIREC(3)",
	"ITMC_OBJ_COND(4)",
	"ITMC_OBJ_MAP(5)",
	"ITMC_OBJ_OP(6)",
	"ITMC_OBJ_EXPR(7)",
	"ITMC_OBJ_DATA(8)",
	"ITMC_OBJ_ACTION(9)",
	"ITMC_OBJ_RANGE(10)",
	"ITMC_OBJ_RAGISTER(11)",
	"ITMC_OBJ_ESCAPESEQ(12)"
};
#endif

#define	TRACE_FMT(comment) \
comment ## " size=%4ld(0x%4lx); 64d=0x%16" PRIx64 "; ptr=%4p(%c...)\n"
#define	TRACE_DT(data, refer) \
	data.size, data.size, data.place.itm_64d, \
	data.place.itm_ptr,\
	(((refer) == 0) ? (not_refer): \
	(((sizeof (itm_place_t) < data.size))? \
	 *((char *)(((char *)itm_header) + data.place.itm_ptr)): \
	(not_refer)))
enum {
	NOREFER = 0,
	REFER  = 1
};
#define	NAMETRACE(comment) \
	{	itmc_name_t	*name;\
		TRACE_MESSAGE('p', (#comment "\n")); \
		for (name = name_first; name; name = name->next) {\
			TRACE_MESSAGE('p', \
				(TRACE_FMT(" "),\
				TRACE_DT(name->name, NOREFER)));\
		}\
	}

/* static int not_refer = (~0); */



static void	relocation_I(itm_hdr_t *, itm_info_hdr_t *);
static void	relocation_II(itm_hdr_t *, itm_info_hdr_t *);

static void	fix_itmc_ref_reloc(itmc_ref_t *, itm_place2_t);
static void	analysis(itm_info_hdr_t	*);
static void	analysis2(void);
static void	output(itm_hdr_t *, itm_info_hdr_t *);




/*
 * Assemble main function
 */

int
assemble(itm_hdr_t	*itm_header)
{
	int		i;
	int		j;
	itmc_ref_t	*ref;
	itm_info_hdr_t	*info_header;
	union {
		long	longval;
		char	charval[8];
	}		mach_spec;

	if (0 < error_deferred) {
		itm_error(gettext("number of deferred error: %d\n"),
			error_deferred);
		exit(ITMC_STATUS_BT);
	}

	itm_header->ident[0] = ITM_IDENT_0;
	itm_header->ident[1] = ITM_IDENT_1;
	itm_header->ident[2] = ITM_IDENT_2;
	itm_header->ident[3] = ITM_IDENT_3;

	itm_header->spec[0] = ITM_SPEC_0;
	itm_header->spec[1] = ITM_SPEC_1;
	itm_header->spec[2] = ITM_SPEC_2;
	mach_spec.longval = 1;
	switch (sizeof (long)) {
	case 4:
		if (0 == mach_spec.charval[0]) {
			itm_header->spec[3] = ITM_SPEC_3_32_BIG_ENDIAN;
		} else {
			itm_header->spec[3] = ITM_SPEC_3_32_LITTLE_ENDIAN;
		}
		break;
	case 8:
		if (0 == mach_spec.charval[0]) {
			itm_header->spec[3] = ITM_SPEC_3_64_BIG_ENDIAN;
		} else {
			itm_header->spec[3] = ITM_SPEC_3_64_LITTLE_ENDIAN;
		}
		break;
	}

	itm_header->version[0] = ITM_VER_0;
	itm_header->version[1] = ITM_VER_1;
	itm_header->version[2] = ITM_VER_2;
	itm_header->version[3] = ITM_VER_3;

	itm_header->itm_size.itm_ptr = 0;

	itm_header->reg_num = reg_id;

	itm_header->itm_hdr_size = (sizeof (itm_hdr_t));

	info_header = malloc_vital(sizeof (itm_info_hdr_t));
	(void) memset(info_header, 0, sizeof (itm_info_hdr_t));

	relocation_I(itm_header, info_header);
	relocation_II(itm_header, info_header);

	TRACE_MESSAGE('r',
			("	  ref	 name	 referencee reloc(10)"
			"size(10) referencer next\n"));
	for (i = ITMC_OBJ_FIRST; i <= ITMC_OBJ_LAST; i++) {
		TRACE_MESSAGE('r', ("%s\n", itmc_obj_names[i]));
		for (ref = ref_first[i], j = 0; ref; ref = ref->next, j++) {
			TRACE_MESSAGE('r',
			("	 %2d:%08p:%08p:%08p:%8p:%8ld:%08p:%08p\n",
			j, ref,
			ref->name, ref->referencee,
			ref->reloc.itm_ptr, ref->size,
			ref->referencer, ref->next));
		}
	}

	analysis(info_header);
	analysis2();
	if (0 < error_deferred) {
		itm_error(gettext("number of deferred error: %d\n"),
			error_deferred);
		exit(ITMC_STATUS_BT);
	}

	output(itm_header, info_header);
	return (0);
}


/*
 * Fix reloc of itmc_ref_t, and fix reloc of itmc_name_t
 */

static void
relocation_I(itm_hdr_t		*itm_header, itm_info_hdr_t	*info_header)
{
	itmc_ref_t	*ref;
	itmc_name_t	*name;
	itm_num_t	sec_num;
	itm_num_t	sec_num2;
	itm_size_t	sec_size;

	/*
	 * determin section size
	 */

	/* string section */
	for (sec_num = 0, sec_size = 0, ref = ref_first[ITMC_OBJ_STRING];
	    ref; sec_num += 1, sec_size += ref->size, ref = ref->next) {}
	sec_size = ITMROUNDUP(sec_size);
	info_header->str_plc_tbl.size = ((sizeof (itm_data_t)) * sec_num);
	info_header->str_plc_tbl.number = sec_num;
	info_header->str_sec.size = sec_size;
	info_header->str_sec.number = sec_num;

	/* direction */
	for (sec_num = 0, sec_size = 0, ref = ref_first[ITMC_OBJ_DIREC];
	    ref; sec_num += 1, sec_size += ref->size, ref = ref->next) {}
	sec_size = ITMROUNDUP(sec_size);
	info_header->direc_plc_tbl.size = sec_num * (sizeof (itm_place_t));
	info_header->direc_plc_tbl.number = sec_num;
	info_header->direc_tbl_sec.size = sec_size;
	info_header->direc_tbl_sec.number = sec_num;

	/* condition */
	for (sec_num = 0, sec_size = 0, ref = ref_first[ITMC_OBJ_COND];
	    ref; sec_num += 1, sec_size += ref->size, ref = ref->next) {}
	sec_size = ITMROUNDUP(sec_size);
	info_header->cond_plc_tbl.size = sec_num * (sizeof (itm_place_t));
	info_header->cond_plc_tbl.number = sec_num;
	info_header->cond_tbl_sec.size = sec_size;
	info_header->cond_tbl_sec.number = sec_num;

	/* map */
	for (sec_num = 0, sec_size = 0, ref = ref_first[ITMC_OBJ_MAP];
	    ref; sec_num += 1, sec_size += ref->size, ref = ref->next) {
	}
	sec_size = ITMROUNDUP(sec_size);
	info_header->map_plc_tbl.size = sec_num * (sizeof (itm_place_t));
	info_header->map_plc_tbl.number = sec_num;
	info_header->map_tbl_sec.size = sec_size;
	info_header->map_tbl_sec.number = sec_num;

	/* operation */
	for (sec_num = 0, sec_size = 0, ref = ref_first[ITMC_OBJ_OP];
	    ref; sec_num += 1, sec_size += ref->size, ref = ref->next) {
	}
	sec_size = ITMROUNDUP(sec_size);
	info_header->op_plc_tbl.size = sec_num * (sizeof (itm_place_t));
	info_header->op_plc_tbl.number = sec_num;
	info_header->op_tbl_sec.size = sec_size;
	info_header->op_tbl_sec.number = sec_num;

	/* range section */
	for (sec_num = 0, sec_size = 0, ref = ref_first[ITMC_OBJ_RANGE];
	    ref; sec_num += 1, sec_size += ref->size, ref = ref->next) {}
	sec_size = ITMROUNDUP(sec_size);
	info_header->range_plc_tbl.size = sec_num * (sizeof (itm_place_t));
	info_header->range_plc_tbl.number = sec_num;
	info_header->range_tbl_sec.size = sec_size;
	info_header->range_tbl_sec.number = sec_num;

	/* escapeseq section */
	for (sec_num = 0, sec_size = 0, ref = ref_first[ITMC_OBJ_ESCAPESEQ];
	    ref; sec_num += 1, sec_size += ref->size, ref = ref->next) {}
	sec_size = ITMROUNDUP(sec_size);
	info_header->escapeseq_plc_tbl.size = sec_num * (sizeof (itm_place_t));
	info_header->escapeseq_plc_tbl.number = sec_num;
	info_header->escapeseq_tbl_sec.size = sec_size;
	info_header->escapeseq_tbl_sec.number = sec_num;

	/* data section */
	for (sec_num = 0, sec_size = 0, ref = ref_first[ITMC_OBJ_DATA];
	    ref; sec_num += 1, sec_size += ref->size, ref = ref->next) {}
	for (ref = ref_first[ITMC_OBJ_EXPR];
	    ref; sec_num += 1, sec_size += ref->size, ref = ref->next) {}
	sec_size = ITMROUNDUP(sec_size);
	info_header->data_plc_tbl.size = ((sizeof (itm_place_t)) * sec_num);
	info_header->data_plc_tbl.number = sec_num;
	info_header->data_sec.size = sec_size;
	info_header->data_sec.number = sec_num;


	/* name section */
	sec_num2 = 0;
	for (sec_num = 0, sec_size = 0, name = name_first;
	    name; name = name->next) {
		if ((ITMC_OBJ_REGISTER != name->type) &&
		    (0 != name->name.size)) {
			if ((sizeof (itm_place_t)) < name->name.size) {
				sec_size += name->name.size;
				sec_num2 += 1;
			}
			sec_num += 1;
		}
	}
	info_header->name_plc_tbl.size = ((sizeof (itm_data_t))	* sec_num);
	info_header->name_plc_tbl.number = sec_num;

	for (sec_num = 0, name = name_first; name; name = name->next) {
		if ((ITMC_OBJ_REGISTER == name->type) &&
		    (0 != name->name.size)) {
			if ((sizeof (itm_place_t)) < name->name.size) {
				sec_size += name->name.size;
				sec_num2 += 1;
			}
			sec_num += 1;
		}
	}
	sec_size = ITMROUNDUP(sec_size);
	info_header->reg_plc_tbl.size =
		((sizeof (itm_data_t)) * (itm_header->reg_num));
	info_header->reg_plc_tbl.number = itm_header->reg_num;

	info_header->name_sec.size = sec_size;
	info_header->name_sec.number = sec_num2;

	/*
	 * adjust place
	 */
	info_header->str_sec.place.itm_ptr =
		0 +
		(sizeof (itm_hdr_t));
	info_header->direc_tbl_sec.place.itm_ptr =
		info_header->str_sec.place.itm_ptr +
		info_header->str_sec.size;
	info_header->cond_tbl_sec.place.itm_ptr =
		info_header->direc_tbl_sec.place.itm_ptr +
		info_header->direc_tbl_sec.size;
	info_header->map_tbl_sec.place.itm_ptr =
		info_header->cond_tbl_sec.place.itm_ptr +
		info_header->cond_tbl_sec.size;
	info_header->op_tbl_sec.place.itm_ptr =
		info_header->map_tbl_sec.place.itm_ptr +
		info_header->map_tbl_sec.size;

	info_header->range_tbl_sec.place.itm_ptr =
		info_header->op_tbl_sec.place.itm_ptr +
		info_header->op_tbl_sec.size;

	info_header->escapeseq_tbl_sec.place.itm_ptr =
		info_header->range_tbl_sec.place.itm_ptr +
		info_header->range_tbl_sec.size;

	info_header->data_sec.place.itm_ptr =
		info_header->escapeseq_tbl_sec.place.itm_ptr +
		info_header->escapeseq_tbl_sec.size;

	/*
	 * adjust place: optional
	 */

	if (0 == cmd_opt.strip) {
		itm_header->info_hdr.itm_ptr =
			info_header->data_sec.place.itm_ptr +
			info_header->data_sec.size;

		info_header->direc_plc_tbl.place.itm_ptr =
			itm_header->info_hdr.itm_ptr +
			(sizeof (itm_info_hdr_t));
		info_header->cond_plc_tbl.place.itm_ptr =
			info_header->direc_plc_tbl.place.itm_ptr +
			info_header->direc_plc_tbl.size;
		info_header->map_plc_tbl.place.itm_ptr =
			info_header->cond_plc_tbl.place.itm_ptr +
			info_header->cond_plc_tbl.size;
		info_header->op_plc_tbl.place.itm_ptr =
			info_header->map_plc_tbl.place.itm_ptr +
			info_header->map_plc_tbl.size;

		info_header->str_plc_tbl.place.itm_ptr =
			info_header->op_plc_tbl.place.itm_ptr +
			info_header->op_plc_tbl.size;
		info_header->range_plc_tbl.place.itm_ptr =
			info_header->str_plc_tbl.place.itm_ptr +
			info_header->str_plc_tbl.size;
		info_header->escapeseq_plc_tbl.place.itm_ptr =
			info_header->range_plc_tbl.place.itm_ptr +
			info_header->range_plc_tbl.size;
		info_header->data_plc_tbl.place.itm_ptr =
			info_header->escapeseq_plc_tbl.place.itm_ptr +
			info_header->escapeseq_plc_tbl.size;
		info_header->name_plc_tbl.place.itm_ptr =
			info_header->data_plc_tbl.place.itm_ptr +
			info_header->data_plc_tbl.size;
		info_header->reg_plc_tbl.place.itm_ptr =
			info_header->name_plc_tbl.place.itm_ptr +
			info_header->name_plc_tbl.size;

		/* name SECTION */
		info_header->name_sec.place.itm_ptr =
			info_header->reg_plc_tbl.place.itm_ptr +
			info_header->reg_plc_tbl.size;
	}

	/*
	 * size of ITM
	 */

	if (0 == cmd_opt.strip) {
		itm_header->itm_size.itm_ptr =
			info_header->name_sec.place.itm_ptr +
			info_header->name_sec.size;
	} else {
		itm_header->itm_size.itm_ptr =
			info_header->data_sec.place.itm_ptr +
			info_header->data_sec.size;
	}


	/*
	 * trace
	 */

#if defined(ENABLE_TRACE)
	dump_itm_header(itm_header, info_header);
#endif
}


/*
 * Fix referencer of itmc_ref_t
 */

static void
relocation_II(itm_hdr_t	*itm_header, itm_info_hdr_t	*info_header)
{
	itmc_ref_t	*ref;
	itmc_name_t	*name;
	itmc_ref_link_t	*rl;
	itm_place2_t	place;
	itm_place2_t	n_plc;

	/*
	 * reloc
	 */

	/* string section */
	TRACE_MESSAGE('3', ("string section\n"));
	place = info_header->str_sec.place.itm_ptr;
	for (ref = ref_first[ITMC_OBJ_STRING];
	    ref; place += ref->size, ref = ref->next) {
		fix_itmc_ref_reloc(ref, place);
	}

	/* direction */
	TRACE_MESSAGE('3', ("direction\n"));
	place = info_header->direc_tbl_sec.place.itm_ptr;
	for (ref = ref_first[ITMC_OBJ_DIREC];
	    ref; place += ref->size, ref = ref->next) {
		fix_itmc_ref_reloc(ref, place);
	}

	/* condition */
	TRACE_MESSAGE('3', ("condition\n"));
	place = info_header->cond_tbl_sec.place.itm_ptr;
	for (ref = ref_first[ITMC_OBJ_COND];
	    ref; place += ref->size, ref = ref->next) {
		fix_itmc_ref_reloc(ref, place);
	}

	/* map */
	TRACE_MESSAGE('3', ("map\n"));
	place = info_header->map_tbl_sec.place.itm_ptr;
	for (ref = ref_first[ITMC_OBJ_MAP];
	    ref; place += ref->size, ref = ref->next) {
		fix_itmc_ref_reloc(ref, place);
	}

	/* operation */
	TRACE_MESSAGE('3', ("operation\n"));
	place = info_header->op_tbl_sec.place.itm_ptr;
	for (ref = ref_first[ITMC_OBJ_OP];
	    ref; place += ref->size, ref = ref->next) {
		fix_itmc_ref_reloc(ref, place);
	}

	/* range */
	place = info_header->range_tbl_sec.place.itm_ptr;
	for (ref = ref_first[ITMC_OBJ_RANGE];
	    ref; place += ref->size, ref = ref->next) {
		fix_itmc_ref_reloc(ref, place);
	}

	/* escape sequence */
	place = info_header->escapeseq_tbl_sec.place.itm_ptr;
	for (ref = ref_first[ITMC_OBJ_ESCAPESEQ];
	    ref; place += ref->size, ref = ref->next) {
		fix_itmc_ref_reloc(ref, place);
	}
	/* data section */
	TRACE_MESSAGE('3', ("data section\n"));
	place = info_header->data_sec.place.itm_ptr;
	for (ref = ref_first[ITMC_OBJ_DATA];
	    ref; place += ref->size, ref = ref->next) {
		fix_itmc_ref_reloc(ref, place);
	}
	for (ref = ref_first[ITMC_OBJ_EXPR];
	    ref; place += ref->size, ref = ref->next) {
		fix_itmc_ref_reloc(ref, place);
	}

	/* name section */
	TRACE_MESSAGE('3', ("name section\n"));
	place = info_header->name_plc_tbl.place.itm_ptr;
	n_plc = info_header->name_sec.place.itm_ptr;
	for (name = name_first; name; name = name->next) {
		if ((NULL == name->object) ||
		    (ITMC_OBJ_REGISTER == name->type) ||
		    (0 == name->name.size)) {
			continue;
		}
		if ((sizeof (itm_place_t)) < name->name.size) {
			name->reloc.itm_ptr = n_plc;
			n_plc += name->name.size;
		}
		if (name->object->referencee) {
			((itm_tbl_hdr_t *)(name->object->referencee))->
			name.itm_ptr = place;
		}
		place += (intptr_t)(sizeof (itm_data_t));
	}
	place = info_header->reg_plc_tbl.place.itm_ptr;
	for (name = name_first; name; name = name->next) {
		if ((ITMC_OBJ_REGISTER != name->type) ||
		    (0 == name->name.size)) {
			continue;
		}
		if ((sizeof (itm_place_t)) < name->name.size) {
#if !defined(_LP64)
			name->reloc.itm_pad = 0;
#endif
			name->reloc.itm_ptr = n_plc;
			n_plc += name->name.size;
		}
		place += (sizeof (itm_data_t));
	}
	for (name = name_first; name; name = name->next) {
		if (ITMC_OBJ_REGISTER == name->type) {
			assert(NULL == name->object);
			continue;
		}
		if (NULL == name->object) {
			itm_error(
			gettext(
			"reference to %1$s \"%2$s\" is not resolved\n"),
			itm_name_type_name[name->type],
			name_to_str(&(name->name)));
			error_deferred += 1;
			continue;
		} /* else */
		assert(0 != name->name.size);
		for (rl = name->ref_first; rl; rl = rl->next) {
			fix_itmc_ref_reloc(rl->ref,
					name->object->reloc.itm_ptr);
		}
		if (NULL == name->object->referencee) {
			itm_error(
				gettext(
				"reference to %1$s \"%2$s\" is not resolved\n"),
				itm_name_type_name[name->type],
				name_to_str(&(name->name)));
			error_deferred += 1;
		}
		if (((ITMC_OBJ_REGISTER != name->type) &&
		    (ITMC_OBJ_DIREC != name->type) &&
		    ((ITMC_OBJ_MAP != name->type) ||
		    (NULL != ref_first[ITMC_OBJ_DIREC]))) &&
		    (NULL == name->ref_first)) {
			itm_error(
				gettext(
				"%1$s \"%2$s\" is defined, but not referred\n"),
					itm_name_type_name[name->type],
					name_to_str(&(name->name)));
				error_deferred += 1;
		}
	}


	/*
	 * initial direction table
	 */
	TRACE_MESSAGE('3', ("initial direction table\n"));
	if (NULL != ref_first[ITMC_OBJ_DIREC]) {
		itm_header->direc_init_tbl = ref_first[ITMC_OBJ_DIREC]->reloc;
	} else if (NULL != ref_first[ITMC_OBJ_MAP]) {
		itm_header->direc_init_tbl = ref_first[ITMC_OBJ_MAP]->reloc;
	} else {
		itm_error(gettext("No direction nor map\n"));
		exit(ITMC_STATUS_BT);
	}

	/*
	 * init operation and reset operation
	 */
	for (ref = ref_first[ITMC_OBJ_OP];
	    ref; place += ref->size, ref = ref->next) {
		switch (((itm_tbl_hdr_t *)(ref->referencee))->type) {
		case ITM_TBL_OP_INIT:
			itm_header->op_init_tbl = ref->reloc;
			break;
		case ITM_TBL_OP_RESET:
			itm_header->op_reset_tbl = ref->reloc;
			break;
		default:
			break;
		}
	}
}


/*
 * Fix reloc and referencer
 */
static void
fix_itmc_ref_reloc(itmc_ref_t	*ref, itm_place2_t place)
{
	itmc_ref_link_t		*rl;

	ref->reloc.itm_ptr = place;
#if !defined(_LP64)
	ref->reloc.itm_pad = 0;
#endif

	if (NULL != ref->referencer) {
		ref->referencer->itm_ptr = place;
	}

	TRACE_MESSAGE('f', ("fix_itmc_ref_reloc: 0x%08p 0x%08p %p\n",
			ref, ref->referencer, place));
	TRACE_MESSAGE('F', ("fix_itmc_ref_reloc: \"%s\"\n",
			name_to_str(ref->name ? &(ref->name->name) : NULL)));

	if (NULL != ref->name) {
		for (rl = ref->name->ref_first; rl; rl = rl->next) {
			if ((NULL != rl->ref) &&
			    (NULL != rl->ref->referencer)) {
				rl->ref->referencer->itm_ptr = place;
				TRACE_MESSAGE('f',
						("fix_itmc_ref_reloc: "
						"0x%08p 0x%08p\n",
						rl->ref, rl->ref->referencer));
				TRACE_MESSAGE('F',
						("fix_itmc_ref_reloc: \"%s\"\n",
						name_to_str(ref->name ?
							&(ref->name->name) :
							NULL)));
			}
		}
	}
}

/*
 * Analysis
 */
static void
analysis(itm_info_hdr_t	*info_header)
{
	itmc_ref_t	*ref;
	itm_place2_t	place;
	itm_type_t	obj_type;
	enum { ONEMAP, ZEROMAP}	onemap = ZEROMAP;

	TRACE_MESSAGE('4', ("Analysis\n"));

	place = info_header->str_sec.place.itm_ptr;
	for (obj_type = ITMC_OBJ_FIRST; obj_type <= ITMC_OBJ_LAST; obj_type++) {
		if (ITMC_OBJ_DIREC == obj_type) {
			continue;
		}

		for (ref = ref_first[obj_type];
		    ref; place += ref->size, ref = ref->next) {
			if ((NULL == ref->name) &&
			    (NULL == ref->referencer)) {
				itm_tbl_hdr_t	*tbl_hdr;
				char		*tbl_type;
				tbl_hdr = (itm_tbl_hdr_t *)(ref->referencee);
				if ((ITM_TBL_OP_RESET == tbl_hdr->type) ||
				    (ITM_TBL_OP_INIT == tbl_hdr->type)) {
					continue;
				} else if ((ITM_TBL_MAP ==
					(ITM_TBL_MASK & tbl_hdr->type)) &&
					(NULL == ref_first[ITMC_OBJ_DIREC])) {
					if (ZEROMAP == onemap) {
						onemap = ONEMAP;
						continue;
					} else {
						itm_error(
						gettext("multiple unamed map's "
							"defined\n"));
						error_deferred += 1;
						continue;
					}
				}
				switch (ITM_TBL_MASK & tbl_hdr->type) {
				case ITM_TBL_ITM:
					tbl_type =
					itm_name_type_name[ITMC_OBJ_ITM];
					break;
				case ITM_TBL_DIREC:
					tbl_type =
					itm_name_type_name[ITMC_OBJ_DIREC];
					break;
				case ITM_TBL_COND:
					tbl_type =
					itm_name_type_name[ITMC_OBJ_COND];
					break;
				case ITM_TBL_OP:
					tbl_type =
					itm_name_type_name[ITMC_OBJ_OP];
					break;
				case ITM_TBL_MAP:
					tbl_type =
					itm_name_type_name[ITMC_OBJ_MAP];
					break;
				case ITM_TBL_RANGE:
					tbl_type =
					itm_name_type_name[ITMC_OBJ_RANGE];
					break;
				case ITM_TBL_ESCAPESEQ:
					tbl_type =
					itm_name_type_name[ITMC_OBJ_ESCAPESEQ];
					break;
				default:
					tbl_type =
					itm_name_type_name[ITMC_OBJ_NONE];
					break;
				}
				itm_error(
					gettext("unnamed %1$s-type object is "
					"defined, but not referenced\n"),
					tbl_type);
				error_deferred += 1;
			}
		}
	}
}

/*
 * Analysis2 (check #nest of operation)
 */
#define	NIL -1
static void
analysis2(void)
{
	int			i, j, k, n_op;
	itmc_ref_t		*ref;
	itm_op_outer_t		*o, *o_prev;
	itm_op_inner_t		*in, *in_prev;
	int			indegree_zero;
	struct op_nest_vertex {
		itmc_ref_t	*ref; /* corresponding object's ref */
		int		indegree; /* indegree */
		struct op_nest_edge *e; /* link of edge list */
		int		z_link; /* index of indegree zero */
		int		n_nest;
	};
	struct op_nest_edge {
		struct op_nest_edge *e; /* link of edge list */
		int		index;	/* index of edge */
	};
	struct op_nest_vertex	*vertexes;
	struct op_nest_edge	*e, *e_prev;

	TRACE_MESSAGE('5', ("Analysis2\n"));

#ifdef ENABLE_TRACE
	for (o = itm_op_outer; o != NULL; o = o->link) {
		TRACE_MESSAGE('L', ("op(table)%x\n", o->optbl));
	}
#endif
	i = 0;
	for (o = itm_op_outer; o != NULL; o = o->link) {
		for (ref = ref_first[ITMC_OBJ_OP]; ref != NULL;
			ref = ref->next) {
			if (o->optbl == ref->referencee) {
				if (ref->name != NULL) {
					o->ref = ref->name->object;
				} else {
					o->ref = ref;
				}
				TRACE_MESSAGE('l', ("op(table)%x<-ref(%x)\n",
					o->optbl, o->ref));
				o->ref->vertex_index = i;
				i++;
				break;
			}
		}
	}

	n_op = i;
	if (n_op == 0)
		return;
	vertexes = (struct op_nest_vertex *)(malloc_vital(
		sizeof (struct op_nest_vertex) * n_op));

	for (o = itm_op_outer; o != NULL; o = o->link) {
		if (o->ref == NULL) {
			continue;
		}
		vertexes[o->ref->vertex_index].ref = o->ref;
		vertexes[o->ref->vertex_index].e = NULL;
	}

	for (o = itm_op_outer; o != NULL; o_prev = o,
		o = o->link, free(o_prev)) {
		if (o->ref == NULL) {
			continue;
		}
		TRACE_MESSAGE('l', ("vertexes[%d].ref=%x (optbl=%x(%s))\n",
			o->ref->vertex_index, o->ref, o->ref->referencee,
			name_to_str(o->ref->name == NULL ? NULL :
			&(o->ref->name->name))));
		for (in = o->in; in != NULL;
			in_prev = in, in = in->in, free(in_prev)) {
			/* make edge */
			i = o->ref->vertex_index;
			j = in->ref->name->object->vertex_index;
			e = malloc_vital(sizeof (struct op_nest_edge));
			e->index = j;
			e->e = vertexes[i].e;
			vertexes[i].e = e;
			vertexes[j].indegree++;
			TRACE_MESSAGE('l',
				(" edge: vertexes[%d]:(%s) ->vertex[%d]:(%s)\n",
				i,
				name_to_str(
				(vertexes[i].ref->name == NULL) ? NULL :
				&(vertexes[i].ref->name->name)),
				j,
				name_to_str(
				(vertexes[j].ref->name == NULL) ? NULL :
				&(vertexes[j].ref->name->name))));
		}
	}

	indegree_zero = NIL;
	for (i = 0; i < n_op; i++) {
		if (vertexes[i].indegree == 0) {
			vertexes[i].z_link = indegree_zero;
			indegree_zero = i;
		}
	}

	for (i = 0; i < n_op; i++) {
		if (indegree_zero == NIL) {
			itm_error(
				gettext("operation loop detected\n"));
			exit(ITMC_STATUS_BT2);
		}
		k = indegree_zero;
		indegree_zero = vertexes[indegree_zero].z_link;

		if (vertexes[k].n_nest > MAXOPNEST) {
			itm_error(
				gettext("operation nested more than %d\n"),
				MAXOPNEST);
			exit(ITMC_STATUS_BT2);
		}
		TRACE_MESSAGE('l',
			("take out first vertex: vertexes[%d] (i.e.%s) "
			"#depth=%d\n", k, name_to_str(
			(vertexes[k].ref->name == NULL) ? NULL :
			&(vertexes[k].ref->name->name)),
			vertexes[k].n_nest));

		for (e = vertexes[k].e; e != NULL;
			e_prev = e, e = e->e, free(e_prev)) {
			j = e->index;
			if (vertexes[j].n_nest < vertexes[k].n_nest + 1) {
				vertexes[j].n_nest =
					vertexes[k].n_nest + 1;
			}
			TRACE_MESSAGE('l', ("	+->vertexes[%d]:(%s) "
				"(#indegree=%d,#depth = %d)\n",
				j, name_to_str(&(vertexes[j].ref->name->name)),
				vertexes[j].indegree, vertexes[j].n_nest));
			vertexes[j].indegree--;
			if (vertexes[j].indegree == 0) {
				vertexes[j].z_link = indegree_zero;
				indegree_zero = j;
			}
		}
	}
	free(vertexes);
}
#undef NIL

/*
 * Output ITM compiled data
 */
void
output(itm_hdr_t	*itm_header, itm_info_hdr_t	*info_header)
{
	itmc_ref_t	*ref;
	itmc_name_t	*name;
	itm_size_t	sec_size;
	struct stat	st_buf;
	int		fd;
	FILE		*fp;

	if (cmd_opt.no_output) {
		return;
	} else if (NULL == itm_output_file) {
		fd = 1;
		TRACE_MESSAGE('o', ("file=(stdout)\n"));
	} else {
		TRACE_MESSAGE('o', ("file=%s\n", itm_output_file));
		switch (stat(itm_output_file, &st_buf)) {
		case 0:
			if (0 == cmd_opt.force_overwrite) {
				itm_error(
					gettext("target file exists\n"));
				exit(ITMC_STATUS_CMD2);
			}
			break;
		case -1:
			if (ENOENT != errno) {
				PERROR(gettext("stat"));
				exit(ITMC_STATUS_CMD2);
			}
			break;
		default:
			PERROR(gettext("stat"));
			exit(ITMC_STATUS_SYS);
			break;
		}

		fd = open(itm_output_file, O_CREAT|O_WRONLY|O_TRUNC, 0666);
		if (fd == -1) {
			PERROR(gettext("open"));
			exit(ITMC_STATUS_SYS);
		}
	}
	fp = fdopen(fd, "w");
	if (NULL == fp) {
		PERROR(gettext("fdopen"));
		exit(ITMC_STATUS_SYS);
	}

	if (1 == cmd_opt.strip) {
		itm_header->info_hdr.itm_ptr = 0;
	}

	/* ITM header */
	(void) fseek(fp, 0, SEEK_SET);
	(void) fwrite(itm_header, sizeof (itm_hdr_t), 1, fp);

	/* string section */
	(void) fseek(fp, info_header->str_sec.place.itm_ptr, SEEK_SET);
	TRACE_MESSAGE('P', ("str_sec.place.place=%p:\n",
		info_header->str_sec.place.itm_ptr));
	for (ref = ref_first[ITMC_OBJ_STRING]; ref; ref = ref->next) {
		(void) fwrite((void *)(ref->referencee), 1, ref->size, fp);
	}

	/* direction */
	(void) fseek(fp, info_header->direc_tbl_sec.place.itm_ptr, SEEK_SET);
	TRACE_MESSAGE('P', ("direc_tbl_sec.place=%p:\n",
		info_header->direc_tbl_sec.place.itm_ptr));
	for (ref = ref_first[ITMC_OBJ_DIREC]; ref; ref = ref->next) {
		(void) fwrite((void *)(ref->referencee), ref->size, 1, fp);
	}

	/* condition */
	(void) fseek(fp, info_header->cond_tbl_sec.place.itm_ptr, SEEK_SET);
	TRACE_MESSAGE('P', ("cond_tbl_sec.place=%p:\n",
		info_header->cond_tbl_sec.place.itm_ptr));
	for (ref = ref_first[ITMC_OBJ_COND]; ref; ref = ref->next) {
		(void) fwrite((void *)(ref->referencee), ref->size, 1, fp);
	}

	/* map */
	(void) fseek(fp, info_header->map_tbl_sec.place.itm_ptr, SEEK_SET);
	TRACE_MESSAGE('P', ("map_tbl_sec.place=%p:\n",
		info_header->map_tbl_sec.place.itm_ptr));
	for (ref = ref_first[ITMC_OBJ_MAP]; ref; ref = ref->next) {
		(void) fwrite((void *)(ref->referencee), ref->size, 1, fp);
	}

	/* operation */
	(void) fseek(fp, info_header->op_tbl_sec.place.itm_ptr, SEEK_SET);
	TRACE_MESSAGE('P', ("op_tbl_sec.place=%p:\n",
		info_header->op_tbl_sec.place.itm_ptr));
	for (ref = ref_first[ITMC_OBJ_OP]; ref; ref = ref->next) {
		(void) fwrite((void *)(ref->referencee), ref->size, 1, fp);
	}

	/* range */
	(void) fseek(fp, info_header->range_tbl_sec.place.itm_ptr, SEEK_SET);
	TRACE_MESSAGE('P', ("range_tbl_sec.place=%p:\n",
		info_header->range_tbl_sec.place.itm_ptr));
	for (ref = ref_first[ITMC_OBJ_RANGE]; ref; ref = ref->next) {
		(void) fwrite((void *)(ref->referencee), ref->size, 1, fp);
	}

	/* escape sequence */
	(void) fseek(fp, info_header->escapeseq_tbl_sec.place.itm_ptr,
		SEEK_SET);
	TRACE_MESSAGE('P', ("escapeseq_tbl_sec.place=%p:\n",
		info_header->escapeseq_tbl_sec.place.itm_ptr));
	for (ref = ref_first[ITMC_OBJ_ESCAPESEQ]; ref; ref = ref->next) {
		(void) fwrite((void *)(ref->referencee), ref->size, 1, fp);
	}

	/* data section */
	sec_size = 0;
	(void) fseek(fp, info_header->data_sec.place.itm_ptr, SEEK_SET);
	TRACE_MESSAGE('P', ("data_sec.place=%p:\n",
		info_header->data_sec.place.itm_ptr));
	for (ref = ref_first[ITMC_OBJ_DATA]; ref; ref = ref->next) {
		(void) fwrite((void *)(ref->referencee), ref->size, 1, fp);
		sec_size += ref->size;
	}
	for (ref = ref_first[ITMC_OBJ_EXPR]; ref; ref = ref->next) {
		(void) fwrite((void *)(ref->referencee), ref->size, 1, fp);
		sec_size += ref->size;
	}
	if (0 != cmd_opt.strip) {
		if (sec_size < info_header->data_sec.size) {
			(void) fwrite("\0\0\0\0", 1,
				info_header->data_sec.size - sec_size, fp);
		}
	} else {

		/* ITM Info header */
		(void) fseek(fp, itm_header->info_hdr.itm_ptr, SEEK_SET);
		TRACE_MESSAGE('P', ("info_hdr=%p:\n",
			itm_header->info_hdr.itm_ptr));
		(void) fwrite(info_header, sizeof (itm_info_hdr_t), 1, fp);

		(void) fseek(fp, info_header->direc_plc_tbl.place.itm_ptr,
			SEEK_SET);
		TRACE_MESSAGE('P', ("direc_plc_tbl.place=%p:\n",
			info_header->direc_plc_tbl.place.itm_ptr));
		for (ref = ref_first[ITMC_OBJ_DIREC]; ref; ref = ref->next) {
			(void) fwrite(&(ref->reloc),
				sizeof (itm_place_t), 1, fp);
		}

		(void) fseek(fp, info_header->cond_plc_tbl.place.itm_ptr,
			SEEK_SET);
		TRACE_MESSAGE('P', ("cond_plc_tbl.place=%p:\n",
			info_header->cond_plc_tbl.place.itm_ptr));

		for (ref = ref_first[ITMC_OBJ_COND]; ref; ref = ref->next) {
			(void) fwrite(&(ref->reloc),
				sizeof (itm_place_t), 1, fp);
		}

		(void) fseek(fp, info_header->map_plc_tbl.place.itm_ptr,
			SEEK_SET);
		TRACE_MESSAGE('P', ("map_plc_tbl.place=%p:\n",
			info_header->map_plc_tbl.place.itm_ptr));

		for (ref = ref_first[ITMC_OBJ_MAP]; ref; ref = ref->next) {
			(void) fwrite(&(ref->reloc),
				sizeof (itm_place_t), 1, fp);
		}

		(void) fseek(fp, info_header->op_plc_tbl.place.itm_ptr,
			SEEK_SET);
		TRACE_MESSAGE('P', ("op_plc_tbl.place=%p:\n",
			info_header->op_plc_tbl.place.itm_ptr));
		for (ref = ref_first[ITMC_OBJ_OP]; ref; ref = ref->next) {
			(void) fwrite(&(ref->reloc),
				sizeof (itm_place_t), 1, fp);
		}

		(void) fseek(fp, info_header->str_plc_tbl.place.itm_ptr,
			SEEK_SET);
		TRACE_MESSAGE('P', ("str_plc_tbl.place=%p:\n",
			info_header->str_plc_tbl.place.itm_ptr));

		for (ref = ref_first[ITMC_OBJ_STRING]; ref; ref = ref->next) {
			itm_data_t	data;
#if !defined(_LP64)
			data.place.itm_pad = 0;
			data.pad = 0;
#endif
			data.place = ref->reloc;
			data.size = ref->size;
			(void) fwrite(&data, sizeof (itm_data_t), 1, fp);
		}

		(void) fseek(fp, info_header->range_plc_tbl.place.itm_ptr,
			SEEK_SET);
		TRACE_MESSAGE('P', ("range_plc_tbl.place=%p:\n",
			info_header->range_plc_tbl.place.itm_ptr));
		for (ref = ref_first[ITMC_OBJ_RANGE]; ref; ref = ref->next) {
			(void) fwrite(&(ref->reloc),
				sizeof (itm_place_t), 1, fp);
		}
		(void) fseek(fp, info_header->escapeseq_plc_tbl.place.itm_ptr,
			SEEK_SET);
		TRACE_MESSAGE('P', ("escapeseq_plc_tbl.place=%p:\n",
			info_header->escapeseq_plc_tbl.place.itm_ptr));
		for (ref = ref_first[ITMC_OBJ_ESCAPESEQ];
		    ref; ref = ref->next) {
			(void) fwrite(&(ref->reloc),
				sizeof (itm_place_t), 1, fp);
		}

		(void) fseek(fp, info_header->data_plc_tbl.place.itm_ptr,
			SEEK_SET);
		TRACE_MESSAGE('P', ("data_plc_tbl.place=%p:\n",
			info_header->data_plc_tbl.place.itm_ptr));
		for (ref = ref_first[ITMC_OBJ_DATA]; ref; ref = ref->next) {
			(void) fwrite(&(ref->reloc),
				sizeof (itm_place_t), 1, fp);
		}
		for (ref = ref_first[ITMC_OBJ_EXPR]; ref; ref = ref->next) {
			(void) fwrite(&(ref->reloc),
				sizeof (itm_place_t), 1, fp);
		}

		(void) fseek(fp, info_header->name_plc_tbl.place.itm_ptr,
			SEEK_SET);
		TRACE_MESSAGE('P', ("name_plc_tbl.place=%p:\n",
			info_header->name_plc_tbl.place.itm_ptr));
		for (name = name_first, sec_size = 0;
		    name; name = name->next) {
			itm_data_t	data;
			if ((ITMC_OBJ_REGISTER == name->type) ||
			    (0 == name->name.size)) {
				continue;
			}
			data.size = name->name.size;
#if !defined(_LP64)
			data.pad = 0;
#endif
			if ((sizeof (itm_place_t)) < data.size) {
#if !defined(_LP64)
				data.place.itm_pad = 0;
#endif
				data.place.itm_ptr = name->reloc.itm_ptr;
			} else {
				data.place = name->name.place;
			}
			(void) fwrite(&data, sizeof (itm_data_t), 1, fp);
		}

		(void) fseek(fp, info_header->reg_plc_tbl.place.itm_ptr,
			SEEK_SET);
		TRACE_MESSAGE('P', ("reg_plc_tbl.place=%p:\n",
			info_header->reg_plc_tbl.place.itm_ptr));

		for (name = name_first;
		    name; name = name->next) {
			itm_data_t	data;
			if ((ITMC_OBJ_REGISTER != name->type) ||
			    (0 == name->name.size)) {
				continue;
			}
#if !defined(_LP64)
			data.pad = 0;
#endif
			data.size = name->name.size;
			if ((sizeof (itm_place_t)) < data.size) {
#if !defined(_LP64)
				data.place.itm_pad = 0;
#endif
				data.place.itm_ptr = name->reloc.itm_ptr;
			} else {
				data.place = name->name.place;
			}
			(void) fwrite(&data, sizeof (itm_data_t), 1, fp);
		}

		/* Name section */
		(void) fseek(fp, info_header->name_sec.place.itm_ptr, SEEK_SET);
		TRACE_MESSAGE('P', ("name_sec.place=%p:\n",
			info_header->name_sec.place.itm_ptr));
		for (name = name_first, sec_size = 0;
		    name; name = name->next) {
			if ((ITMC_OBJ_REGISTER == name->type) ||
			    (name->name.size <= (sizeof (itm_place_t)))) {
				continue;
			}
			(void) fwrite(NSPTR(&(name->name)), 1,
				name->name.size, fp);
			sec_size += name->name.size;
		}
		for (name = name_first; name; name = name->next) {
			if ((ITMC_OBJ_REGISTER != name->type) ||
			    (name->name.size <= (sizeof (itm_place_t)))) {
				continue;
			}
			(void) fwrite(NSPTR(&(name->name)), 1,
				name->name.size, fp);
			sec_size += name->name.size;
		}
		if (sec_size < info_header->name_sec.size) {
			(void) fwrite("\0\0\0\0", 1,
				info_header->name_sec.size - sec_size, fp);
		}
	}
	(void) fclose(fp);
}