/* $Id$ */

#include <common.h>

#include <linux/ctype.h>
#include <bedbug/bedbug.h>
#include <bedbug/ppc.h>
#include <bedbug/regs.h>
#include <bedbug/tables.h>

#define Elf32_Word      unsigned long

/* USE_SOURCE_CODE enables some symbolic debugging functions of this
   code.  This is only useful if the program will have access to the
   source code for the binary being examined.
*/

/* #define USE_SOURCE_CODE 1 */

#ifdef USE_SOURCE_CODE
extern int line_info_from_addr __P ((Elf32_Word, char *, char *, int *));
extern struct symreflist *symByAddr;
extern char *symbol_name_from_addr __P ((Elf32_Word, int, int *));
#endif /* USE_SOURCE_CODE */

int print_operands __P ((struct ppc_ctx *));
int get_operand_value __P ((struct opcode *, unsigned long,
                                enum OP_FIELD, unsigned long *));
struct opcode *find_opcode __P ((unsigned long));
struct opcode *find_opcode_by_name __P ((char *));
char *spr_name __P ((int));
int spr_value __P ((char *));
char *tbr_name __P ((int));
int tbr_value __P ((char *));
int parse_operand __P ((unsigned long, struct opcode *,
                        struct operand *, char *, int *));
int get_word __P ((char **, char *));
long read_number __P ((char *));
int downstring __P ((char *));


/*======================================================================
 * Entry point for the PPC disassembler.
 *
 * Arguments:
 *      memaddr         The address to start disassembling from.
 *
 *      virtual         If this value is non-zero, then this will be
 *                      used as the base address for the output and
 *                      symbol lookups.  If this value is zero then
 *                      memaddr is used as the absolute address.
 *
 *      num_instr       The number of instructions to disassemble.  Since
 *                      each instruction is 32 bits long, this can be
 *                      computed if you know the total size of the region.
 *
 *      pfunc           The address of a function that is called to print
 *                      each line of output.  The function should take a
 *                      single character pointer as its parameters a la puts.
 *
 *      flags           Sets options for the output.  This is a
 *                      bitwise-inclusive-OR of the following
 *                      values.  Note that only one of the radix
 *                      options may be set.
 *
 *                      F_RADOCTAL      - output radix is unsigned base 8.
 *                      F_RADUDECIMAL   - output radix is unsigned base 10.
 *                      F_RADSDECIMAL   - output radix is signed base 10.
 *                      F_RADHEX        - output radix is unsigned base 16.
 *                      F_SIMPLE        - use simplified mnemonics.
 *                      F_SYMBOL        - lookup symbols for addresses.
 *                      F_INSTR         - output raw instruction.
 *                      F_LINENO        - show line # info if available.
 *
 * Returns TRUE if the area was successfully disassembled or FALSE if
 * a problem was encountered with accessing the memory.
 */

int disppc (unsigned char *memaddr, unsigned char *virtual, int num_instr,
                        int (*pfunc) (const char *), unsigned long flags)
{
        int i;
        struct ppc_ctx ctx;

#ifdef USE_SOURCE_CODE
        int line_no = 0;
        int last_line_no = 0;
        char funcname[128] = { 0 };
        char filename[256] = { 0 };
        char last_funcname[128] = { 0 };
        int symoffset;
        char *symname;
        char *cursym = (char *) 0;
#endif /* USE_SOURCE_CODE */
  /*------------------------------------------------------------*/

        ctx.flags = flags;
        ctx.virtual = virtual;

        /* Figure out the output radix before we go any further */

        if (ctx.flags & F_RADOCTAL) {
                /* Unsigned octal output */
                strcpy (ctx.radix_fmt, "O%o");
        } else if (ctx.flags & F_RADUDECIMAL) {
                /* Unsigned decimal output */
                strcpy (ctx.radix_fmt, "%u");
        } else if (ctx.flags & F_RADSDECIMAL) {
                /* Signed decimal output */
                strcpy (ctx.radix_fmt, "%d");
        } else {
                /* Unsigned hex output */
                strcpy (ctx.radix_fmt, "0x%x");
        }

        if (ctx.virtual == 0) {
                ctx.virtual = memaddr;
        }
#ifdef USE_SOURCE_CODE
        if (ctx.flags & F_SYMBOL) {
                if (symByAddr == 0)             /* no symbols loaded */
                        ctx.flags &= ~F_SYMBOL;
                else {
                        cursym = (char *) 0;
                        symoffset = 0;
                }
        }
#endif /* USE_SOURCE_CODE */

        /* format each line as "XXXXXXXX: <symbol> IIIIIIII  disassembly" where,
           XXXXXXXX is the memory address in hex,
           <symbol> is the symbolic location if F_SYMBOL is set.
           IIIIIIII is the raw machine code in hex if F_INSTR is set,
           and disassembly is the disassembled machine code with numbers
           formatted according to the 'radix' parameter */

        for (i = 0; i < num_instr; ++i, memaddr += 4, ctx.virtual += 4) {
#ifdef USE_SOURCE_CODE
                if (ctx.flags & F_LINENO) {
                        if ((line_info_from_addr ((Elf32_Word) ctx.virtual, filename,
                                                                          funcname, &line_no) == TRUE) &&
                                ((line_no != last_line_no) ||
                                 (strcmp (last_funcname, funcname) != 0))) {
                                print_source_line (filename, funcname, line_no, pfunc);
                        }
                        last_line_no = line_no;
                        strcpy (last_funcname, funcname);
                }
#endif /* USE_SOURCE_CODE */

                sprintf (ctx.data, "%08lx: ", (unsigned long) ctx.virtual);
                ctx.datalen = 10;

#ifdef USE_SOURCE_CODE
                if (ctx.flags & F_SYMBOL) {
                        if ((symname =
                                 symbol_name_from_addr ((Elf32_Word) ctx.virtual,
                                                                                TRUE, 0)) != 0) {
                                cursym = symname;
                                symoffset = 0;
                        } else {
                                if ((cursym == 0) &&
                                        ((symname =
                                          symbol_name_from_addr ((Elf32_Word) ctx.virtual,
                                                                                         FALSE, &symoffset)) != 0)) {
                                        cursym = symname;
                                } else {
                                        symoffset += 4;
                                }
                        }

                        if (cursym != 0) {
                                sprintf (&ctx.data[ctx.datalen], "<%s+", cursym);
                                ctx.datalen = strlen (ctx.data);
                                sprintf (&ctx.data[ctx.datalen], ctx.radix_fmt, symoffset);
                                strcat (ctx.data, ">");
                                ctx.datalen = strlen (ctx.data);
                        }
                }
#endif /* USE_SOURCE_CODE */

                ctx.instr = INSTRUCTION (memaddr);

                if (ctx.flags & F_INSTR) {
                        /* Find the opcode structure for this opcode.  If one is not found
                           then it must be an illegal instruction */
                        sprintf (&ctx.data[ctx.datalen],
                                         "   %02lx %02lx %02lx %02lx    ",
                                         ((ctx.instr >> 24) & 0xff),
                                         ((ctx.instr >> 16) & 0xff), ((ctx.instr >> 8) & 0xff),
                                         (ctx.instr & 0xff));
                        ctx.datalen += 18;
                } else {
                        strcat (ctx.data, "   ");
                        ctx.datalen += 3;
                }

                if ((ctx.op = find_opcode (ctx.instr)) == 0) {
                        /* Illegal Opcode */
                        sprintf (&ctx.data[ctx.datalen], "        .long 0x%08lx",
                                         ctx.instr);
                        ctx.datalen += 24;
                        (*pfunc) (ctx.data);
                        continue;
                }

                if (((ctx.flags & F_SIMPLE) == 0) ||
                        (ctx.op->hfunc == 0) || ((*ctx.op->hfunc) (&ctx) == FALSE)) {
                        sprintf (&ctx.data[ctx.datalen], "%-7s ", ctx.op->name);
                        ctx.datalen += 8;
                        print_operands (&ctx);
                }

                (*pfunc) (ctx.data);
        }

        return TRUE;
}                                                               /* disppc */



/*======================================================================
 * Called by the disassembler to print the operands for an instruction.
 *
 * Arguments:
 *      ctx             A pointer to the disassembler context record.
 *
 * always returns 0.
 */

int print_operands (struct ppc_ctx *ctx)
{
        int open_parens = 0;
        int field;
        unsigned long operand;
        struct operand *opr;

#ifdef USE_SOURCE_CODE
        char *symname;
        int offset;
#endif /* USE_SOURCE_CODE */
  /*------------------------------------------------------------*/

        /* Walk through the operands and list each in order */
        for (field = 0; ctx->op->fields[field] != 0; ++field) {
                if (ctx->op->fields[field] > n_operands) {
                        continue;                       /* bad operand ?! */
                }

                opr = &operands[ctx->op->fields[field] - 1];

                if (opr->hint & OH_SILENT) {
                        continue;
                }

                if ((field > 0) && !open_parens) {
                        strcat (ctx->data, ",");
                        ctx->datalen++;
                }

                operand = (ctx->instr >> opr->shift) & ((1 << opr->bits) - 1);

                if (opr->hint & OH_ADDR) {
                        if ((operand & (1 << (opr->bits - 1))) != 0) {
                                operand = operand - (1 << opr->bits);
                        }

                        if (ctx->op->hint & H_RELATIVE)
                                operand = (operand << 2) + (unsigned long) ctx->virtual;
                        else
                                operand = (operand << 2);


                        sprintf (&ctx->data[ctx->datalen], "0x%lx", operand);
                        ctx->datalen = strlen (ctx->data);

#ifdef USE_SOURCE_CODE
                        if ((ctx->flags & F_SYMBOL) &&
                                ((symname =
                                  symbol_name_from_addr (operand, 0, &offset)) != 0)) {
                                sprintf (&ctx->data[ctx->datalen], " <%s", symname);
                                if (offset != 0) {
                                        strcat (ctx->data, "+");
                                        ctx->datalen = strlen (ctx->data);
                                        sprintf (&ctx->data[ctx->datalen], ctx->radix_fmt,
                                                         offset);
                                }
                                strcat (ctx->data, ">");
                        }
#endif /* USE_SOURCE_CODE */
                }

                else if (opr->hint & OH_REG) {
                        if ((operand == 0) &&
                                (opr->field == O_rA) && (ctx->op->hint & H_RA0_IS_0)) {
                                strcat (ctx->data, "0");
                        } else {
                                sprintf (&ctx->data[ctx->datalen], "r%d", (short) operand);
                        }

                        if (open_parens) {
                                strcat (ctx->data, ")");
                                open_parens--;
                        }
                }

                else if (opr->hint & OH_SPR) {
                        strcat (ctx->data, spr_name (operand));
                }

                else if (opr->hint & OH_TBR) {
                        strcat (ctx->data, tbr_name (operand));
                }

                else if (opr->hint & OH_LITERAL) {
                        switch (opr->field) {
                        case O_cr2:
                                strcat (ctx->data, "cr2");
                                ctx->datalen += 3;
                                break;

                        default:
                                break;
                        }
                }

                else {
                        sprintf (&ctx->data[ctx->datalen], ctx->radix_fmt,
                                         (unsigned short) operand);

                        if (open_parens) {
                                strcat (ctx->data, ")");
                                open_parens--;
                        }

                        else if (opr->hint & OH_OFFSET) {
                                strcat (ctx->data, "(");
                                open_parens++;
                        }
                }

                ctx->datalen = strlen (ctx->data);
        }

        return 0;
}                                                               /* print_operands */



/*======================================================================
 * Called to get the value of an arbitrary operand with in an instruction.
 *
 * Arguments:
 *      op              The pointer to the opcode structure to which
 *                      the operands belong.
 *
 *      instr           The instruction (32 bits) containing the opcode
 *                      and the operands to print.  By the time that
 *                      this routine is called the operand has already
 *                      been added to the output.
 *
 *      field           The field (operand) to get the value of.
 *
 *      value           The address of an unsigned long to be filled in
 *                      with the value of the operand if it is found.  This
 *                      will only be filled in if the function returns
 *                      TRUE.  This may be passed as 0 if the value is
 *                      not required.
 *
 * Returns TRUE if the operand was found or FALSE if it was not.
 */

int get_operand_value (struct opcode *op, unsigned long instr,
                                           enum OP_FIELD field, unsigned long *value)
{
        int i;
        struct operand *opr;

  /*------------------------------------------------------------*/

        if (field > n_operands) {
                return FALSE;                   /* bad operand ?! */
        }

        /* Walk through the operands and list each in order */
        for (i = 0; op->fields[i] != 0; ++i) {
                if (op->fields[i] != field) {
                        continue;
                }

                opr = &operands[op->fields[i] - 1];

                if (value) {
                        *value = (instr >> opr->shift) & ((1 << opr->bits) - 1);
                }
                return TRUE;
        }

        return FALSE;
}                                                               /* operand_value */



/*======================================================================
 * Called by the disassembler to match an opcode value to an opcode structure.
 *
 * Arguments:
 *      instr           The instruction (32 bits) to match.  This value
 *                      may contain operand values as well as the opcode
 *                      since they will be masked out anyway for this
 *                      search.
 *
 * Returns the address of an opcode struct (from the opcode table) if the
 * operand successfully matched an entry, or 0 if no match was found.
 */

struct opcode *find_opcode (unsigned long instr)
{
        struct opcode *ptr;
        int top = 0;
        int bottom = n_opcodes - 1;
        int idx;

  /*------------------------------------------------------------*/

        while (top <= bottom) {
                idx = (top + bottom) >> 1;
                ptr = &opcodes[idx];

                if ((instr & ptr->mask) < ptr->opcode) {
                        bottom = idx - 1;
                } else if ((instr & ptr->mask) > ptr->opcode) {
                        top = idx + 1;
                } else {
                        return ptr;
                }
        }

        return (struct opcode *) 0;
}                                                               /* find_opcode */



/*======================================================================
 * Called by the assembler to match an opcode name to an opcode structure.
 *
 * Arguments:
 *      name            The text name of the opcode, e.g. "b", "mtspr", etc.
 *
 * The opcodes are sorted numerically by their instruction binary code
 * so a search for the name cannot use the binary search used by the
 * other find routine.
 *
 * Returns the address of an opcode struct (from the opcode table) if the
 * name successfully matched an entry, or 0 if no match was found.
 */

struct opcode *find_opcode_by_name (char *name)
{
        int idx;

  /*------------------------------------------------------------*/

        downstring (name);

        for (idx = 0; idx < n_opcodes; ++idx) {
                if (!strcmp (name, opcodes[idx].name))
                        return &opcodes[idx];
        }

        return (struct opcode *) 0;
}                                                               /* find_opcode_by_name */



/*======================================================================
 * Convert the 'spr' operand from its numeric value to its symbolic name.
 *
 * Arguments:
 *      value           The value of the 'spr' operand.  This value should
 *                      be unmodified from its encoding in the instruction.
 *                      the split-field computations will be performed
 *                      here before the switch.
 *
 * Returns the address of a character array containing the name of the
 * special purpose register defined by the 'value' parameter, or the
 * address of a character array containing "???" if no match was found.
 */

char *spr_name (int value)
{
        unsigned short spr;
        static char other[10];
        int i;

  /*------------------------------------------------------------*/

        /* spr is a 10 bit field whose interpretation has the high and low
           five-bit fields reversed from their encoding in the operand */

        spr = ((value >> 5) & 0x1f) | ((value & 0x1f) << 5);

        for (i = 0; i < n_sprs; ++i) {
                if (spr == spr_map[i].spr_val)
                        return spr_map[i].spr_name;
        }

        sprintf (other, "%d", spr);
        return other;
}                                                               /* spr_name */



/*======================================================================
 * Convert the 'spr' operand from its symbolic name to its numeric value
 *
 * Arguments:
 *      name            The symbolic name of the 'spr' operand.  The
 *                      split-field encoding will be done by this routine.
 *                      NOTE: name can be a number.
 *
 * Returns the numeric value for the spr appropriate for encoding a machine
 * instruction.  Returns 0 if unable to find the SPR.
 */

int spr_value (char *name)
{
        struct spr_info *sprp;
        int spr;
        int i;

  /*------------------------------------------------------------*/

        if (!name || !*name)
                return 0;

        if (isdigit ((int) name[0])) {
                i = htonl (read_number (name));
                spr = ((i >> 5) & 0x1f) | ((i & 0x1f) << 5);
                return spr;
        }

        downstring (name);

        for (i = 0; i < n_sprs; ++i) {
                sprp = &spr_map[i];

                if (strcmp (name, sprp->spr_name) == 0) {
                        /* spr is a 10 bit field whose interpretation has the high and low
                           five-bit fields reversed from their encoding in the operand */
                        i = htonl (sprp->spr_val);
                        spr = ((i >> 5) & 0x1f) | ((i & 0x1f) << 5);

                        return spr;
                }
        }

        return 0;
}                                                               /* spr_value */



/*======================================================================
 * Convert the 'tbr' operand from its numeric value to its symbolic name.
 *
 * Arguments:
 *      value           The value of the 'tbr' operand.  This value should
 *                      be unmodified from its encoding in the instruction.
 *                      the split-field computations will be performed
 *                      here before the switch.
 *
 * Returns the address of a character array containing the name of the
 * time base register defined by the 'value' parameter, or the address
 * of a character array containing "???" if no match was found.
 */

char *tbr_name (int value)
{
        unsigned short tbr;

  /*------------------------------------------------------------*/

        /* tbr is a 10 bit field whose interpretation has the high and low
           five-bit fields reversed from their encoding in the operand */

        tbr = ((value >> 5) & 0x1f) | ((value & 0x1f) << 5);

        if (tbr == 268)
                return "TBL";

        else if (tbr == 269)
                return "TBU";


        return "???";
}                                                               /* tbr_name */



/*======================================================================
 * Convert the 'tbr' operand from its symbolic name to its numeric value.
 *
 * Arguments:
 *      name            The symbolic name of the 'tbr' operand.  The
 *                      split-field encoding will be done by this routine.
 *
 * Returns the numeric value for the spr appropriate for encoding a machine
 * instruction.  Returns 0 if unable to find the TBR.
 */

int tbr_value (char *name)
{
        int tbr;
        int val;

  /*------------------------------------------------------------*/

        if (!name || !*name)
                return 0;

        downstring (name);

        if (isdigit ((int) name[0])) {
                val = read_number (name);

                if (val != 268 && val != 269)
                        return 0;
        } else if (strcmp (name, "tbl") == 0)
                val = 268;
        else if (strcmp (name, "tbu") == 0)
                val = 269;
        else
                return 0;

        /* tbr is a 10 bit field whose interpretation has the high and low
           five-bit fields reversed from their encoding in the operand */

        val = htonl (val);
        tbr = ((val >> 5) & 0x1f) | ((val & 0x1f) << 5);
        return tbr;
}                                                               /* tbr_name */



/*======================================================================
 * The next several functions (handle_xxx) are the routines that handle
 * disassembling the opcodes with simplified mnemonics.
 *
 * Arguments:
 *      ctx             A pointer to the disassembler context record.
 *
 * Returns TRUE if the simpler form was printed or FALSE if it was not.
 */

int handle_bc (struct ppc_ctx *ctx)
{
        unsigned long bo;
        unsigned long bi;
        static struct opcode blt = { B_OPCODE (16, 0, 0), B_MASK, {O_BD, 0},
        0, "blt", H_RELATIVE
        };
        static struct opcode bne =
                        { B_OPCODE (16, 0, 0), B_MASK, {O_cr2, O_BD, 0},
        0, "bne", H_RELATIVE
        };
        static struct opcode bdnz = { B_OPCODE (16, 0, 0), B_MASK, {O_BD, 0},
        0, "bdnz", H_RELATIVE
        };

  /*------------------------------------------------------------*/

        if (get_operand_value (ctx->op, ctx->instr, O_BO, &bo) == FALSE)
                return FALSE;

        if (get_operand_value (ctx->op, ctx->instr, O_BI, &bi) == FALSE)
                return FALSE;

        if ((bo == 12) && (bi == 0)) {
                ctx->op = &blt;
                sprintf (&ctx->data[ctx->datalen], "%-7s ", ctx->op->name);
                ctx->datalen += 8;
                print_operands (ctx);
                return TRUE;
        } else if ((bo == 4) && (bi == 10)) {
                ctx->op = &bne;
                sprintf (&ctx->data[ctx->datalen], "%-7s ", ctx->op->name);
                ctx->datalen += 8;
                print_operands (ctx);
                return TRUE;
        } else if ((bo == 16) && (bi == 0)) {
                ctx->op = &bdnz;
                sprintf (&ctx->data[ctx->datalen], "%-7s ", ctx->op->name);
                ctx->datalen += 8;
                print_operands (ctx);
                return TRUE;
        }

        return FALSE;
}                                                               /* handle_blt */



/*======================================================================
 * Outputs source line information for the disassembler.  This should
 * be modified in the future to lookup the actual line of source code
 * from the file, but for now this will do.
 *
 * Arguments:
 *      filename        The address of a character array containing the
 *                      absolute path and file name of the source file.
 *
 *      funcname        The address of a character array containing the
 *                      name of the function (not C++ demangled (yet))
 *                      to which this code belongs.
 *
 *      line_no         An integer specifying the source line number that
 *                      generated this code.
 *
 *      pfunc           The address of a function to call to print the output.
 *
 *
 * Returns TRUE if it was able to output the line info, or false if it was
 * not.
 */

int print_source_line (char *filename, char *funcname,
                                           int line_no, int (*pfunc) (const char *))
{
        char out_buf[256];

  /*------------------------------------------------------------*/

        (*pfunc) ("");                          /* output a newline */
        sprintf (out_buf, "%s %s(): line %d", filename, funcname, line_no);
        (*pfunc) (out_buf);

        return TRUE;
}                                                               /* print_source_line */



/*======================================================================
 * Entry point for the PPC assembler.
 *
 * Arguments:
 *      asm_buf         An array of characters containing the assembly opcode
 *                      and operands to convert to a POWERPC machine
 *                      instruction.
 *
 * Returns the machine instruction or zero.
 */

unsigned long asmppc (unsigned long memaddr, char *asm_buf, int *err)
{
        struct opcode *opc;
        struct operand *oper[MAX_OPERANDS];
        unsigned long instr;
        unsigned long param;
        char *ptr = asm_buf;
        char scratch[20];
        int i;
        int w_operands = 0;                     /* wanted # of operands */
        int n_operands = 0;                     /* # of operands read */
        int asm_debug = 0;

  /*------------------------------------------------------------*/

        if (err)
                *err = 0;

        if (get_word (&ptr, scratch) == 0)
                return 0;

        /* Lookup the opcode structure based on the opcode name */
        if ((opc = find_opcode_by_name (scratch)) == (struct opcode *) 0) {
                if (err)
                        *err = E_ASM_BAD_OPCODE;
                return 0;
        }

        if (asm_debug) {
                printf ("asmppc: Opcode = \"%s\"\n", opc->name);
        }

        for (i = 0; i < 8; ++i) {
                if (opc->fields[i] == 0)
                        break;
                ++w_operands;
        }

        if (asm_debug) {
                printf ("asmppc: Expecting %d operands\n", w_operands);
        }

        instr = opc->opcode;

        /* read each operand */
        while (n_operands < w_operands) {

                oper[n_operands] = &operands[opc->fields[n_operands] - 1];

                if (oper[n_operands]->hint & OH_SILENT) {
                        /* Skip silent operands, they are covered in opc->opcode */

                        if (asm_debug) {
                                printf ("asmppc: Operand %d \"%s\" SILENT\n", n_operands,
                                                oper[n_operands]->name);
                        }

                        ++n_operands;
                        continue;
                }

                if (get_word (&ptr, scratch) == 0)
                        break;

                if (asm_debug) {
                        printf ("asmppc: Operand %d \"%s\" : \"%s\"\n", n_operands,
                                        oper[n_operands]->name, scratch);
                }

                if ((param = parse_operand (memaddr, opc, oper[n_operands],
                                                                        scratch, err)) == -1)
                        return 0;

                instr |= param;
                ++n_operands;
        }

        if (n_operands < w_operands) {
                if (err)
                        *err = E_ASM_NUM_OPERANDS;
                return 0;
        }

        if (asm_debug) {
                printf ("asmppc: Instruction = 0x%08lx\n", instr);
        }

        return instr;
}                                                               /* asmppc */



/*======================================================================
 * Called by the assembler to interpret a single operand
 *
 * Arguments:
 *      ctx             A pointer to the disassembler context record.
 *
 * Returns 0 if the operand is ok, or -1 if it is bad.
 */

int parse_operand (unsigned long memaddr, struct opcode *opc,
                                   struct operand *oper, char *txt, int *err)
{
        long data;
        long mask;
        int is_neg = 0;

  /*------------------------------------------------------------*/

        mask = (1 << oper->bits) - 1;

        if (oper->hint & OH_ADDR) {
                data = read_number (txt);

                if (opc->hint & H_RELATIVE)
                        data = data - memaddr;

                if (data < 0)
                        is_neg = 1;

                data >>= 2;
                data &= (mask >> 1);

                if (is_neg)
                        data |= 1 << (oper->bits - 1);
        }

        else if (oper->hint & OH_REG) {
                if (txt[0] == 'r' || txt[0] == 'R')
                        txt++;
                else if (txt[0] == '%' && (txt[1] == 'r' || txt[1] == 'R'))
                        txt += 2;

                data = read_number (txt);
                if (data > 31) {
                        if (err)
                                *err = E_ASM_BAD_REGISTER;
                        return -1;
                }

                data = htonl (data);
        }

        else if (oper->hint & OH_SPR) {
                if ((data = spr_value (txt)) == 0) {
                        if (err)
                                *err = E_ASM_BAD_SPR;
                        return -1;
                }
        }

        else if (oper->hint & OH_TBR) {
                if ((data = tbr_value (txt)) == 0) {
                        if (err)
                                *err = E_ASM_BAD_TBR;
                        return -1;
                }
        }

        else {
                data = htonl (read_number (txt));
        }

        return (data & mask) << oper->shift;
}                                                               /* parse_operand */


char *asm_error_str (int err)
{
        switch (err) {
        case E_ASM_BAD_OPCODE:
                return "Bad opcode";
        case E_ASM_NUM_OPERANDS:
                return "Bad number of operands";
        case E_ASM_BAD_REGISTER:
                return "Bad register number";
        case E_ASM_BAD_SPR:
                return "Bad SPR name or number";
        case E_ASM_BAD_TBR:
                return "Bad TBR name or number";
        }

        return "";
}                                                               /* asm_error_str */



/*======================================================================
 * Copy a word from one buffer to another, ignores leading white spaces.
 *
 * Arguments:
 *      src             The address of a character pointer to the
 *                      source buffer.
 *      dest            A pointer to a character buffer to write the word
 *                      into.
 *
 * Returns the number of non-white space characters copied, or zero.
 */

int get_word (char **src, char *dest)
{
        char *ptr = *src;
        int nchars = 0;

  /*------------------------------------------------------------*/

        /* Eat white spaces */
        while (*ptr && isblank (*ptr))
                ptr++;

        if (*ptr == 0) {
                *src = ptr;
                return 0;
        }

        /* Find the text of the word */
        while (*ptr && !isblank (*ptr) && (*ptr != ','))
                dest[nchars++] = *ptr++;
        ptr = (*ptr == ',') ? ptr + 1 : ptr;
        dest[nchars] = 0;

        *src = ptr;
        return nchars;
}                                                               /* get_word */



/*======================================================================
 * Convert a numeric string to a number, be aware of base notations.
 *
 * Arguments:
 *      txt             The numeric string.
 *
 * Returns the converted numeric value.
 */

long read_number (char *txt)
{
        long val;
        int is_neg = 0;

  /*------------------------------------------------------------*/

        if (txt == 0 || *txt == 0)
                return 0;

        if (*txt == '-') {

                is_neg = 1;
                ++txt;
        }

        if (txt[0] == '0' && (txt[1] == 'x' || txt[1] == 'X'))  /* hex */
                val = simple_strtoul (&txt[2], NULL, 16);
        else                                            /* decimal */
                val = simple_strtoul (txt, NULL, 10);

        if (is_neg)
                val = -val;

        return val;
}                                                               /* read_number */


int downstring (char *s)
{
        if (!s || !*s)
                return 0;

        while (*s) {
                if (isupper (*s))
                        *s = tolower (*s);
                s++;
        }

        return 0;
}                                                               /* downstring */



/*======================================================================
 * Examines the instruction at the current address and determines the
 * next address to be executed.  This will take into account branches
 * of different types so that a "step" and "next" operations can be
 * supported.
 *
 * Arguments:
 *      nextaddr        The address (to be filled in) of the next
 *                      instruction to execute.  This will only be a valid
 *                      address if TRUE is returned.
 *
 *      step_over       A flag indicating how to compute addresses for
 *                      branch statements:
 *                       TRUE  = Step over the branch (next)
 *                       FALSE = step into the branch (step)
 *
 * Returns TRUE if it was able to compute the address.  Returns FALSE if
 * it has a problem reading the current instruction or one of the registers.
 */

int find_next_address (unsigned char *nextaddr, int step_over,
                                           struct pt_regs *regs)
{
        unsigned long pc;                       /* SRR0 register from PPC */
        unsigned long ctr;                      /* CTR register from PPC */
        unsigned long cr;                       /* CR register from PPC */
        unsigned long lr;                       /* LR register from PPC */
        unsigned long instr;            /* instruction at SRR0 */
        unsigned long next;                     /* computed instruction for 'next' */
        unsigned long step;                     /* computed instruction for 'step' */
        unsigned long addr = 0;         /* target address operand */
        unsigned long aa = 0;           /* AA operand */
        unsigned long lk = 0;           /* LK operand */
        unsigned long bo = 0;           /* BO operand */
        unsigned long bi = 0;           /* BI operand */
        struct opcode *op = 0;          /* opcode structure for 'instr' */
        int ctr_ok = 0;
        int cond_ok = 0;
        int conditional = 0;
        int branch = 0;

  /*------------------------------------------------------------*/

        if (nextaddr == 0 || regs == 0) {
                printf ("find_next_address: bad args");
                return FALSE;
        }

        pc = regs->nip & 0xfffffffc;
        instr = INSTRUCTION (pc);

        if ((op = find_opcode (instr)) == (struct opcode *) 0) {
                printf ("find_next_address: can't parse opcode 0x%lx", instr);
                return FALSE;
        }

        ctr = regs->ctr;
        cr = regs->ccr;
        lr = regs->link;

        switch (op->opcode) {
        case B_OPCODE (16, 0, 0):       /* bc */
        case B_OPCODE (16, 0, 1):       /* bcl */
        case B_OPCODE (16, 1, 0):       /* bca */
        case B_OPCODE (16, 1, 1):       /* bcla */
                if (!get_operand_value (op, instr, O_BD, &addr) ||
                        !get_operand_value (op, instr, O_BO, &bo) ||
                        !get_operand_value (op, instr, O_BI, &bi) ||
                        !get_operand_value (op, instr, O_AA, &aa) ||
                        !get_operand_value (op, instr, O_LK, &lk))
                        return FALSE;

                if ((addr & (1 << 13)) != 0)
                        addr = addr - (1 << 14);
                addr <<= 2;
                conditional = 1;
                branch = 1;
                break;

        case I_OPCODE (18, 0, 0):       /* b */
        case I_OPCODE (18, 0, 1):       /* bl */
        case I_OPCODE (18, 1, 0):       /* ba */
        case I_OPCODE (18, 1, 1):       /* bla */
                if (!get_operand_value (op, instr, O_LI, &addr) ||
                        !get_operand_value (op, instr, O_AA, &aa) ||
                        !get_operand_value (op, instr, O_LK, &lk))
                        return FALSE;

                if ((addr & (1 << 23)) != 0)
                        addr = addr - (1 << 24);
                addr <<= 2;
                conditional = 0;
                branch = 1;
                break;

        case XL_OPCODE (19, 528, 0):    /* bcctr */
        case XL_OPCODE (19, 528, 1):    /* bcctrl */
                if (!get_operand_value (op, instr, O_BO, &bo) ||
                        !get_operand_value (op, instr, O_BI, &bi) ||
                        !get_operand_value (op, instr, O_LK, &lk))
                        return FALSE;

                addr = ctr;
                aa = 1;
                conditional = 1;
                branch = 1;
                break;

        case XL_OPCODE (19, 16, 0):     /* bclr */
        case XL_OPCODE (19, 16, 1):     /* bclrl */
                if (!get_operand_value (op, instr, O_BO, &bo) ||
                        !get_operand_value (op, instr, O_BI, &bi) ||
                        !get_operand_value (op, instr, O_LK, &lk))
                        return FALSE;

                addr = lr;
                aa = 1;
                conditional = 1;
                branch = 1;
                break;

        default:
                conditional = 0;
                branch = 0;
                break;
        }

        if (conditional) {
                switch ((bo & 0x1e) >> 1) {
                case 0:                         /* 0000y */
                        if (--ctr != 0)
                                ctr_ok = 1;

                        cond_ok = !(cr & (1 << (31 - bi)));
                        break;

                case 1:                         /* 0001y */
                        if (--ctr == 0)
                                ctr_ok = 1;

                        cond_ok = !(cr & (1 << (31 - bi)));
                        break;

                case 2:                         /* 001zy */
                        ctr_ok = 1;
                        cond_ok = !(cr & (1 << (31 - bi)));
                        break;

                case 4:                         /* 0100y */
                        if (--ctr != 0)
                                ctr_ok = 1;

                        cond_ok = cr & (1 << (31 - bi));
                        break;

                case 5:                         /* 0101y */
                        if (--ctr == 0)
                                ctr_ok = 1;

                        cond_ok = cr & (1 << (31 - bi));
                        break;

                case 6:                         /* 011zy */
                        ctr_ok = 1;
                        cond_ok = cr & (1 << (31 - bi));
                        break;

                case 8:                         /* 1z00y */
                        if (--ctr != 0)
                                ctr_ok = cond_ok = 1;
                        break;

                case 9:                         /* 1z01y */
                        if (--ctr == 0)
                                ctr_ok = cond_ok = 1;
                        break;

                case 10:                                /* 1z1zz */
                        ctr_ok = cond_ok = 1;
                        break;
                }
        }

        if (branch && (!conditional || (ctr_ok && cond_ok))) {
                if (aa)
                        step = addr;
                else
                        step = addr + pc;

                if (lk)
                        next = pc + 4;
                else
                        next = step;
        } else {
                step = next = pc + 4;
        }

        if (step_over == TRUE)
                *(unsigned long *) nextaddr = next;
        else
                *(unsigned long *) nextaddr = step;

        return TRUE;
}                                                               /* find_next_address */


/*
 * Copyright (c) 2000 William L. Pitts and W. Gerald Hicks
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are freely
 * permitted provided that the above copyright notice and this
 * paragraph and the following disclaimer are duplicated in all
 * such forms.
 *
 * This software is provided "AS IS" and without any express or
 * implied warranties, including, without limitation, the implied
 * warranties of merchantability and fitness for a particular
 * purpose.
 */