#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"

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 *, ...);

#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) */

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)

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

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);

}

}

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;

}

}

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");

}

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");

}

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");

}

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");

}

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, "}");

}

}

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");

}

}

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;

}

}

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]);