OpenSolaris_b135/cmd/geniconvtbl/disassemble.c

/*
 * 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.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"


#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <fcntl.h>
#include <unistd.h>
#include <libintl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <errno.h>
#include <stdarg.h>
#include <string.h>

#include "iconv_tm.h"
#include "itm_util.h"

/*
 * function prototype
 */

static itm_hdr_t	*itm_attach(const char *);
static void	dump_tables(itm_hdr_t *, itm_info_hdr_t *);
static void	dump_direc_tbl(itm_hdr_t *, itm_place_t);
static void	dump_map(itm_hdr_t *, itm_place_t, int);
static void	dump_map_i_f(itm_hdr_t *, itm_place_t, int);
static void	dump_map_l_f(itm_hdr_t *, itm_place_t, int);
static void	dump_map_hash(itm_hdr_t *, itm_place_t, int);
static void	dump_map_dense_enc(itm_hdr_t *, itm_place_t, int);
static void	dump_cond_tbl(itm_hdr_t *, itm_place_t, int);
static void	dump_op_tbl(itm_hdr_t *, itm_place_t, int);
static void	dump_op(itm_hdr_t *, itm_place2_t);
static void	dump_expr(itm_hdr_t *, itm_place_t);
static void	dump_range(itm_hdr_t *, itm_place_t);
static void	dump_escapeseq(itm_hdr_t *, itm_place_t);

static char	*tbl_name(itm_hdr_t *, itm_tbl_hdr_t *);
static char	*reg_name(itm_hdr_t	*itm_hdr, itm_place_t op);

static void	printi(int, char *, ...);


/*
 * macro definition
 */

#define	ADDR(place)	((void *)(((char *)(itm_hdr)) + \
			((itm_place2_t)((place).itm_ptr))))
#define	DADDR(n)	(((n)->size <= (sizeof ((n)->place))) ?	\
				((char *)(&((n)->place))) :\
				((char *)(ADDR((n)->place))))
#define	ADDR2(place2)	((void *)(((char *)(itm_hdr)) + \
			((itm_place2_t)(place2))))
#define	INFO_HDR(pa)	((void *)(((char *)pa) + \
			((itm_hdr_t *)(pa))->info_hdr.itm_ptr))


#if defined(RESERVED_NAME_PREFIX)
#define	RNPREF		RESERVED_NAME_PREFIX
#else /* !defined(RESERVED_NAME_PREFIX) */
#define	RNPREF		/* null strings */
#endif /* !defined(RESERVED_NAME_PREFIX) */


void
disassemble(char	*file)
{
	itm_hdr_t	*itm_hdr;
	itm_info_hdr_t	*info_hdr;
	itm_data_t	type_id;

	TRACE_MESSAGE('d', ("disassemble %s\n", file));

	itm_hdr = itm_attach(file);

	if (NULL == itm_hdr) {
		exit(3);
	}

	if (0 == itm_hdr->info_hdr.itm_ptr) {
		itm_error(gettext("binarytable is stripped\n"));
		exit(4);
	}

	if (0 == itm_hdr->info_hdr.itm_ptr) {
		info_hdr = malloc_vital(sizeof (itm_info_hdr_t));
		(void) memset(info_hdr, 0, sizeof (itm_info_hdr_t));
	} else {
		info_hdr = INFO_HDR(itm_hdr);
	}

#if defined(ENABLE_TRACE)
	dump_itm_header(itm_hdr, info_hdr);
#endif
	printi(0, "//\n", file);
	printi(0, "// %s\n", file);
	printi(0, "//\n", file);

	type_id = itm_hdr->type_id;
	if ((NULL != cmd_opt.disassemble) &&
	    ((sizeof (itm_place_t)) < type_id.size)) {
		type_id.place.itm_ptr += (itm_place2_t)itm_hdr;
	}
	printi(1, "%s {\n", name_to_str(&type_id));
	dump_tables(itm_hdr, info_hdr);
	printi(-1, "}\n");
}

#if defined(ENABLE_TRACE)
void
dump_itm_header(itm_hdr_t	*itm_header, itm_info_hdr_t	*info_header)
{
	char	*str_type_id;
	char	*str_interpreter;

	itm_data_t	type_id;
	itm_data_t	interpreter;

	type_id = itm_header->type_id;
	str_type_id = malloc_vital(itm_header->type_id.size + 1);
	if ((NULL != cmd_opt.disassemble) &&
	    ((sizeof (itm_place_t)) < type_id.size)) {
		type_id.place.itm_ptr += (itm_place2_t)itm_header;
	}
	(void) memcpy(str_type_id, name_to_str(&type_id), type_id.size + 1);

	interpreter = itm_header->interpreter;
	str_interpreter = malloc_vital(itm_header->interpreter.size + 1);
	if ((NULL != cmd_opt.disassemble) &&
	    ((sizeof (itm_place_t)) < interpreter.size)) {
		interpreter.place.itm_ptr += (itm_place2_t)itm_header;
	}
	(void) memcpy(str_interpreter, name_to_str(&interpreter),
		interpreter.size + 1);

	TRACE_MESSAGE('D',
			("\n"
			"------\n"
			"Sizeof Data Structures \n"
			" sizeof(int)		    = %ld\n"
			" sizeof(long)		    = %ld\n"
			" sizeof(uintptr_t)	    = %ld\n"
			" sizeof(struct itm_place_t)  = %ld\n"
			" sizeof(struct itm_data_t)   = %ld\n"
			" sizeof(struct itm_hdr_t)    = %ld\n"
			" sizeof(struct itm_place_tbl_info_t)  = %ld\n"
			" sizeof(struct itm_section_info_t)    = %ld\n"
			" sizeof(struct itm_action_type_t)     = %ld\n"
			" sizeof(struct itm_direct_t)	= %ld\n"
			" sizeof(struct itm_cond_t)	= %ld\n"
			" sizeof(struct itm_range_hdr_t)       = %ld\n"
			" sizeof(struct itm_escapeseq_hdr_t)   = %ld\n"
			" sizeof(struct itm_map_idx_fix_hdr_t) = %ld\n"
			" sizeof(struct itm_map_lookup_hdr_t)  = %ld\n"
			" sizeof(struct itm_map_hash_hdr_t)    = %ld\n"
			" sizeof(struct itm_map_dense_enc_hdr_t) = %ld\n"
			" sizeof(struct itm_expr_t)   = %ld\n"
			" sizeof(enum itm_op_type_t)  = %ld\n"
			" sizeof(struct itm_op_t)     u= %ld\n"
			" sizeof(enum itm_expr_type_t)= %ld\n"
			"\n",

			sizeof (int),
			sizeof (long),
			sizeof (uintptr_t),
			sizeof (itm_place_t),
			sizeof (itm_data_t),
			sizeof (itm_hdr_t),
			sizeof (itm_place_tbl_info_t),
			sizeof (itm_section_info_t),
			sizeof (itm_action_type_t),
			sizeof (itm_direc_t),
			sizeof (itm_cond_t),
			sizeof (itm_range_hdr_t),
			sizeof (itm_escapeseq_hdr_t),
			sizeof (itm_map_idx_fix_hdr_t),
			sizeof (itm_map_lookup_hdr_t),
			sizeof (itm_map_hash_hdr_t),
			sizeof (itm_map_dense_enc_hdr_t),
			sizeof (itm_expr_t),
			sizeof (itm_op_type_t),
			sizeof (itm_op_t),
			sizeof (itm_expr_type_t)));

	TRACE_MESSAGE('H',
			("ident		= %c%c%c\n"
			"spec		= %02x%02x%02x%02x\n"
			"version	= %02x%02x%02x%02x\n"
			"itm_size	= %ld\n"
			"type_id	= %s\n"
			"interpreter	= %s\n"
			"op_init_tbl	= %ld\n"
			"op_reset_tbl	= %ld\n"
			"direc_init_tbl = %ld\n"
			"reg_num	= %ld\n"
			"itm_hdr_size	= %ld\n"
			"info_hdr	= %ld\n"
			"info_hdr_size	= %ld\n",

			itm_header->ident[0],
			itm_header->ident[1],
			itm_header->ident[2],
			/* itm_header->ident[3], */
			itm_header->spec[0],
			itm_header->spec[1],
			itm_header->spec[2],
			itm_header->spec[3],
			itm_header->version[0],
			itm_header->version[1],
			itm_header->version[2],
			itm_header->version[3],
			itm_header->itm_size.itm_ptr,
			str_type_id,
			str_interpreter,
			itm_header->op_init_tbl.itm_ptr,
			itm_header->op_reset_tbl.itm_ptr,
			itm_header->direc_init_tbl.itm_ptr,
			itm_header->reg_num,
			itm_header->itm_hdr_size,
			itm_header->info_hdr.itm_ptr,
			(sizeof (itm_info_hdr_t))));

	TRACE_MESSAGE('H',
			("  str_sec     = (%4ld %4ld %4ld)	"
			"  str_plc_tbl = (%4ld %4ld %4ld)\n"
			"direc_sec_tbl = (%4ld %4ld %4ld)	"
			"direc_plc_tbl = (%4ld %4ld %4ld)\n"
			" cond_sec_tbl = (%4ld %4ld %4ld)	"
			" cond_plc_tbl = (%4ld %4ld %4ld)\n"
			"  map_sec_tbl = (%4ld %4ld %4ld)	"
			"  map_plc_tbl = (%4ld %4ld %4ld)\n"
			"   op_sec_tbl = (%4ld %4ld %4ld)	"
			"   op_plc_tbl = (%4ld %4ld %4ld)\n"
			"range_sec_tbl = (%4ld %4ld %4ld)	"
			"range_plc_tbl = (%4ld %4ld %4ld)\n"
			"escsq_sec_tbl = (%4ld %4ld %4ld)	"
			"escsq_plc_tbl = (%4ld %4ld %4ld)\n"
			" data_sec     = (%4ld %4ld %4ld)	"
			" data_plc_tbl = (%4ld %4ld %4ld)\n"
			" name_sec     = (%4ld %4ld %4ld)	"
			" name_plc_tbl = (%4ld %4ld %4ld)\n"
			"					"
			"  reg_plc_tbl = (%4ld %4ld %4ld)\n"
			"%s\n",
			info_header->str_sec.place.itm_ptr,
			info_header->str_sec.size,
			info_header->str_sec.number,
			info_header->str_plc_tbl.place.itm_ptr,
			info_header->str_plc_tbl.size,
			info_header->str_plc_tbl.number,
			info_header->direc_tbl_sec.place.itm_ptr,
			info_header->direc_tbl_sec.size,
			info_header->direc_tbl_sec.number,
			info_header->direc_plc_tbl.place.itm_ptr,
			info_header->direc_plc_tbl.size,
			info_header->direc_plc_tbl.number,
			info_header->cond_tbl_sec.place.itm_ptr,
			info_header->cond_tbl_sec.size,
			info_header->cond_tbl_sec.number,
			info_header->cond_plc_tbl.place.itm_ptr,
			info_header->cond_plc_tbl.size,
			info_header->cond_plc_tbl.number,
			info_header->map_tbl_sec.place.itm_ptr,
			info_header->map_tbl_sec.size,
			info_header->map_tbl_sec.number,
			info_header->map_plc_tbl.place.itm_ptr,
			info_header->map_plc_tbl.size,
			info_header->map_plc_tbl.number,
			info_header->op_tbl_sec.place.itm_ptr,
			info_header->op_tbl_sec.size,
			info_header->op_tbl_sec.number,
			info_header->op_plc_tbl.place.itm_ptr,
			info_header->op_plc_tbl.size,
			info_header->op_plc_tbl.number,
			info_header->range_tbl_sec.place.itm_ptr,
			info_header->range_tbl_sec.size,
			info_header->range_tbl_sec.number,
			info_header->range_plc_tbl.place.itm_ptr,
			info_header->range_plc_tbl.size,
			info_header->range_plc_tbl.number,
			info_header->escapeseq_tbl_sec.place.itm_ptr,
			info_header->escapeseq_tbl_sec.size,
			info_header->escapeseq_tbl_sec.number,
			info_header->escapeseq_plc_tbl.place.itm_ptr,
			info_header->escapeseq_plc_tbl.size,
			info_header->escapeseq_plc_tbl.number,
			info_header->data_sec.place.itm_ptr,
			info_header->data_sec.size,
			info_header->data_sec.number,
			info_header->data_plc_tbl.place.itm_ptr,
			info_header->data_plc_tbl.size,
			info_header->data_plc_tbl.number,
			info_header->name_sec.place.itm_ptr,
			info_header->name_sec.size,
			info_header->name_sec.number,
			info_header->name_plc_tbl.place.itm_ptr,
			info_header->name_plc_tbl.size,
			info_header->name_plc_tbl.number,
			info_header->reg_plc_tbl.place.itm_ptr,
			info_header->reg_plc_tbl.size,
			info_header->reg_plc_tbl.number,
			"--------"));
}
#endif

/*
 * Dump tables
 */
static void
dump_tables(itm_hdr_t	*itm_hdr, itm_info_hdr_t	*info_hdr)
{
	itm_num_t	n;
	itm_data_t	*data;
	itm_place_t	*place;
	itm_place2_t	place2;
	itm_data_t	d;

	data = (itm_data_t *)(ADDR(info_hdr->reg_plc_tbl.place));
	for (n = 0; n < info_hdr->reg_plc_tbl.number; n++, data += 1) {
		d = *(data);
		if ((sizeof (itm_place_t)) < d.size) {
			d.place.itm_ptr = (itm_place2_t)ADDR(d.place);
		}
		printi(0, "// register: %s\n", name_to_str(&d));
	}

	data = (itm_data_t *)(ADDR(info_hdr->name_plc_tbl.place));
	for (n = 0, place2 = info_hdr->name_plc_tbl.place.itm_ptr;
	    n < info_hdr->name_plc_tbl.number;
	    n++, data += 1, place2 += sizeof (itm_data_t)) {
		d = *(data);

		if ((sizeof (itm_place_t)) < d.size) {
			d.place.itm_ptr = (itm_place2_t)ADDR(d.place);
		}
		TRACE_MESSAGE('p', ("(*)name=%ld",
				((sizeof (itm_place_t)) < d.size) ?
				d.place.itm_ptr:
				(place2 + offsetof(itm_data_t, place))));
		printi(0, "// name: %s\n", name_to_str(&d));

	}

	place = (itm_place_t *)(ADDR(info_hdr->cond_plc_tbl.place));
	for (n = 0; n < info_hdr->cond_plc_tbl.number; n++, place += 1) {
		dump_cond_tbl(itm_hdr, *place, 1);
	}
	place = (itm_place_t *)(ADDR(info_hdr->map_plc_tbl.place));
	for (n = 0; n < info_hdr->map_plc_tbl.number;
	    n++, place += 1) {
		dump_map(itm_hdr, *place, 1);
	}
	place = (itm_place_t *)(ADDR(info_hdr->op_plc_tbl.place));
	for (n = 0; n < info_hdr->op_plc_tbl.number;
	    n++, place += 1) {
		dump_op_tbl(itm_hdr, *place, 1);
	}
	place = (itm_place_t *)(ADDR(info_hdr->direc_plc_tbl.place));
	for (n = 0; n < info_hdr->direc_plc_tbl.number; n++, place += 1) {
		dump_direc_tbl(itm_hdr, *place);
	}
}


/*
 * Dump direction
 */
static void
dump_direc_tbl(itm_hdr_t	*itm_hdr, itm_place_t direc_place)
{
	itm_tbl_hdr_t	*direc_hdr;
	itm_direc_t	*direc;
	itm_type_t	type;
	long		i;
	char		*name;

	direc_hdr = (itm_tbl_hdr_t *)ADDR(direc_place);
	direc = (itm_direc_t *)(direc_hdr + 1);

	TRACE_MESSAGE('p', ("(&)direc=%ld ", direc_place.itm_ptr));

	printi(1, RNPREF "direction");
	if (0 != direc_hdr->name.itm_ptr) {
		name = tbl_name(itm_hdr, direc_hdr);
		if (NULL != name) {
			printi(0, " %s", name);
		}
	}
	printi(0, " {\n");

	for (i = 0; i < direc_hdr->number; i++, direc++) {
		dump_cond_tbl(itm_hdr, direc->condition, 0);

		printi(0, "\t");

		type = (ITM_TBL_MASK &
			(((itm_tbl_hdr_t *)(ADDR(direc->action)))->type));

		if (ITM_TBL_OP == type) {
			dump_op_tbl(itm_hdr, direc->action, 0);
		} else if (ITM_TBL_DIREC == type) {
			printi(0, "direction: action: %ld\n",
				direc->action.itm_ptr);
		} else if (ITM_TBL_MAP == type) {
			dump_map(itm_hdr, direc->action, 0);
		} else {
			printi(0, RNPREF
				"error ELIBBAD // unknown operation (%lx)\n",
				type);
		}
	}

	printi(-1, "};\n");
}


static void
dump_map(itm_hdr_t	*itm_hdr, itm_place_t map_place, int standalone)
{
	itm_tbl_hdr_t	*tbl_hdr;

	tbl_hdr = (itm_tbl_hdr_t *)ADDR(map_place);

	switch (tbl_hdr->type) {
	case ITM_TBL_MAP_INDEX_FIXED_1_1:
	case ITM_TBL_MAP_INDEX_FIXED:
		dump_map_i_f(itm_hdr, map_place, standalone);
		break;
	case ITM_TBL_MAP_LOOKUP:
		dump_map_l_f(itm_hdr, map_place, standalone);
		break;
	case ITM_TBL_MAP_HASH:
		dump_map_hash(itm_hdr, map_place, standalone);
		break;
	case ITM_TBL_MAP_DENSE_ENC:
		dump_map_dense_enc(itm_hdr, map_place, standalone);
		break;
	default:
		break;
	}
}


/*
 * Dump map-indexed-fixed
 */
static void
dump_map_i_f(itm_hdr_t		*itm_hdr, itm_place_t map_place, int standalone)
{
	itm_tbl_hdr_t		*tbl_hdr;
	itm_map_idx_fix_hdr_t	*map_hdr;
	itm_num_t		i;
	itm_num_t		j;
	unsigned char		*p;
	unsigned char		*map_error;
	char			*name;
	int			error_flag;

	TRACE_MESSAGE('d', ("dump_map_i_f\n"));

	tbl_hdr = (itm_tbl_hdr_t *)ADDR(map_place);
	map_hdr = (itm_map_idx_fix_hdr_t *)(tbl_hdr + 1);

	if (0 < map_hdr->error_num) {
		p = (unsigned char *)(map_hdr + 1);
		map_error = p + (map_hdr->result_len * (tbl_hdr->number));
		if (0 == map_hdr->default_error) {
			map_error += map_hdr->result_len;
		}
	} else if (1 == map_hdr->default_error) {
		p = (unsigned char *)(map_hdr + 1);
		map_error = p + (map_hdr->result_len * (tbl_hdr->number));
	} else {
		map_error = NULL;
	}

	if ((standalone) &&
	    (0 == tbl_hdr->name.itm_ptr) &&
	    (map_place.itm_ptr != itm_hdr->direc_init_tbl.itm_ptr)) {
		return;
	}

	TRACE_MESSAGE('p', ("(&)map=%ld ", map_place.itm_ptr));

	if (0 == tbl_hdr->name.itm_ptr) {
		name = NULL;
	} else {
		name = tbl_name(itm_hdr, tbl_hdr);
	}

	if ((0 == standalone) && (0 != tbl_hdr->name.itm_ptr)) {
		if (NULL != name) {
			printi(0, "%s;\n", name);
		} else {
			printi(0, RNPREF "unknown;\n", name);
		}
		return;
	} else {
		printi(1, RNPREF "map");
		if (NULL != name) {
			printi(0, " %s", name);
		}
		printi(0, " {\n");
	}

	printi(0, "//  simple indexed map\n");
	printi(0, "//  source_len=%ld result_len=%ld\n",
		map_hdr->source_len, map_hdr->result_len);
	printi(0, "//  start=0x%p end=0x%p\n", /* DO NOT CHANGE to %ld */
		map_hdr->start.itm_ptr, map_hdr->end.itm_ptr);
	if (0 < map_hdr->error_num) {
		printi(0, "//  error_num=%ld\n",
			map_hdr->error_num);
	}
	if (0 == map_hdr->default_error) {
		p = (((unsigned char *)(map_hdr + 1)) +
			(map_hdr->result_len *
			(map_hdr->end.itm_ptr - map_hdr->start.itm_ptr + 1)));
		printi(0, RNPREF "default 0x");
		for (j = 0; j < map_hdr->result_len; j++) {
			printi(0, "%02x", *(p + j));
		}
		printi(0, "\n");
	} else if (-1 == map_hdr->default_error) {
		printi(0, RNPREF "default\t" RNPREF "default\n");
	}
	error_flag = 0;
	for (i = 0; i <= (map_hdr->end.itm_ptr - map_hdr->start.itm_ptr); i++) {
		p = (((unsigned char *)(map_hdr + 1)) +
			(map_hdr->result_len * i));
		if ((NULL == map_error) ||
		    (0 == *(map_error + i))) {
			printi(0, "0x%0*p\t",
			(map_hdr->source_len * 2), i + map_hdr->start.itm_ptr);
			printi(0, "0x");
			for (j = 0; j < map_hdr->result_len; j++) {
				printi(0, "%02x", *(p + j));
			}
			error_flag = 0;
			printi(0, "\n");
		} else	if (0 >= map_hdr->default_error) {
			if (0 == error_flag) {
				printi(0, "0x%0*p\t",
				(map_hdr->source_len * 2),
				i + map_hdr->start.itm_ptr);
				printi(0, "error\n");
				error_flag = 1;
			} else if (error_flag == 1) {
				printi(0, " :\t:\n");
				error_flag = 2;
			}
		}
	}
	printi(-1, "};\n");
}


/*
 * Dump map-lookup-fixed
 */
static void
dump_map_l_f(itm_hdr_t		*itm_hdr, itm_place_t map_place, int standalone)
{
	itm_tbl_hdr_t		*tbl_hdr;
	itm_map_lookup_hdr_t	*map_hdr;
	itm_num_t		i;
	itm_num_t		j;
	unsigned char		*p;
	char			*name;

	TRACE_MESSAGE('d', ("dump_map_l_f\n"));

	tbl_hdr = (itm_tbl_hdr_t *)ADDR(map_place);
	map_hdr = (itm_map_lookup_hdr_t *)(tbl_hdr + 1);

	if ((standalone) &&
	    (0 == tbl_hdr->name.itm_ptr) &&
	    (map_place.itm_ptr != itm_hdr->direc_init_tbl.itm_ptr)) {
		return;
	}

	TRACE_MESSAGE('p', ("(&)map=%ld ", map_place.itm_ptr));

	if (0 == tbl_hdr->name.itm_ptr) {
		name = NULL;
	} else {
		name = tbl_name(itm_hdr, tbl_hdr);
	}

	if ((0 == standalone) && (0 != tbl_hdr->name.itm_ptr)) {
		if (NULL != name) {
			printi(0, "%s;\n", name);
		} else {
			printi(0, RNPREF "unknown;\n", name);
		}
		return;
	} else {
		printi(1, RNPREF "map");
		if (NULL != name) {
			printi(0, " %s", name);
		}
		printi(0, " {\n");
	}

	printi(0, "//  binary search map\n");
	printi(0, "//  source_len=%ld result_len=%ld\n",
		map_hdr->source_len, map_hdr->result_len);
	if (0 < map_hdr->error_num) {
		printi(0, "//  error_num=%ld\n",
			map_hdr->error_num);
	}

	if (0 == map_hdr->default_error) {
		printi(0, RNPREF "default\t0x");
		p = ((unsigned char *)(map_hdr + 1) +
			(tbl_hdr->number *
			(map_hdr->source_len + map_hdr->result_len + 1)) +
			map_hdr->source_len + 1);
		for (j = 0; j < map_hdr->result_len; j++, p++) {
			printi(0, "%02x", *p);
		}
		printi(0, "\n");
	} else if (-1 == map_hdr->default_error) {
		printi(0, RNPREF "default\t" RNPREF "default\n");
	}
	p = (unsigned char *)(map_hdr + 1);
	for (i = 0; i < tbl_hdr->number; i++) {
		printi(0, "0x");
		for (j = 0; j < map_hdr->source_len; j++, p++) {
			printi(0, "%02x", *p);
		}

		if (0 != (*p)) {
			p += map_hdr->result_len + 1;
			printi(0, "\terror");
		} else {
			p++;
			printi(0, "\t0x");
			for (j = 0; j < map_hdr->result_len; j++, p++) {
				printi(0, "%02x", *p);
			}
		}
		printi(0, "\n");
	}
	printi(-1, "};\n");
}

/*
 * Dump map-hash
 */
static void
dump_map_hash(itm_hdr_t		*itm_hdr, itm_place_t map_place, int standalone)
{
	itm_tbl_hdr_t		*tbl_hdr;
	itm_map_hash_hdr_t	*map_hdr;
	itm_num_t		i;
	itm_num_t		j;
	unsigned char		*p;
	unsigned char		*map_hash;
	unsigned char		*map_error;
	char			*name;

	TRACE_MESSAGE('d', ("dump_map_hash\n"));

	tbl_hdr = (itm_tbl_hdr_t *)ADDR(map_place);
	map_hdr = (itm_map_hash_hdr_t *)(tbl_hdr + 1);
	map_error = (unsigned char *)(map_hdr + 1);
	map_hash = (map_error + map_hdr->hash_tbl_num);

	if ((standalone) &&
	    (0 == tbl_hdr->name.itm_ptr) &&
	    (map_place.itm_ptr != itm_hdr->direc_init_tbl.itm_ptr)) {
		return;
	}

	TRACE_MESSAGE('p', ("(&)map=%ld ", map_place.itm_ptr));

	if (0 == tbl_hdr->name.itm_ptr) {
		name = NULL;
	} else {
		name = tbl_name(itm_hdr, tbl_hdr);
	}

	if ((0 == standalone) && (0 != tbl_hdr->name.itm_ptr)) {
		if (NULL != name) {
			printi(0, "%s;\n", name);
		} else {
			printi(0, RNPREF "unknown;\n", name);
		}
		return;
	} else {
		printi(1, RNPREF "map");
		if (NULL != name) {
			printi(0, " %s", name);
		}
		printi(0, " {\n");
	}

	printi(0, "//  hashed map\n");
	printi(0, "//  number=%ld\n",
		tbl_hdr->number);
	printi(0, "//  source_len=%ld result_len=%ld\n",
		map_hdr->source_len, map_hdr->result_len);
	printi(0, "//  hash_tbl_size=%ld hash_of_size=%ld hash_of_num=%ld\n",
		map_hdr->hash_tbl_size,
		map_hdr->hash_of_size, map_hdr->hash_of_num);
	if (0 < map_hdr->error_num) {
		printi(0, "//  error_num=%ld\n",
			map_hdr->error_num);
	}


	if (0 == map_hdr->default_error) {
		printi(0, RNPREF "default\t0x");
		p = map_hash + map_hdr->hash_tbl_size +
			map_hdr->hash_of_size;
		for (j = 0; j < map_hdr->result_len; j++, p++) {
			printi(0, "%02x", *p);
		}
		printi(0, "\n");
	} else if (-1 == map_hdr->default_error) {
		printi(0, RNPREF "default\t" RNPREF "default\n");
	}
	p = map_hash;
	TRACE_MESSAGE('d', ("dump_map_hash: %ld %ld\n",
			tbl_hdr->number, map_hdr->hash_of_num));
	for (i = 0; i < map_hdr->hash_tbl_num; i++) {
		TRACE_MESSAGE('d', ("dump_map_hash: %x (0x%08p)\n", *p, p));
		if (0 == *(map_error + i)) {
			p += (map_hdr->source_len + 1 + map_hdr->result_len);
			continue;
		}
		printi(0, "0x");
		for (j = 0; j < map_hdr->source_len; j++, p++) {
			printi(0, "%02x", *p);
		}

		if (0 != (*p)) {
			p += map_hdr->result_len + 1;
			printi(0, "\terror");
		} else {
			p++;
			printi(0, "\t0x");
			for (j = 0; j < map_hdr->result_len; j++, p++) {
				printi(0, "%02x", *p);
			}
		}
		printi(0, "\n");
	}
	printi(0, "// of table\n");
	for (i = 0; i < map_hdr->hash_of_num; i++) {
		printi(0, "0x");
		for (j = 0; j < map_hdr->source_len; j++, p++) {
			printi(0, "%02x", *p);
		}
		if (0 != (*p)) {
			p += map_hdr->result_len + 1;
			printi(0, "\terror\n");
		} else {
			p++;
			printi(0, "\t0x");
			for (j = 0; j < map_hdr->result_len; j++, p++) {
				printi(0, "%02x", *p);
			}
			printi(0, "\n");
		}
	}
	printi(-1, "};\n");
}


/*
 * Dump map-dense-encoding
 */
static void
dump_map_dense_enc(itm_hdr_t	*itm_hdr, itm_place_t map_place, int standalone)
{
	itm_tbl_hdr_t			*tbl_hdr;
	itm_map_dense_enc_hdr_t		*map_hdr;
	itm_num_t			i;
	itm_num_t			j;
	unsigned char			*p;
	unsigned char			*map_ptr;
	unsigned char			*map_error;
	unsigned char			*byte_seq_min;
	unsigned char			*byte_seq_max;
	char				*name;
	int				error_flag;

	TRACE_MESSAGE('d', ("dump_map_dense_enc\n"));

	tbl_hdr = (itm_tbl_hdr_t *)ADDR(map_place);
	map_hdr = (itm_map_dense_enc_hdr_t *)(tbl_hdr + 1);
	map_ptr = ((unsigned char *)(map_hdr + 1) +
			map_hdr->source_len + map_hdr->source_len);

	if (0 < map_hdr->error_num) {
		map_error = (map_ptr +
			(tbl_hdr->number * map_hdr->result_len));
		if (0 == map_hdr->default_error) {
			map_error += map_hdr->result_len;
		}
	} else if (1 == map_hdr->default_error) {
		map_error = (map_ptr +
			(tbl_hdr->number * map_hdr->result_len));
	} else {
		map_error = NULL;
	}
	byte_seq_min = (unsigned char *)(map_hdr + 1);
	byte_seq_max = byte_seq_min + map_hdr->source_len;

	if ((standalone) &&
	    (0 == tbl_hdr->name.itm_ptr) &&
	    (map_place.itm_ptr != itm_hdr->direc_init_tbl.itm_ptr)) {
		return;
	}

	TRACE_MESSAGE('p', ("(&)map=%ld ", map_place.itm_ptr));

	if (0 == tbl_hdr->name.itm_ptr) {
		name = NULL;
	} else {
		name = tbl_name(itm_hdr, tbl_hdr);
	}

	if ((0 == standalone) && (0 != tbl_hdr->name.itm_ptr)) {
		if (NULL != name) {
			printi(0, "%s;\n", name);
		} else {
			printi(0, RNPREF "unknown;\n", name);
		}
		return;
	} else {
		printi(1, RNPREF "map");
		if (NULL != name) {
			printi(0, " %s", name);
		}
		printi(0, " {\n");
	}

	printi(0, "//  dense encoded map\n");
	printi(0, "//  entry_number=%ld\n", tbl_hdr->number);
	printi(0, "//  source_len=%ld result_len=%ld\n",
		map_hdr->source_len, map_hdr->result_len);
	printi(0, "//  byte_seq_min=0x");
	p = byte_seq_min;
	for (i = 0; i < map_hdr->source_len; i++, p++) {
		printi(0, "%02x", *p);
	}
	printi(0, "\n");
	printi(0, "//  byte_seq_max=0x");
	p = byte_seq_max;
	for (i = 0; i < map_hdr->source_len; i++, p++) {
		printi(0, "%02x", *p);
	}
	printi(0, "\n");
	if (0 < map_hdr->error_num) {
		printi(0, "//  error_num=%ld\n",
			map_hdr->error_num);
	}
	if (0 == map_hdr->default_error) {
		p = (map_ptr + (tbl_hdr->number * map_hdr->result_len));
		printi(0, RNPREF "default 0x");
		for (j = 0; j < map_hdr->result_len; j++) {
			printi(0, "%02x", *(p + j));
		}
		printi(0, "\n");
	} else if (-1 == map_hdr->default_error) {
		printi(0, RNPREF "default\t" RNPREF "default\n");
	}

	error_flag = 0;
	for (i = 0, p = map_ptr; i < tbl_hdr->number;
	    i++, p += map_hdr->result_len) {
		if ((NULL == map_error) || (0 == *(map_error + i))) {
			printi(0, "%s\t",
				dense_enc_index_to_byte_seq(
					i, map_hdr->source_len,
					byte_seq_min, byte_seq_max));
			printi(0, "0x");
			for (j = 0; j < map_hdr->result_len; j++) {
				printi(0, "%02x", *(p + j));
			}
			printi(0, "\n");
			error_flag = 0;
		} else	if (0 >= map_hdr->default_error) {
			if (0 == error_flag) {
				printi(0, "%s\t",
					dense_enc_index_to_byte_seq(
					i, map_hdr->source_len,
					byte_seq_min, byte_seq_max));
				printi(0, "error\n");
				error_flag = 1;
			} else if (error_flag == 1) {
				printi(0, " :\t:\n");
				error_flag = 2;
			}
		}
	}
	printi(-1, "};\n");
}


/*
 * Evaluate condition table
 */
static void
dump_cond_tbl(itm_hdr_t *itm_hdr, itm_place_t cond_place, int standalone)
{
	itm_tbl_hdr_t	*cond_hdr;
	itm_cond_t	*cond;
	long		i;
	char		*name;

	TRACE_MESSAGE('p', ("(&)cond_tbl=%ld ", cond_place.itm_ptr));
	cond_hdr = (itm_tbl_hdr_t *)(ADDR(cond_place));
	cond = (itm_cond_t *)(cond_hdr + 1);

	if ((standalone) && (0 == cond_hdr->name.itm_ptr)) {
		TRACE_MESSAGE('t', ("skip condition(%d, %ld)\n",
		standalone, cond_hdr->name.itm_ptr));
		return;
	}

	if (0 == cond_place.itm_ptr) {
		printi(0, RNPREF "true");
		return;
	}

	if (0 == cond_hdr->name.itm_ptr) {
		name = NULL;
	} else {
		name = tbl_name(itm_hdr, cond_hdr);
	}

	if ((0 == standalone) && (0 != cond_hdr->name.itm_ptr)) {
		if (NULL != name) {
			printi(0, "%s", name);
		} else {
			printi(0, RNPREF "unknown");
		}
		return;
	} else {
		printi(1, RNPREF "condition");
		if (NULL != name) {
			printi(0, " %s", name);
		}
		printi(0, " {\n");
	}

	for (i = 0; i < cond_hdr->number; i++, cond++) {
		switch (cond->type) {
		case ITM_COND_BETWEEN:
			dump_range(itm_hdr, cond->operand.place);
			break;
		case ITM_COND_EXPR:
			dump_expr(itm_hdr, cond->operand.place);
			printi(0, ";\n");
			break;
		case ITM_COND_ESCAPESEQ:
			dump_escapeseq(itm_hdr, cond->operand.place);
			break;
		default:
			printi(0, "// unknown %d\n", cond->type);
			break;
		}
	}

	if (standalone) {
		printi(-1, "};\n");
	} else {
		printi(-1, "}");
	}
}


/*
 * Dump operation table
 */
static void
dump_op_tbl(itm_hdr_t	*itm_hdr, itm_place_t op_tbl_place, int standalone)
{
	itm_tbl_hdr_t	*op_hdr;
	itm_op_t	*operation;
	itm_place2_t	op_place;
	long		i;
	char		*name;
	static int	op_tbl_level;

	op_hdr = (itm_tbl_hdr_t *)(ADDR(op_tbl_place));
	operation = (itm_op_t *)(op_hdr + 1);
	TRACE_MESSAGE('p', ("(&)op_tbl=%ld ", op_tbl_place));

	name = tbl_name(itm_hdr, op_hdr);

	if ((standalone) && (NULL == name))
		return;

	if (0 == op_tbl_level) {
		if ((0 == standalone) && (0 != op_hdr->name.itm_ptr)) {
			if (NULL != name) {
				printi(0, "%s;\n", name);
			} else {
				printi(0, RNPREF "unknown;", name);
			}
			return;
		} else {
			printi(1, RNPREF "operation");
			if (NULL != name) {
				printi(0, " %s", name);
			}
			printi(0, " {\n");
		}
	}

	op_tbl_level += 1;

	op_place = op_tbl_place.itm_ptr + (sizeof (itm_tbl_hdr_t));
	for (i = 0; i < op_hdr->number;
	    i++, operation++, op_place += (sizeof (itm_op_t))) {
		dump_op(itm_hdr, op_place);
	}

	op_tbl_level -= 1;

	if (0 == op_tbl_level) {
		printi(-1, "};\n");
	}
}


/*
 * Evaluate single operation
 */
static void
dump_op(itm_hdr_t	*itm_hdr, itm_place2_t op_place)
{
	itm_op_t	*operation;
	itm_tbl_hdr_t	*op_hdr;

	operation = (itm_op_t *)ADDR2(op_place);
	TRACE_MESSAGE('p', ("(&)op=%ld ", op_place));

	switch (operation->type) {
	case ITM_OP_EXPR:
		dump_expr(itm_hdr, operation->data.operand[0]);
		printi(0, ";\n");
		break;
	case ITM_OP_ERROR:
		printi(0, RNPREF "error ");
		dump_expr(itm_hdr, operation->data.operand[0]);
		printi(0, ";\n");
		break;
	case ITM_OP_ERROR_D:
		printi(0, RNPREF "error %d;",
			operation->data.operand[0].itm_ptr);
		printi(0, "\n");
		break;
	case ITM_OP_DISCARD:
		printi(0, RNPREF "discard ");
		dump_expr(itm_hdr, operation->data.operand[0]);
		printi(0, ";\n");
		break;
	case ITM_OP_DISCARD_D:
		printi(0, RNPREF "discard %ld;\n",
			operation->data.operand[0].itm_ptr);
		break;
	case ITM_OP_OUT:
	case ITM_OP_OUT_D:
	case ITM_OP_OUT_R:
	case ITM_OP_OUT_S:
	case ITM_OP_OUT_INVD:
		printi(0, RNPREF "out = ");
		dump_expr(itm_hdr, operation->data.operand[0]);
		printi(0, ";\n");
		break;
	case ITM_OP_IF:
		printi(0, RNPREF "if ");
		dump_expr(itm_hdr, operation->data.operand[0]);
		printi(1, " {\n");
		dump_op_tbl(itm_hdr, operation->data.operand[1], 0);
		printi(-1, "}\n");
		break;
	case ITM_OP_IF_ELSE:
		printi(0, RNPREF "if ");
		dump_expr(itm_hdr, operation->data.operand[0]);
		printi(1, " {\n");
		dump_op_tbl(itm_hdr, operation->data.operand[1], 0);
		printi(-1, "} ");
		op_hdr = ADDR(operation->data.operand[2]);
		if ((1 == op_hdr->number) &&
		    ((ITM_OP_IF_ELSE == ((itm_op_t *)(op_hdr + 1))->type) ||
		    (ITM_OP_IF == ((itm_op_t *)(op_hdr + 1))->type))) {
			printi(0, RNPREF "else ");
			dump_op_tbl(itm_hdr, operation->data.operand[2], 0);
		} else {
			printi(1, RNPREF "else {\n");
			dump_op_tbl(itm_hdr, operation->data.operand[2], 0);
			printi(-1, "}\n");
		}
		break;
	case ITM_OP_DIRECTION: /* switch direction */
		printi(0, RNPREF "direction %1$s;\n", tbl_name(itm_hdr,
			(itm_tbl_hdr_t *)ADDR(operation->data.operand[0])));
		break;
	case ITM_OP_MAP:	/* use map */
		printi(0, RNPREF "map %1$s", tbl_name(itm_hdr,
			(itm_tbl_hdr_t *)ADDR(operation->data.operand[0])));
		if (0 != operation->data.operand[1].itm_ptr) {
			printi(0, " ");
			dump_expr(itm_hdr, operation->data.operand[1]);
		}
		printi(0, ";\n");
		break;
	case ITM_OP_OPERATION: /* invoke operation */
		printi(0, RNPREF "operation %1$s;\n",
			tbl_name(itm_hdr,
			(itm_tbl_hdr_t *)ADDR(operation->data.operand[0])));
		break;
	case ITM_OP_INIT: /* invoke init operation */
		printi(0, RNPREF "operation " RNPREF "init;\n");
		break;
	case ITM_OP_RESET: /* invoke reset operation */
		printi(0, RNPREF "operation " RNPREF "reset;\n");
		break;
	case ITM_OP_BREAK: /* break */
		printi(0, RNPREF "break;\n");
		break;
	case ITM_OP_RETURN: /* return */
		printi(0, RNPREF "return;\n");
		break;
	case ITM_OP_PRINTCHR:
		printi(0, RNPREF "printchr ");
		dump_expr(itm_hdr, operation->data.operand[0]);
		printi(0, ";\n");
		break;
	case ITM_OP_PRINTHD:
		printi(0, RNPREF "printhd ");
		dump_expr(itm_hdr, operation->data.operand[0]);
		printi(0, ";\n");
		break;
	case ITM_OP_PRINTINT:
		printi(0, RNPREF "printint ");
		dump_expr(itm_hdr, operation->data.operand[0]);
		printi(0, ";\n");
		break;
	default:
		printi(0, "// unknown operation: %lx\n", operation->type);
		break;
	}
}


/*
 * Dump expression
 */
static void
dump_expr(itm_hdr_t	*itm_hdr, itm_place_t expr_place)
{
	itm_expr_t	*expr;
	itm_data_t	data;

	expr = (itm_expr_t *)ADDR(expr_place);
	TRACE_MESSAGE('p', ("(*)ex=%ld ", expr_place.itm_ptr));

	switch (expr->type) {
	case ITM_EXPR_NONE:		/* not used */
		printi(0, "none");
		break;
	case ITM_EXPR_NOP:		/* not used */
		printi(0, "NOP");
		break;
	case ITM_EXPR_NAME:		/* not used */
		printi(0, "NAME");
		break;
	case ITM_EXPR_INT:		/* integer */
		printi(0, "%ld", expr->data.itm_exnum);
		break;
	case ITM_EXPR_SEQ:		/* byte sequence */
		data = expr->data.value;
		if ((sizeof (itm_place_t)) < data.size) {
			data.place.itm_ptr = (itm_place2_t)ADDR(data.place);
		}
		printi(0, "0x%s", data_to_hexadecimal(&data));
		break;
	case ITM_EXPR_REG:		/* register */
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		break;
	case ITM_EXPR_IN_VECTOR:	/* in[expr] */
		printi(0, RNPREF "in[");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, "]");
		break;
	case ITM_EXPR_IN_VECTOR_D:	/* in[num] */
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		if (0 == expr->data.operand[0].itm_ptr) {
			printi(0, " // inputsize");
		}
		break;
	case ITM_EXPR_OUT:		/* out */
		printi(0, RNPREF "out");
		break;
	case ITM_EXPR_TRUE:		/* true */
		printi(0, RNPREF "true");
		break;
	case ITM_EXPR_FALSE:		/* false */
		printi(0, RNPREF "false");
		break;
	case ITM_EXPR_UMINUS:		/* unary minus */
		printi(0, "-");
		dump_expr(itm_hdr, expr->data.operand[0]);
		break;
	case ITM_EXPR_PLUS:		/* A  + B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " + ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_E_D:		/* exprA + B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " + ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_E_R:		/* exprA + varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " + ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_E_INVD:	/* exprA + in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " + ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_D_E:		/* intA + exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " + ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_D_D:		/* intA + B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " + ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_D_R:		/* intA + varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " + ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_D_INVD:	/* intA + in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " + ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_R_E:		/* varA + exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " + ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_R_D:		/* varA + B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " + ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_R_R:		/* varA + varB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " + ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_R_INVD:	/* varA + in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " + ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_INVD_E:	/* in[A] + exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " + ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_INVD_D:	/* in[A] + B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " + ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_INVD_R:	/* in[A] + varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " + ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_PLUS_INVD_INVD:	/* in[A] + in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " + ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS:		/* A  - B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " - ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_E_D:		/* exprA - B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " - ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_E_R:		/* exprA - varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " - ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_E_INVD:	/* exprA - in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " - ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_D_E:		/* intA - exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " - ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_D_D:		/* intA - B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " - ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_D_R:		/* intA - varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " - ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_D_INVD:	/* intA - in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " - ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_R_E:		/* varA - exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " - ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_R_D:		/* varA - B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " - ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_R_R:		/* varA - varB */
		printi(0, "(");
		printi(0, " - ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_R_INVD:	/* varA - in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " - ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_INVD_E:	/* in[A] - exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " - ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_INVD_D:	/* in[A] - B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " - ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_INVD_R:	/* in[A] - varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " - ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_MINUS_INVD_INVD:	/* in[A] - in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " - ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MUL:		/* A  * B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " * ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_E_D:		/* exprA * B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " * ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_E_R:		/* exprA * varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " * ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_E_INVD:	/* exprA * in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " * ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_D_E:		/* intA * exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " * ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_D_D:		/* intA * B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " * ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_D_R:		/* intA * varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " * ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_D_INVD:	/* intA * in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " * ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_R_E:		/* varA * exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " * ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_R_D:		/* varA * B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " * ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_R_R:		/* varA * varB */
		printi(0, "(");
		printi(0, " * ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_R_INVD:	/* varA * in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " * ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_INVD_E:	/* in[A] * exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " * ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_INVD_D:	/* in[A] * B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " * ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_INVD_R:	/* in[A] * varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " * ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_MUL_INVD_INVD:	/* in[A] * in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " * ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_DIV:		/* A  / B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " / ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_E_D:		/* exprA / B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " / ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_E_R:		/* exprA / varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " / ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_E_INVD:	/* exprA / in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " / ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_D_E:		/* intA / exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " / ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_D_D:		/* intA / B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " / ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_D_R:		/* intA / varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " / ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_D_INVD:	/* intA / in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " / ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_R_E:		/* varA / exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " / ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_R_D:		/* varA / B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " / ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_R_R:		/* varA / varB */
		printi(0, "(");
		printi(0, " / ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_R_INVD:	/* varA / in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " / ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_INVD_E:	/* in[A] / exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " / ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_INVD_D:	/* in[A] / B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " / ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_INVD_R:	/* in[A] / varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " / ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_DIV_INVD_INVD:	/* in[A] / in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " / ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MOD:		/* A  % B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " %% ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_E_D:		/* exprA % B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " %% ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_E_R:		/* exprA % varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " %% ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_E_INVD:	/* exprA % in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " %% ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_D_E:		/* intA % exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " %% ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_D_D:		/* intA % B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " %% ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_D_R:		/* intA % varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " %% ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_D_INVD:	/* intA % in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " %% ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_R_E:		/* varA % exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " %% ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_R_D:		/* varA % B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " %% ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_R_R:		/* varA % varB */
		printi(0, "(");
		printi(0, " %% ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_R_INVD:	/* varA % in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " %% ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_INVD_E:	/* in[A] % exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " %% ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_INVD_D:	/* in[A] % B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " %% ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_INVD_R:	/* in[A] % varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " %% ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_MOD_INVD_INVD:	/* in[A] % in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " %% ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L:		/* A << B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " << ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_E_D:		/* exprA << B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " << ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_E_R:		/* exprA << varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " << ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_E_INVD:	/* exprA << in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " << ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_D_E:		/* intA << exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " << ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_D_D:		/* intA << B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " << ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_D_R:		/* intA << varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " << ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_D_INVD:	/* intA << in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " << ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_R_E:		/* varA << exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " << ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_R_D:		/* varA << B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " << ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_R_R:		/* varA << varB */
		printi(0, "(");
		printi(0, " << ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_R_INVD:	/* varA << in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " << ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_INVD_E:	/* in[A] << exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " << ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_INVD_D:	/* in[A] << B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " << ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_INVD_R:	/* in[A] << varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " << ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_L_INVD_INVD:	/* in[A] << in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " << ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R:		/* A >> B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " >> ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_E_D:		/* exprA >> B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " >> ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_E_R:		/* exprA >> varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " >> ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_E_INVD:	/* exprA >> in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " >> ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_D_E:		/* intA >> exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " >> ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_D_D:		/* intA >> B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " >> ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_D_R:		/* intA >> varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " >> ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_D_INVD:	/* intA >> in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " >> ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_R_E:		/* varA >> exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " >> ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_R_D:		/* varA >> B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " >> ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_R_R:		/* varA >> varB */
		printi(0, "(");
		printi(0, " >> ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_R_INVD:	/* varA >> in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " >> ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_INVD_E:	/* in[A] >> exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " >> ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_INVD_D:	/* in[A] >> B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " >> ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_INVD_R:	/* in[A] >> varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " >> ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_SHIFT_R_INVD_INVD:	/* in[A] >> in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " >> ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_OR:		/* A  | B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " | ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_OR_E_D:		/* exprA | B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " | ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_OR_E_R:		/* exprA | varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " | ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_OR_E_INVD:	/* exprA | in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " | ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_OR_D_E:		/* intA | exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " | ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_OR_D_D:		/* intA | B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " | ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_OR_D_R:		/* intA | varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " | ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_OR_D_INVD:	/* intA | in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " | ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_OR_R_E:		/* varA | exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " | ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_OR_R_D:		/* varA | B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " | ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_OR_R_R:		/* varA | varB */
		printi(0, "(");
		printi(0, " | ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, ")");
		break;
	case ITM_EXPR_OR_R_INVD:	/* varA | in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " | ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_OR_INVD_E:	/* in[A] | exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " | ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_OR_INVD_D:	/* in[A] | B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " | ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_OR_INVD_R:	/* in[A] | varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " | ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_OR_INVD_INVD:	/* in[A] | in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " | ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_XOR:		/* A  ^ B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " ^ ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_E_D:		/* exprA ^ B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " ^ ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_E_R:		/* exprA ^ varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " ^ ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_E_INVD:	/* exprA ^ in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " ^ ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_D_E:		/* intA ^ exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " ^ ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_D_D:		/* intA ^ B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " ^ ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_D_R:		/* intA ^ varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " ^ ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_D_INVD:	/* intA ^ in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " ^ ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_R_E:		/* varA ^ exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " ^ ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_R_D:		/* varA ^ B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " ^ ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_R_R:		/* varA ^ varB */
		printi(0, "(");
		printi(0, " ^ ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_R_INVD:	/* varA ^ in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " ^ ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_INVD_E:	/* in[A] ^ exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " ^ ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_INVD_D:	/* in[A] ^ B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " ^ ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_INVD_R:	/* in[A] ^ varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " ^ ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_XOR_INVD_INVD:	/* in[A] ^ in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " ^ ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_AND:		/* A  & B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " & ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_AND_E_D:		/* exprA & B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " & ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_AND_E_R:		/* exprA & varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " & ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_AND_E_INVD:	/* exprA & in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " & ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_AND_D_E:		/* intA & exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " & ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_AND_D_D:		/* intA & B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " & ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_AND_D_R:		/* intA & varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " & ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_AND_D_INVD:	/* intA & in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " & ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_AND_R_E:		/* varA & exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " & ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_AND_R_D:		/* varA & B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " & ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_AND_R_R:		/* varA & varB */
		printi(0, "(");
		printi(0, " & ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, ")");
		break;
	case ITM_EXPR_AND_R_INVD:	/* varA & in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " & ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_AND_INVD_E:	/* in[A] & exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " & ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_AND_INVD_D:	/* in[A] & B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " & ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_AND_INVD_R:	/* in[A] & varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " & ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_AND_INVD_INVD:	/* in[A] & in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " & ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_EQ:		/* A == B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " == ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_E_D:		/* exprA == B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " == ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_E_R:		/* exprA == varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " == ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_E_INVD:	/* exprA == in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " == ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_D_E:		/* intA == exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " == ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_D_D:		/* intA == B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " == ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_D_R:		/* intA == varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " == ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_D_INVD:	/* intA == in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " == ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_R_E:		/* varA == exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " == ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_R_D:		/* varA == B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " == ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_R_R:		/* varA == varB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " == ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_R_INVD:	/* varA == in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " == ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_INVD_E:	/* in[A] == exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " == ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_INVD_D:	/* in[A] == B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " == ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_INVD_R:	/* in[A] == varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " == ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_EQ_INVD_INVD:	/* in[A] == in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " == ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_NE:		/* A != B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " != ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_NE_E_D:		/* exprA != B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " != ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_NE_E_R:		/* exprA != varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " != ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_NE_E_INVD:	/* exprA != in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " != ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_NE_D_E:		/* intA != exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " != ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_NE_D_D:		/* intA != B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " != ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_NE_D_R:		/* intA != varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " != ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_NE_D_INVD:	/* intA != in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " != ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_NE_R_E:		/* varA != exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " != ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_NE_R_D:		/* varA != B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " != ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_NE_R_R:		/* varA != varB */
		printi(0, "(");
		printi(0, " != ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, ")");
		break;
	case ITM_EXPR_NE_R_INVD:	/* varA != in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " != ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_NE_INVD_E:	/* in[A] != exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " != ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_NE_INVD_D:	/* in[A] != B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " != ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_NE_INVD_R:	/* in[A] != varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " != ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_NE_INVD_INVD:	/* in[A] != in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " != ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GT:		/* A  > B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " > ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_GT_E_D:		/* exprA > B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " > ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GT_E_R:		/* exprA > varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " > ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_GT_E_INVD:	/* exprA > in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " > ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GT_D_E:		/* intA > exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " > ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_GT_D_D:		/* intA > B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " > ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GT_D_R:		/* intA > varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " > ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_GT_D_INVD:	/* intA > in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " > ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GT_R_E:		/* varA > exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " > ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_GT_R_D:		/* varA > B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " > ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GT_R_R:		/* varA > varB */
		printi(0, "(");
		printi(0, " > ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, ")");
		break;
	case ITM_EXPR_GT_R_INVD:	/* varA > in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " > ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GT_INVD_E:	/* in[A] > exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " > ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_GT_INVD_D:	/* in[A] > B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " > ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GT_INVD_R:	/* in[A] > varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " > ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_GT_INVD_INVD:	/* in[A] > in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " > ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GE:		/* A >= B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " >= ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_GE_E_D:		/* exprA >= B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " >= ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GE_E_R:		/* exprA >= varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " >= ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_GE_E_INVD:	/* exprA >= in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " >= ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GE_D_E:		/* intA >= exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " >= ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_GE_D_D:		/* intA >= B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " >= ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GE_D_R:		/* intA >= varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " >= ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_GE_D_INVD:	/* intA >= in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " >= ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GE_R_E:		/* varA >= exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " >= ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_GE_R_D:		/* varA >= B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " >= ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GE_R_R:		/* varA >= varB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " >= ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_GE_R_INVD:	/* varA >= in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " >= ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GE_INVD_E:	/* in[A] >= exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " >= ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_GE_INVD_D:	/* in[A] >= B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " >= ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_GE_INVD_R:	/* in[A] >= varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " >= ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_GE_INVD_INVD:	/* in[A] >= in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " >= ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LT:		/* A  < B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " < ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_LT_E_D:		/* exprA < B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " < ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LT_E_R:		/* exprA < varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " < ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_LT_E_INVD:	/* exprA < in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " < ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LT_D_E:		/* intA < exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " < ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_LT_D_D:		/* intA < B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " < ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LT_D_R:		/* intA < varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " < ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_LT_D_INVD:	/* intA < in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " < ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LT_R_E:		/* varA < exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " < ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_LT_R_D:		/* varA < B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " < ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LT_R_R:		/* varA < varB */
		printi(0, "(");
		printi(0, " < ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, ")");
		break;
	case ITM_EXPR_LT_R_INVD:	/* varA < in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " < ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LT_INVD_E:	/* in[A] < exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " < ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_LT_INVD_D:	/* in[A] < B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " < ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LT_INVD_R:	/* in[A] < varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " < ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_LT_INVD_INVD:	/* in[A] < in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " < ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LE:		/* A <= B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " <= ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_LE_E_D:		/* exprA <= B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " <= ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LE_E_R:		/* exprA <= varB */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " <= ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_LE_E_INVD:	/* exprA <= in[B] */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " <= ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LE_D_E:		/* intA <= exprB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " <= ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_LE_D_D:		/* intA <= B */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " <= ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LE_D_R:		/* intA <= varB */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " <= ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_LE_D_INVD:	/* intA <= in[B] */
		printi(0, "(");
		printi(0, "%ld", expr->data.operand[0].itm_ptr);
		printi(0, " <= ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LE_R_E:		/* varA <= exprB */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " <= ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_LE_R_D:		/* varA <= B */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " <= ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LE_R_R:		/* varA <= varB */
		printi(0, "(");
		printi(0, " <= ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, ")");
		break;
	case ITM_EXPR_LE_R_INVD:	/* varA <= in[B] */
		printi(0, "(");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[0]));
		printi(0, " <= ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LE_INVD_E:	/* in[A] <= exprB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " <= ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_LE_INVD_D:	/* in[A] <= B */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " <= ");
		printi(0, "%ld", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_LE_INVD_R:	/* in[A] <= varB */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " <= ");
		printi(0, "%s", reg_name(itm_hdr, expr->data.operand[1]));
		printi(0, ")");
		break;
	case ITM_EXPR_LE_INVD_INVD:	/* in[A] <= in[B] */
		printi(0, "(");
		printi(0, RNPREF "in[%ld]", expr->data.operand[0].itm_ptr);
		printi(0, " <= ");
		printi(0, RNPREF "in[%ld]", expr->data.operand[1].itm_ptr);
		printi(0, ")");
		break;
	case ITM_EXPR_NOT:		/*   !A	  */
		printi(0, "(");
		printi(0, "!");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, ")");
		break;
	case ITM_EXPR_NEG:		/*   ~A	  */
		printi(0, "(");
		printi(0, " ~");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, ")");
		break;
	case ITM_EXPR_LOR:		/* A || B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " || ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_LAND:		/* A && B */
		printi(0, "(");
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, " && ");
		dump_expr(itm_hdr, expr->data.operand[1]);
		printi(0, ")");
		break;
	case ITM_EXPR_ASSIGN:		/* A  = B */
		printi(0, "%s = ", reg_name(itm_hdr, expr->data.operand[0]));
		dump_expr(itm_hdr, expr->data.operand[1]);
		break;
	case ITM_EXPR_IN_EQ:		/* in == A */
		printi(0, "(" RNPREF "in == ", 0);
		dump_expr(itm_hdr, expr->data.operand[0]);
		printi(0, ")");
		break;
	default:
		break;
	}
}


/*
 * Dump range (between)
 */
static void
dump_range(itm_hdr_t	*itm_hdr, itm_place_t range_place)
{
	itm_tbl_hdr_t	*rth;
	itm_range_hdr_t	*rtsh;
	unsigned char	*p;
	long		i;
	long		j;

	rth = (itm_tbl_hdr_t *)(ADDR(range_place));
	rtsh = (itm_range_hdr_t *)(rth + 1);
	p = (unsigned char *)(rtsh + 1);

	TRACE_MESSAGE('p', ("(&)between=%ld ", range_place.itm_ptr));
	printi(0, RNPREF "between ");
	for (i = 0; i < rth->number; i++) {
		if (0 != i)	printi(0, "\t ");
		printi(0, "0x");
		for (j = 0; j < rtsh->len; j++) {
			printi(0, "%02x", *(p++));
		}
		printi(0, " - ");
		printi(0, "0x");
		for (j = 0; j < rtsh->len; j++) {
			printi(0, "%02x", *(p++));
		}
		if (i < (rth->number - 1)) {
			printi(0, ",\n");
		} else {
			printi(0, ";\n");
		}
	}
}


/*
 * Dump escape sequence
 */
static void
dump_escapeseq(itm_hdr_t	*itm_hdr, itm_place_t escapeseq_place)
{
	itm_tbl_hdr_t		*eth;
	itm_escapeseq_hdr_t	*eh;
	itm_data_t		*d;
	itm_data_t		data;

	long			i;


	eth = (itm_tbl_hdr_t *)(ADDR(escapeseq_place));
	eh = (itm_escapeseq_hdr_t *)(eth + 1);
	d = (itm_data_t *)(eh + 1);
	TRACE_MESSAGE('p', ("(&)escseq=%ld ", escapeseq_place.itm_ptr));
	printi(1, RNPREF "escapceseq {");

	for (i = 0; i < eth->number; i++, d++) {
		if (0 != i)	printi(0, " ");
		data = *d;
		if ((sizeof (itm_place_t)) < data.size) {
			data.place.itm_ptr = (itm_place2_t)ADDR(d->place);
		}
		printi(0, "0x%s;", data_to_hexadecimal(&data));
	}
	printi(-1, "}\n");
}


static void
printi(int c, char	*format, ...)
{
	static int	indent_level;
	static int	new_line = 1;
	int		i;
	va_list		ap;
	va_start(ap, format);

	if (c < 0) {
		indent_level += c;
		if (indent_level < 0) {
			indent_level = 0;
		}
	}
	if (new_line) {
		for (i = indent_level; 0 < i; i -= 1) {
			(void) putchar('\t');
		}
	}
	if (0 < c) {
		indent_level += c;
		if (indent_level < 0) {
			indent_level = 0;
		}
	}

	if (NULL == strchr(format, '\n')) {
		new_line = 0;
	} else {
		new_line = 1;
	}

	(void) vfprintf(stdout, format, ap);

	va_end(ap);
}


static char *
name_place_to_str(itm_hdr_t	*itm_hdr, itm_place2_t place)
{
	itm_data_t	d;

	if (0 != place) {
		d = *((itm_data_t *)ADDR2(place));
		if ((sizeof (itm_place_t)) < d.size) {
			d.place.itm_ptr = (itm_place2_t)ADDR(d.place);
		}
	} else {
		d.size = 0;
		d.place.itm_ptr = 0;
	}
	return (name_to_str(&d));
}

static char *
tbl_name(itm_hdr_t	*itm_hdr, itm_tbl_hdr_t		*tbl_hdr)
{
	if (ITM_TBL_OP_INIT == tbl_hdr->type) {
		return (RNPREF "init");
	} else if (ITM_TBL_OP_RESET == tbl_hdr->type) {
		return (RNPREF "reset");
	} else if (tbl_hdr->name.itm_ptr) {
		return (name_place_to_str(itm_hdr, tbl_hdr->name.itm_ptr));
	} else {
		return (NULL);
	}
}


static char *
reg_name(itm_hdr_t	*itm_hdr, itm_place_t op)
{
	itm_info_hdr_t		*info_hdr;
	static char		sbuf[32];
	itm_num_t		reg_num;

	reg_num = (itm_num_t)(op.itm_ptr);
	if (0 == itm_hdr->info_hdr.itm_ptr) {
		(void) sprintf(sbuf, "reg%ld\n", reg_num);
		return (sbuf);
	} else {
		info_hdr = INFO_HDR(itm_hdr);
		return (name_place_to_str(
			itm_hdr,
			info_hdr->reg_plc_tbl.place.itm_ptr +
			(reg_num	*sizeof (itm_data_t))));
	}
}

static itm_hdr_t *
itm_attach(const char	*itm_file)
{
	itm_hdr_t	*itm_hdr;
	struct stat	st;
	int		fd;

	fd = open(itm_file, O_RDONLY, 0);
	if (fd == -1) {
		PERROR(gettext("open()"));
		return	(NULL);
	}

	if (fstat(fd, &st) == -1) {
		PERROR(gettext("fstat()"));
		return	(NULL);
	}
	itm_hdr = (void *) mmap(NULL, st.st_size,
				    PROT_READ, MAP_SHARED, fd, 0);
	if (MAP_FAILED == itm_hdr) {
		PERROR(gettext("mmap()"));
		return	(NULL);
	}

	(void) close(fd);

	if ((itm_hdr->ident[0] != ITM_IDENT_0) ||
	    (itm_hdr->ident[1] != ITM_IDENT_1) ||
	    (itm_hdr->ident[2] != ITM_IDENT_2) ||
	    (itm_hdr->ident[3] != ITM_IDENT_3)) {
		itm_error(gettext("magic number error\n"));
		return	(NULL);
	}
	if ((itm_hdr->version[0] != ITM_VER_0) ||
	    (itm_hdr->version[1] != ITM_VER_1) ||
	    (itm_hdr->version[2] != ITM_VER_2) ||
#if defined(_LITTLE_ENDIAN)
#if defined(_LP64)
	    ((itm_hdr->spec[3] != ITM_SPEC_3_32_LITTLE_ENDIAN) &&
	    (itm_hdr->spec[3] != ITM_SPEC_3_64_LITTLE_ENDIAN))) {
#else
	    (itm_hdr->spec[3] != ITM_SPEC_3_32_LITTLE_ENDIAN)) {
#endif
#else
#if defined(_LP64)
	    ((itm_hdr->spec[3] != ITM_SPEC_3_32_BIG_ENDIAN) &&
	    (itm_hdr->spec[3] != ITM_SPEC_3_64_BIG_ENDIAN))) {
#else
	    (itm_hdr->spec[3] != ITM_SPEC_3_32_BIG_ENDIAN)) {
#endif
#endif
		itm_error(gettext("version number error\n"));
		return	(NULL);
	}
	if (itm_hdr->itm_size.itm_ptr != st.st_size) {
		itm_error(gettext(
			"size error: expected=%1$d current=%2$d\n"),
			(size_t)(itm_hdr->itm_size.itm_ptr), st.st_size);
		return (NULL);
	}

	return (itm_hdr);
}