From 9695e5c9051d331278288a071c1353ae7214c4c2 Mon Sep 17 00:00:00 2001 From: patacongo Date: Fri, 18 Dec 2009 16:30:25 +0000 Subject: Update to use stdint/stdbool.h git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@2384 42af7a65-404d-4744-a932-0658087f49c3 --- misc/pascal/insn32/libinsn/pdasm.c | 865 +++++++++++++++++++------------------ 1 file changed, 436 insertions(+), 429 deletions(-) (limited to 'misc/pascal/insn32/libinsn/pdasm.c') diff --git a/misc/pascal/insn32/libinsn/pdasm.c b/misc/pascal/insn32/libinsn/pdasm.c index 0db6db932..75d79d7b6 100644 --- a/misc/pascal/insn32/libinsn/pdasm.c +++ b/misc/pascal/insn32/libinsn/pdasm.c @@ -1,429 +1,436 @@ -/********************************************************************** - * pdasm.c - * P-Code Disassembler - * - * Copyright (C) 2008 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * 3. Neither the name NuttX nor the names of its contributors may be - * used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, - * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS - * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED - * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - * - **********************************************************************/ - -#include - -#include "keywords.h" -#include "podefs.h" -#include "pinsn32.h" -#include "pfdefs.h" -#include "pxdefs.h" -#include "paslib.h" - -#include "pinsn.h" - -/***********************************************************************/ - -/* These are all the format codes that apply to opcodes with an argument */ - -enum { - SIMPLE = 0, /* No argument */ - HEX, /* Hexadecimal argument */ - DECIMAL, /* Signed Decimal argument (w/shift) */ - UDECIMAL, /* Unsigned Decimal argument (w/shift) */ - LABEL_DEC, /* Label number */ - xOP, lbOP, fpOP, /* Sub opcode */ - FILENO, LINENO /* File number, line number */ -}; - -/* The following table defines everything that is needed to disassemble - * a P-Code. NOTE: The order of definition in this table must exactly - * match the declaration sequence in pinsn.h. */ - -static const char invOp[] = "Invalid Opcode"; -struct optab_s -{ - const char *opName; /* Opcode mnemonics */ - ubyte format; /* arg16 format */ -}; - -/******************** OPCODES WITH NO ARGUMENTS *************************/ - -static const struct optab_s g_sNoArgOpTable[64] = -{ - /* Program control (No stack arguments) */ - - /* 0x00 */ { "NOP ", SIMPLE }, - - /* Arithmetic & logical & and integer conversions (One stack argument) */ - - /* 0x01 */ { "NEG ", SIMPLE }, - /* 0x02 */ { "ABS ", SIMPLE }, - /* 0x03 */ { "INC ", SIMPLE }, - /* 0x04 */ { "DEC ", SIMPLE }, - /* 0x05 */ { "NOT ", SIMPLE }, - - /* Arithmetic & logical (Two stack arguments) */ - - /* 0x06 */ { "ADD ", SIMPLE }, - /* 0x07 */ { "SUB ", SIMPLE }, - /* 0x08 */ { "MUL ", SIMPLE }, - /* 0x09 */ { "DIV ", SIMPLE }, - /* 0x0a */ { "MOD ", SIMPLE }, - /* 0x0b */ { "SLL ", SIMPLE }, - /* 0x0c */ { "SRL ", SIMPLE }, - /* 0x0d */ { "SRA ", SIMPLE }, - /* 0x0e */ { "OR ", SIMPLE }, - /* 0x0f */ { "AND ", SIMPLE }, - - /* Comparisons (One stack argument) */ - - /* 0x10 */ { "EQUZ ", SIMPLE }, - /* 0x11 */ { "NEQZ ", SIMPLE }, - /* 0x12 */ { "LTZ ", SIMPLE }, - /* 0x13 */ { "GTEZ ", SIMPLE }, - /* 0x14 */ { "GTZ ", SIMPLE }, - /* 0x15 */ { "LTEZ ", SIMPLE }, - /* 0x16 */ { invOp, SIMPLE }, - /* 0x17 */ { invOp, SIMPLE }, - - /* Comparisons (Two stack arguments) */ - - /* 0x18 */ { "EQU ", SIMPLE }, - /* 0x19 */ { "NEQ ", SIMPLE }, - /* 0x1a */ { "LT ", SIMPLE }, - /* 0x1b */ { "GTE ", SIMPLE }, - /* 0x1c */ { "GT ", SIMPLE }, - /* 0x1d */ { "LTE ", SIMPLE }, - /* 0x1e */ { invOp, SIMPLE }, - /* 0x1f */ { "BIT ", SIMPLE }, - - /* Load (One) or Store (Two stack argument) */ - - /* 0x20 */ { "LDI ", SIMPLE }, - /* 0x21 */ { "LDIH", SIMPLE }, - /* 0x22 */ { "LDIB", SIMPLE }, - /* 0x23 */ { "LDIM", SIMPLE }, - /* 0x24 */ { "STI ", SIMPLE }, - /* 0x25 */ { "STIH", SIMPLE }, - /* 0x26 */ { "STIB", SIMPLE }, - /* 0x27 */ { "STIM", SIMPLE }, - - /* Data stack operations */ - - /* 0x28 */ { "DUP ", SIMPLE }, - /* 0x29 */ { "DUPH ", SIMPLE }, - /* 0x2a */ { "PUSHS", SIMPLE }, - /* 0x2b */ { "POPS", SIMPLE }, - /* 0x2c */ { invOp, SIMPLE }, - /* 0x2d */ { invOp, SIMPLE }, - /* 0x2e */ { invOp, SIMPLE }, - /* 0x2f */ { "RET ", SIMPLE }, - - /* 0x30 */ { invOp, SIMPLE }, - /* 0x31 */ { invOp, SIMPLE }, - /* 0x32 */ { invOp, SIMPLE }, - /* 0x33 */ { invOp, SIMPLE }, - /* 0x34 */ { invOp, SIMPLE }, - /* 0x35 */ { invOp, SIMPLE }, - /* 0x36 */ { invOp, SIMPLE }, - /* 0x37 */ { invOp, SIMPLE }, - - /* System Functions (No stack arguments) */ - - /* 0x38 */ { invOp, SIMPLE }, - /* 0x39 */ { invOp, SIMPLE }, - /* 0x3a */ { invOp, SIMPLE }, - /* 0x3b */ { invOp, SIMPLE }, - /* 0x3c */ { invOp, SIMPLE }, - /* 0x3d */ { invOp, SIMPLE }, - /* 0x3e */ { invOp, SIMPLE }, - /* 0x3f */ { "EXIT ", SIMPLE } -}; - -/****************** OPCODES WITH 25-BIT ARGUMENT ************************/ - -static const struct optab_s g_sArg32OpTable[64] = -{ - /* Load: arg = unsigned base offset */ - - /* 0x80 */ { "LD ", UDECIMAL }, /* No stack arguments */ - /* 0x81 */ { "LDH ", UDECIMAL }, /* No stack arguments */ - /* 0x82 */ { "LDB ", UDECIMAL }, /* No stack arguments */ - /* 0x83 */ { "LDM ", UDECIMAL }, /* One 32-bit stack argument */ - - /* Store: arg = unsigned base offset (One stack arguments) */ - - /* 0x84 */ { "ST ", UDECIMAL }, /* One 32-bit stack argument */ - /* 0x85 */ { "STH ", UDECIMAL }, /* One 32-bit stack argument */ - /* 0x86 */ { "STB ", UDECIMAL }, /* One 32-bit stack argument */ - /* 0x87 */ { "STM ", UDECIMAL }, /* One+n 32-bit stack argument */ - - /* Load Indexed: arg = unsigned base offset */ - - /* 0x88 */ { "LDX ", UDECIMAL }, /* One 32-bit stack argument */ - /* 0x89 */ { "LDXH ", UDECIMAL }, /* One 32-bit stack argument */ - /* 0x8a */ { "LDXB ", UDECIMAL }, /* One 32-bit stack argument */ - /* 0x8b */ { "LDXM ", UDECIMAL }, /* Two 32-bit stack argument */ - - /* Store Indexed: arg = unsigned base offset */ - - /* 0x8c */ { "STX ", UDECIMAL }, /* Two 32-bit stack argument */ - /* 0x8d */ { "STXH ", UDECIMAL }, /* Two 32-bit stack argument */ - /* 0x8e */ { "STXB ", UDECIMAL }, /* Two 32-bit stack argument */ - /* 0x8f */ { "STXM ", UDECIMAL }, /* Two+n 32-bit stack argument */ - - /* Program control: arg = unsigned label (One stack argument) */ - - /* 0x90 */ { "JEQUZ", HEX }, - /* 0x91 */ { "JNEQZ", HEX }, - /* 0x92 */ { "JLTZ ", HEX }, - /* 0x93 */ { "JGTEZ", HEX }, - /* 0x94 */ { "JGTZ ", HEX }, - /* 0x95 */ { "JLTEZ", HEX }, - - /* Program control: arg = unsigned label (no stack arguments) */ - - /* 0x96 */ { "JMP ", HEX }, - /* 0x97 */ { "PUSH ", DECIMAL }, - - /* Program control: arg = unsigned label (One stack argument) */ - - /* 0x98 */ { "JEQU ", HEX }, - /* 0x99 */ { "JNEQ ", HEX }, - /* 0x9a */ { "JLT ", HEX }, - /* 0x9b */ { "JGTE ", HEX }, - /* 0x9c */ { "JGT ", HEX }, - /* 0x9d */ { "JLTE ", HEX }, - /* 0x9e */ { invOp, SIMPLE }, - /* 0x9f */ { "INDS ", DECIMAL }, - - /* Load: Uses LSP; arg = signed frame offset */ - - /* 0xa0 */ { "LDS ", DECIMAL }, /* No stack arguments */ - /* 0xa1 */ { "LDSH ", DECIMAL }, /* No stack arguments */ - /* 0xa2 */ { "LDSB ", DECIMAL }, /* No stack arguments */ - /* 0xa3 */ { "LDSM ", DECIMAL }, /* One 32-bit stack argument */ - - /* Store: Uses LSP; arg = signed frame offset */ - - /* 0xa4 */ { "STS ", DECIMAL }, /* One 32-bit stack argument */ - /* 0xa5 */ { "STSH ", DECIMAL }, /* One 32-bit stack argument */ - /* 0xa6 */ { "STSB ", DECIMAL }, /* One 32-bit stack argument */ - /* 0xa7 */ { "STSM ", DECIMAL }, /* One+n 32-bit stack argument */ - - /* Load Indexed: Uses LSP; arg = signed frame offset */ - - /* 0xa8 */ { "LDSX ", DECIMAL }, /* One 32-bit stack argument */ - /* 0xa9 */ { "LDSXH", DECIMAL }, /* One 32-bit stack argument */ - /* 0xaa */ { "LDSXB", DECIMAL }, /* One 32-bit stack argument */ - /* 0xab */ { "LDSXM", DECIMAL }, /* Two 32-bit stack argument */ - - /* Store Indexed: Uses LSP; arg = signed frame offset */ - - /* 0xac */ { "STSX ", DECIMAL }, /* Two 32-bit stack argument */ - /* 0xad */ { "STSXH", DECIMAL }, /* Two 32-bit stack argument */ - /* 0xae */ { "STSXB", DECIMAL }, /* Two 32-bit stack argument */ - /* 0xaf */ { "STSXM", DECIMAL }, /* Two+n 32-bit stack argument */ - - /* Load address relative to stack base: arg = unsigned offset */ - - /* 0xb0 */ { "LA ", UDECIMAL }, - - /* Load address: Uses SLP, arg = signed frame offset */ - - /* 0xb1 */ { "LAS ", DECIMAL }, - - /* Load absolute stack address: arg = RODATA offset (No stack arguments) */ - - /* 0xb2 */ { "LAC ", HEX, }, - /* 0xb3 */ { invOp, SIMPLE }, - - /* Load address relative to stack base: arg = unsigned offset, TOS=index */ - - /* 0xb4 */ { "LAX ", UDECIMAL }, - - /* Load address indexed: Uses SLP, arg = signed frame offset */ - - /* 0xb5 */ { "LASX ", DECIMAL }, - - /* Set LSP: arg = new level that evaluates to LSP value */ - - /* 0xb6 */ { "SLSP ", UDECIMAL }, - /* 0xb7 */ { "SDC ", UDECIMAL }, - /* 0xb8 */ { invOp, SIMPLE }, - - /* Program Control: Uses LSP; arg = unsigned label (No stack arguments) */ - - /* 0xb9 */ { "PCAL ", HEX }, - - /* System calls: arg = file number | sub-function code */ - - /* 0xba */ { "SYSIO", xOP }, - - /* System functions: arg = 32-bit library call identifier */ - - /* 0xbb */ { "LIB ", lbOP }, - - /* Floating point operations: arg = FP op-code */ - - /* 0xbc */ { "FLOAT", fpOP }, - - /* Program control: arg = unsigned label (no stack arguments) */ - - /* 0xbd */ { NULL, LABEL_DEC }, - - /* Psuedo-operations: arg = file number OR line number */ - - /* 0xbe */ { "INCLUDE ", FILENO }, - /* 0xbf */ { "LINE ", LINENO }, -}; - -static const char invXOp[] = "Invalid SYSIO"; -static const char *xName[MAX_XOP] = { /* SYSIO opcode mnemonics */ -/* 0x00 */ invXOp, "EOF", "EOLN", "RESET", -/* 0x04 */ "REWRITE", invXOp, invXOp, invXOp, -/* 0x08 */ invXOp, invXOp, invXOp, invXOp, -/* 0x0c */ invXOp, invXOp, invXOp, invXOp, -/* 0x10 */ "READLN", "READPG", "READBIN", "READINT", -/* 0x14 */ "READCHR", "READSTR", "READRL", invXOp, -/* 0x18 */ invXOp, invXOp, invXOp, invXOp, -/* 0x1c */ invXOp, invXOp, invXOp, invXOp, -/* 0x20 */ "WRITELN", "WRITEPG", "WRITEBIN", "WRITEINT", -/* 0x24 */ "WRITECHR", "WRITESTR", "WRITERL" }; - -static const char invLbOp[] = "Invalid runtime code"; -static const char *lbName[MAX_LBOP] = { /* LIB opcode mnemonics */ -/* 0x00 */ "GETENV", "STR2STR", "CSTR2STR", "STR2RSTR", -/* 0x04 */ "CSTR2RSTR", "VAL", "MKSTK", "MKSTKSTR", -/* 0x08 */ "MKSTKC", "STRCAT", "STRCATC", "STRCMP" }; - -#define MAX_FOP 16 -static const char invFpOp[] = "Invalid FP Operation"; -static const char *fpName[MAX_FOP] = { -/* 0x00 */ invFpOp, "FLOAT", "TRUNC", "ROUND", -/* 0x04 */ "NEG", "ADD", "SUB", "MUL", -/* 0x08 */ "DIV", "MOD", "EQU", "NEQ", -/* 0x0c */ "LT", "GTE", "GT", "LTE" }; - -/***********************************************************************/ - -void insn_DisassemblePCode(FILE* lfile, OPTYPE *pop) -{ - const struct optab_s *opTable; - int idx; - - /* Select table based upon whether an opcode is included or not */ - - if (pop->op & o32) - { - opTable = g_sArg32OpTable; - idx = pop->op & ~o32; - } - else - { - opTable = g_sNoArgOpTable; - idx = pop->op; - } - - /* Indent, comment or label as appropriate */ - - switch (opTable[idx].format) - { - case LABEL_DEC : - fprintf(lfile, "L%08lx:\n", pop->arg); - return; - case FILENO : - case LINENO : - fprintf(lfile, "; "); - break; - default : - fprintf(lfile, " "); - } /* end switch */ - - /* Print the opcode mnemonic */ - - fprintf(lfile, "%s ", opTable[idx].opName); - - /* Print the argument (if present) */ - - if (pop->op & o32) - { - switch (opTable[idx].format) - { - case HEX : - fprintf(lfile, "0x%08lx", pop->arg); - break; - - case FILENO : - case LINENO : - case DECIMAL : - fprintf(lfile, "%ld", (sint32)pop->arg); - break; - - case UDECIMAL : - fprintf(lfile, "%1lu", pop->arg); - break; - - case fpOP : - if ((pop->arg & 0x3f) < MAX_FOP) - fprintf(lfile, "%s", fpName[(pop->arg & 0x3f)]); - else - fprintf(lfile, "%s", invFpOp); - break; - - case xOP : - { - unsigned fileno = pop->arg >> 16; - unsigned xop = pop->arg & 0xffff; - fprintf(lfile, "%d, ", fileno); - if (xop < MAX_XOP) - fprintf(lfile, "%s", xName[xop]); - else - fprintf(lfile, "%s", invXOp); - } - break; - - case lbOP : - if (pop->arg < MAX_LBOP) - fprintf(lfile, "%s", lbName[pop->arg]); - else - fprintf(lfile, "%s", invLbOp); - break; - - case LABEL_DEC : - default : - break; - } - } - - /* Don't forget the newline! */ - - fputc('\n', lfile); - -} /* end dissassemblePcode */ - -/***********************************************************************/ +/********************************************************************** + * pdasm.c + * P-Code Disassembler + * + * Copyright (C) 2008-2009 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + **********************************************************************/ + +/********************************************************************** + * Included Files + **********************************************************************/ + +#include +#include + +#include "keywords.h" +#include "podefs.h" +#include "pinsn32.h" +#include "pfdefs.h" +#include "pxdefs.h" +#include "paslib.h" + +#include "pinsn.h" + +/********************************************************************** + * Private Types + **********************************************************************/ + +/* These are all the format codes that apply to opcodes with an argument */ + +enum { + SIMPLE = 0, /* No argument */ + HEX, /* Hexadecimal argument */ + DECIMAL, /* Signed Decimal argument (w/shift) */ + UDECIMAL, /* Unsigned Decimal argument (w/shift) */ + LABEL_DEC, /* Label number */ + xOP, lbOP, fpOP, /* Sub opcode */ + FILENO, LINENO /* File number, line number */ +}; + +/* The following table defines everything that is needed to disassemble + * a P-Code. NOTE: The order of definition in this table must exactly + * match the declaration sequence in pinsn.h. */ + +static const char invOp[] = "Invalid Opcode"; +struct optab_s +{ + const char *opName; /* Opcode mnemonics */ + uint8_t format; /* arg16 format */ +}; + +/******************** OPCODES WITH NO ARGUMENTS *************************/ + +static const struct optab_s g_sNoArgOpTable[64] = +{ + /* Program control (No stack arguments) */ + + /* 0x00 */ { "NOP ", SIMPLE }, + + /* Arithmetic & logical & and integer conversions (One stack argument) */ + + /* 0x01 */ { "NEG ", SIMPLE }, + /* 0x02 */ { "ABS ", SIMPLE }, + /* 0x03 */ { "INC ", SIMPLE }, + /* 0x04 */ { "DEC ", SIMPLE }, + /* 0x05 */ { "NOT ", SIMPLE }, + + /* Arithmetic & logical (Two stack arguments) */ + + /* 0x06 */ { "ADD ", SIMPLE }, + /* 0x07 */ { "SUB ", SIMPLE }, + /* 0x08 */ { "MUL ", SIMPLE }, + /* 0x09 */ { "DIV ", SIMPLE }, + /* 0x0a */ { "MOD ", SIMPLE }, + /* 0x0b */ { "SLL ", SIMPLE }, + /* 0x0c */ { "SRL ", SIMPLE }, + /* 0x0d */ { "SRA ", SIMPLE }, + /* 0x0e */ { "OR ", SIMPLE }, + /* 0x0f */ { "AND ", SIMPLE }, + + /* Comparisons (One stack argument) */ + + /* 0x10 */ { "EQUZ ", SIMPLE }, + /* 0x11 */ { "NEQZ ", SIMPLE }, + /* 0x12 */ { "LTZ ", SIMPLE }, + /* 0x13 */ { "GTEZ ", SIMPLE }, + /* 0x14 */ { "GTZ ", SIMPLE }, + /* 0x15 */ { "LTEZ ", SIMPLE }, + /* 0x16 */ { invOp, SIMPLE }, + /* 0x17 */ { invOp, SIMPLE }, + + /* Comparisons (Two stack arguments) */ + + /* 0x18 */ { "EQU ", SIMPLE }, + /* 0x19 */ { "NEQ ", SIMPLE }, + /* 0x1a */ { "LT ", SIMPLE }, + /* 0x1b */ { "GTE ", SIMPLE }, + /* 0x1c */ { "GT ", SIMPLE }, + /* 0x1d */ { "LTE ", SIMPLE }, + /* 0x1e */ { invOp, SIMPLE }, + /* 0x1f */ { "BIT ", SIMPLE }, + + /* Load (One) or Store (Two stack argument) */ + + /* 0x20 */ { "LDI ", SIMPLE }, + /* 0x21 */ { "LDIH", SIMPLE }, + /* 0x22 */ { "LDIB", SIMPLE }, + /* 0x23 */ { "LDIM", SIMPLE }, + /* 0x24 */ { "STI ", SIMPLE }, + /* 0x25 */ { "STIH", SIMPLE }, + /* 0x26 */ { "STIB", SIMPLE }, + /* 0x27 */ { "STIM", SIMPLE }, + + /* Data stack operations */ + + /* 0x28 */ { "DUP ", SIMPLE }, + /* 0x29 */ { "DUPH ", SIMPLE }, + /* 0x2a */ { "PUSHS", SIMPLE }, + /* 0x2b */ { "POPS", SIMPLE }, + /* 0x2c */ { invOp, SIMPLE }, + /* 0x2d */ { invOp, SIMPLE }, + /* 0x2e */ { invOp, SIMPLE }, + /* 0x2f */ { "RET ", SIMPLE }, + + /* 0x30 */ { invOp, SIMPLE }, + /* 0x31 */ { invOp, SIMPLE }, + /* 0x32 */ { invOp, SIMPLE }, + /* 0x33 */ { invOp, SIMPLE }, + /* 0x34 */ { invOp, SIMPLE }, + /* 0x35 */ { invOp, SIMPLE }, + /* 0x36 */ { invOp, SIMPLE }, + /* 0x37 */ { invOp, SIMPLE }, + + /* System Functions (No stack arguments) */ + + /* 0x38 */ { invOp, SIMPLE }, + /* 0x39 */ { invOp, SIMPLE }, + /* 0x3a */ { invOp, SIMPLE }, + /* 0x3b */ { invOp, SIMPLE }, + /* 0x3c */ { invOp, SIMPLE }, + /* 0x3d */ { invOp, SIMPLE }, + /* 0x3e */ { invOp, SIMPLE }, + /* 0x3f */ { "EXIT ", SIMPLE } +}; + +/****************** OPCODES WITH 25-BIT ARGUMENT ************************/ + +static const struct optab_s g_sArg32OpTable[64] = +{ + /* Load: arg = unsigned base offset */ + + /* 0x80 */ { "LD ", UDECIMAL }, /* No stack arguments */ + /* 0x81 */ { "LDH ", UDECIMAL }, /* No stack arguments */ + /* 0x82 */ { "LDB ", UDECIMAL }, /* No stack arguments */ + /* 0x83 */ { "LDM ", UDECIMAL }, /* One 32-bit stack argument */ + + /* Store: arg = unsigned base offset (One stack arguments) */ + + /* 0x84 */ { "ST ", UDECIMAL }, /* One 32-bit stack argument */ + /* 0x85 */ { "STH ", UDECIMAL }, /* One 32-bit stack argument */ + /* 0x86 */ { "STB ", UDECIMAL }, /* One 32-bit stack argument */ + /* 0x87 */ { "STM ", UDECIMAL }, /* One+n 32-bit stack argument */ + + /* Load Indexed: arg = unsigned base offset */ + + /* 0x88 */ { "LDX ", UDECIMAL }, /* One 32-bit stack argument */ + /* 0x89 */ { "LDXH ", UDECIMAL }, /* One 32-bit stack argument */ + /* 0x8a */ { "LDXB ", UDECIMAL }, /* One 32-bit stack argument */ + /* 0x8b */ { "LDXM ", UDECIMAL }, /* Two 32-bit stack argument */ + + /* Store Indexed: arg = unsigned base offset */ + + /* 0x8c */ { "STX ", UDECIMAL }, /* Two 32-bit stack argument */ + /* 0x8d */ { "STXH ", UDECIMAL }, /* Two 32-bit stack argument */ + /* 0x8e */ { "STXB ", UDECIMAL }, /* Two 32-bit stack argument */ + /* 0x8f */ { "STXM ", UDECIMAL }, /* Two+n 32-bit stack argument */ + + /* Program control: arg = unsigned label (One stack argument) */ + + /* 0x90 */ { "JEQUZ", HEX }, + /* 0x91 */ { "JNEQZ", HEX }, + /* 0x92 */ { "JLTZ ", HEX }, + /* 0x93 */ { "JGTEZ", HEX }, + /* 0x94 */ { "JGTZ ", HEX }, + /* 0x95 */ { "JLTEZ", HEX }, + + /* Program control: arg = unsigned label (no stack arguments) */ + + /* 0x96 */ { "JMP ", HEX }, + /* 0x97 */ { "PUSH ", DECIMAL }, + + /* Program control: arg = unsigned label (One stack argument) */ + + /* 0x98 */ { "JEQU ", HEX }, + /* 0x99 */ { "JNEQ ", HEX }, + /* 0x9a */ { "JLT ", HEX }, + /* 0x9b */ { "JGTE ", HEX }, + /* 0x9c */ { "JGT ", HEX }, + /* 0x9d */ { "JLTE ", HEX }, + /* 0x9e */ { invOp, SIMPLE }, + /* 0x9f */ { "INDS ", DECIMAL }, + + /* Load: Uses LSP; arg = signed frame offset */ + + /* 0xa0 */ { "LDS ", DECIMAL }, /* No stack arguments */ + /* 0xa1 */ { "LDSH ", DECIMAL }, /* No stack arguments */ + /* 0xa2 */ { "LDSB ", DECIMAL }, /* No stack arguments */ + /* 0xa3 */ { "LDSM ", DECIMAL }, /* One 32-bit stack argument */ + + /* Store: Uses LSP; arg = signed frame offset */ + + /* 0xa4 */ { "STS ", DECIMAL }, /* One 32-bit stack argument */ + /* 0xa5 */ { "STSH ", DECIMAL }, /* One 32-bit stack argument */ + /* 0xa6 */ { "STSB ", DECIMAL }, /* One 32-bit stack argument */ + /* 0xa7 */ { "STSM ", DECIMAL }, /* One+n 32-bit stack argument */ + + /* Load Indexed: Uses LSP; arg = signed frame offset */ + + /* 0xa8 */ { "LDSX ", DECIMAL }, /* One 32-bit stack argument */ + /* 0xa9 */ { "LDSXH", DECIMAL }, /* One 32-bit stack argument */ + /* 0xaa */ { "LDSXB", DECIMAL }, /* One 32-bit stack argument */ + /* 0xab */ { "LDSXM", DECIMAL }, /* Two 32-bit stack argument */ + + /* Store Indexed: Uses LSP; arg = signed frame offset */ + + /* 0xac */ { "STSX ", DECIMAL }, /* Two 32-bit stack argument */ + /* 0xad */ { "STSXH", DECIMAL }, /* Two 32-bit stack argument */ + /* 0xae */ { "STSXB", DECIMAL }, /* Two 32-bit stack argument */ + /* 0xaf */ { "STSXM", DECIMAL }, /* Two+n 32-bit stack argument */ + + /* Load address relative to stack base: arg = unsigned offset */ + + /* 0xb0 */ { "LA ", UDECIMAL }, + + /* Load address: Uses SLP, arg = signed frame offset */ + + /* 0xb1 */ { "LAS ", DECIMAL }, + + /* Load absolute stack address: arg = RODATA offset (No stack arguments) */ + + /* 0xb2 */ { "LAC ", HEX, }, + /* 0xb3 */ { invOp, SIMPLE }, + + /* Load address relative to stack base: arg = unsigned offset, TOS=index */ + + /* 0xb4 */ { "LAX ", UDECIMAL }, + + /* Load address indexed: Uses SLP, arg = signed frame offset */ + + /* 0xb5 */ { "LASX ", DECIMAL }, + + /* Set LSP: arg = new level that evaluates to LSP value */ + + /* 0xb6 */ { "SLSP ", UDECIMAL }, + /* 0xb7 */ { "SDC ", UDECIMAL }, + /* 0xb8 */ { invOp, SIMPLE }, + + /* Program Control: Uses LSP; arg = unsigned label (No stack arguments) */ + + /* 0xb9 */ { "PCAL ", HEX }, + + /* System calls: arg = file number | sub-function code */ + + /* 0xba */ { "SYSIO", xOP }, + + /* System functions: arg = 32-bit library call identifier */ + + /* 0xbb */ { "LIB ", lbOP }, + + /* Floating point operations: arg = FP op-code */ + + /* 0xbc */ { "FLOAT", fpOP }, + + /* Program control: arg = unsigned label (no stack arguments) */ + + /* 0xbd */ { NULL, LABEL_DEC }, + + /* Psuedo-operations: arg = file number OR line number */ + + /* 0xbe */ { "INCLUDE ", FILENO }, + /* 0xbf */ { "LINE ", LINENO }, +}; + +static const char invXOp[] = "Invalid SYSIO"; +static const char *xName[MAX_XOP] = { /* SYSIO opcode mnemonics */ +/* 0x00 */ invXOp, "EOF", "EOLN", "RESET", +/* 0x04 */ "REWRITE", invXOp, invXOp, invXOp, +/* 0x08 */ invXOp, invXOp, invXOp, invXOp, +/* 0x0c */ invXOp, invXOp, invXOp, invXOp, +/* 0x10 */ "READLN", "READPG", "READBIN", "READINT", +/* 0x14 */ "READCHR", "READSTR", "READRL", invXOp, +/* 0x18 */ invXOp, invXOp, invXOp, invXOp, +/* 0x1c */ invXOp, invXOp, invXOp, invXOp, +/* 0x20 */ "WRITELN", "WRITEPG", "WRITEBIN", "WRITEINT", +/* 0x24 */ "WRITECHR", "WRITESTR", "WRITERL" }; + +static const char invLbOp[] = "Invalid runtime code"; +static const char *lbName[MAX_LBOP] = { /* LIB opcode mnemonics */ +/* 0x00 */ "GETENV", "STR2STR", "CSTR2STR", "STR2RSTR", +/* 0x04 */ "CSTR2RSTR", "VAL", "MKSTK", "MKSTKSTR", +/* 0x08 */ "MKSTKC", "STRCAT", "STRCATC", "STRCMP" }; + +#define MAX_FOP 16 +static const char invFpOp[] = "Invalid FP Operation"; +static const char *fpName[MAX_FOP] = { +/* 0x00 */ invFpOp, "FLOAT", "TRUNC", "ROUND", +/* 0x04 */ "NEG", "ADD", "SUB", "MUL", +/* 0x08 */ "DIV", "MOD", "EQU", "NEQ", +/* 0x0c */ "LT", "GTE", "GT", "LTE" }; + +/***********************************************************************/ + +void insn_DisassemblePCode(FILE* lfile, OPTYPE *pop) +{ + const struct optab_s *opTable; + int idx; + + /* Select table based upon whether an opcode is included or not */ + + if (pop->op & o32) + { + opTable = g_sArg32OpTable; + idx = pop->op & ~o32; + } + else + { + opTable = g_sNoArgOpTable; + idx = pop->op; + } + + /* Indent, comment or label as appropriate */ + + switch (opTable[idx].format) + { + case LABEL_DEC : + fprintf(lfile, "L%08lx:\n", pop->arg); + return; + case FILENO : + case LINENO : + fprintf(lfile, "; "); + break; + default : + fprintf(lfile, " "); + } /* end switch */ + + /* Print the opcode mnemonic */ + + fprintf(lfile, "%s ", opTable[idx].opName); + + /* Print the argument (if present) */ + + if (pop->op & o32) + { + switch (opTable[idx].format) + { + case HEX : + fprintf(lfile, "0x%08lx", pop->arg); + break; + + case FILENO : + case LINENO : + case DECIMAL : + fprintf(lfile, "%ld", (int32_t)pop->arg); + break; + + case UDECIMAL : + fprintf(lfile, "%1lu", pop->arg); + break; + + case fpOP : + if ((pop->arg & 0x3f) < MAX_FOP) + fprintf(lfile, "%s", fpName[(pop->arg & 0x3f)]); + else + fprintf(lfile, "%s", invFpOp); + break; + + case xOP : + { + unsigned fileno = pop->arg >> 16; + unsigned xop = pop->arg & 0xffff; + fprintf(lfile, "%d, ", fileno); + if (xop < MAX_XOP) + fprintf(lfile, "%s", xName[xop]); + else + fprintf(lfile, "%s", invXOp); + } + break; + + case lbOP : + if (pop->arg < MAX_LBOP) + fprintf(lfile, "%s", lbName[pop->arg]); + else + fprintf(lfile, "%s", invLbOp); + break; + + case LABEL_DEC : + default : + break; + } + } + + /* Don't forget the newline! */ + + fputc('\n', lfile); + +} /* end dissassemblePcode */ + +/***********************************************************************/ -- cgit v1.2.3