| /* $Id$ */ |
| |
| #ifndef _PPC_H |
| #define _PPC_H |
| |
| /*====================================================================== |
| * |
| * OPERANDS |
| * |
| *======================================================================*/ |
| |
| enum OP_FIELD { |
| O_AA = 1, O_BD, O_BI, O_BO, O_crbD, O_crbA, O_crbB, O_CRM, O_d, O_frC, O_frD, |
| O_frS, O_IMM, O_LI, O_LK, O_MB, O_ME, O_NB, O_OE, O_rA, O_rB, O_Rc, O_rD, |
| O_rS, O_SH, O_SIMM, O_SR, O_TO, O_UIMM, O_crfD, O_crfS, O_L, O_spr, O_tbr, |
| O_cr2 }; |
| |
| struct operand { |
| enum OP_FIELD field; /* The operand identifier from the |
| enum above */ |
| |
| char * name; /* Symbolic name of this operand */ |
| |
| unsigned int bits; /* The number of bits used by this |
| operand */ |
| |
| unsigned int shift; /* How far to the right the operand |
| should be shifted so that it is |
| aligned at the beginning of the |
| word */ |
| |
| unsigned int hint; /* A bitwise-inclusive-OR of the |
| values shown below. These are used |
| tell the disassembler how to print |
| this operand */ |
| }; |
| |
| /* Values for operand hint */ |
| #define OH_SILENT 0x01 /* dont print this operand */ |
| #define OH_ADDR 0x02 /* this operand is an address */ |
| #define OH_REG 0x04 /* this operand is a register */ |
| #define OH_SPR 0x08 /* this operand is an SPR */ |
| #define OH_TBR 0x10 /* this operand is a TBR */ |
| #define OH_OFFSET 0x20 /* this operand is an offset */ |
| #define OH_LITERAL 0x40 /* a literal string */ |
| |
| |
| /*====================================================================== |
| * |
| * OPCODES |
| * |
| *======================================================================*/ |
| |
| /* From the MPCxxx instruction set documentation, all instructions are |
| * 32 bits long and word aligned. Bits 0-5 always specify the primary |
| * opcode. Many instructions also have an extended opcode. |
| */ |
| |
| #define GET_OPCD(i) (((unsigned long)(i) >> 26) & 0x3f) |
| #define MAKE_OPCODE(i) ((((unsigned long)(i)) & 0x3f) << 26) |
| |
| /* The MPC860 User's Manual, Appendix D.4 contains the definitions of the |
| * instruction forms |
| */ |
| |
| |
| /*------------------------------------------------- |
| * I-Form Instructions: |
| * bX |
| *------------------------------------------------- |
| * OPCD | LI |AA|LK |
| *-------------------------------------------------*/ |
| |
| #define I_OPCODE(i,aa,lk) (MAKE_OPCODE(i) | (((aa) & 0x1) << 1) | ((lk) & 0x1)) |
| #define I_MASK I_OPCODE(0x3f,0x1,0x1) |
| |
| |
| /*------------------------------------------------- |
| * B-Form Instructions: |
| * bcX |
| *------------------------------------------------- |
| * OPCD | BO | BI | BD |AA|LK |
| *-------------------------------------------------*/ |
| |
| #define B_OPCODE(i,aa,lk) (MAKE_OPCODE(i) | (((aa) & 0x1) << 1) | ((lk) & 0x1)) |
| #define B_MASK B_OPCODE(0x3f,0x1,0x1) |
| |
| |
| /*------------------------------------------------- |
| * SC-Form Instructions: |
| * sc |
| *------------------------------------------------- |
| * OPCD | 00000 | 00000 | 00000000000000 |1|0 |
| *-------------------------------------------------*/ |
| |
| #define SC_OPCODE(i) (MAKE_OPCODE(i) | 0x2) |
| #define SC_MASK SC_OPCODE(0x3f) |
| |
| |
| /*------------------------------------------------- |
| * D-Form Instructions: |
| * addi addic addic. addis andi. andis. cmpi cmpli |
| * lbz lbzu lha lhau lhz lhzu lmw lwz lwzu mulli |
| * ori oris stb stbu sth sthu stmw stw stwu subfic |
| * twi xori xoris |
| *------------------------------------------------- |
| * OPCD | D | A | d |
| * OPCD | D | A | SIMM |
| * OPCD | S | A | d |
| * OPCD | S | A | UIMM |
| * OPCD |crfD|0|L| A | SIMM |
| * OPCD |crfD|0|L| A | UIMM |
| * OPCD | TO | A | SIMM |
| *-------------------------------------------------*/ |
| |
| #define D_OPCODE(i) MAKE_OPCODE(i) |
| #define D_MASK MAKE_OPCODE(0x3f) |
| |
| |
| /*------------------------------------------------- |
| * DS-Form Instructions: |
| * (none supported by MPC860) |
| *------------------------------------------------- |
| * OPCD | D | A | ds |XO |
| * OPCD | S | A | ds |XO |
| *-------------------------------------------------*/ |
| |
| #define DS_OPCODE(i,xo) (MAKE_OPCODE(i) | ((xo) & 0x3)) |
| #define DS_MASK DS_OPCODE(0x3f,0x1) |
| |
| |
| /*--------------------------------------------------- |
| * X-Form Instructions: |
| * andX andcX cmp cmpl cntlzwX dcbf dcbi dcbst dcbt |
| * dcbtst dcbz eciwx ecowx eieio eqvX extsbX extshX |
| * icbi lbzux lbxz lhaux lhax lhbrx lhzux lhxz lswi |
| * lswx lwarx lwbrx lwzux lwxz mcrfs mcrxr mfcr |
| * mfmsr mfsr mfsrin mtmsr mtsr mtsrin nandX norX |
| * orX orcX slwX srawX srawiX srwX stbux stbx |
| * sthbrx sthuxsthx stswi stswx stwbrx stwcx. stwux |
| * stwx sync tlbie tlbld tlbli tlbsync tw xorX |
| *--------------------------------------------------- |
| * OPCD | D | A | B | XO |0 |
| * OPCD | D | A | NB | XO |0 |
| * OPCD | D | 00000 | B | XO |0 |
| * OPCD | D | 00000 | 00000 | XO |0 |
| * OPCD | D |0| SR | 00000 | XO |0 |
| * OPCD | S | A | B | XO |Rc |
| * OPCD | S | A | B | XO |1 |
| * OPCD | S | A | B | XO |0 |
| * OPCD | S | A | NB | XO |0 |
| * OPCD | S | A | 00000 | XO |Rc |
| * OPCD | S | 00000 | B | XO |0 |
| * OPCD | S | 00000 | 00000 | XO |0 |
| * OPCD | S |0| SR | 00000 | XO |0 |
| * OPCD | S | A | SH | XO |Rc |
| * OPCD |crfD|0|L| A | SH | XO |0 |
| * OPCD |crfD |00| A | B | XO |0 |
| * OPCD |crfD |00|crfS |00| 00000 | XO |0 |
| * OPCD |crfD |00| 00000 | 00000 | XO |0 |
| * OPCD |crfD |00| 00000 | IMM |0| XO |Rc |
| * OPCD | TO | A | B | XO |0 |
| * OPCD | D | 00000 | B | XO |Rc |
| * OPCD | D | 00000 | 00000 | XO |Rc |
| * OPCD | crbD | 00000 | 00000 | XO |Rc |
| * OPCD | 00000 | A | B | XO |0 |
| * OPCD | 00000 | 00000 | B | XO |0 |
| * OPCD | 00000 | 00000 | 00000 | XO |0 |
| *---------------------------------------------------*/ |
| |
| #define X_OPCODE(i,xo,rc) (MAKE_OPCODE(i) | (((xo) & 0x3ff) << 1) | \ |
| ((rc) & 0x1)) |
| #define X_MASK X_OPCODE(0x3f,0x3ff,0x1) |
| |
| |
| /*--------------------------------------------------- |
| * XL-Form Instructions: |
| * bcctrX bclrX crand crandc creqv crnand crnor cror |
| * croc crxorisync mcrf rfi |
| *--------------------------------------------------- |
| * OPCD | BO | BI | 00000 | XO |LK |
| * OPCD | crbD | crbA | crbB | XO |0 |
| * OPCD |crfD |00|crfS |00| 00000 | XO |0 |
| * OPCD | 00000 | 00000 | 00000 | XO |0 |
| *---------------------------------------------------*/ |
| |
| #define XL_OPCODE(i,xo,lk) (MAKE_OPCODE(i) | (((xo) & 0x3ff) << 1) | \ |
| ((lk) & 0x1)) |
| #define XL_MASK XL_OPCODE(0x3f,0x3ff,0x1) |
| |
| |
| /*--------------------------------------------------- |
| * XFX-Form Instructions: |
| * mfspr mftb mtcrf mtspr |
| *--------------------------------------------------- |
| * OPCD | D | spr | XO |0 |
| * OPCD | D |0| CRM |0| XO |0 |
| * OPCD | S | spr | XO |0 |
| * OPCD | D | tbr | XO |0 |
| *---------------------------------------------------*/ |
| |
| #define XFX_OPCODE(i,xo,rc) (MAKE_OPCODE(i) | (((xo) & 0x3ff) << 1) | \ |
| ((rc) & 0x1)) |
| #define XFX_MASK XFX_OPCODE(0x3f,0x3ff,0x1) |
| |
| |
| /*--------------------------------------------------- |
| * XFL-Form Instructions: |
| * (none supported by MPC860) |
| *--------------------------------------------------- |
| * OPCD |0| FM |0| B | XO |0 |
| *---------------------------------------------------*/ |
| |
| #define XFL_OPCODE(i,xo,rc) (MAKE_OPCODE(i) | (((xo) & 0x3ff) << 1) | \ |
| ((rc) & 0x1)) |
| #define XFL_MASK XFL_OPCODE(0x3f,0x3ff,0x1) |
| |
| |
| /*--------------------------------------------------- |
| * XS-Form Instructions: |
| * (none supported by MPC860) |
| *--------------------------------------------------- |
| * OPCD | S | A | sh | XO |sh|LK |
| *---------------------------------------------------*/ |
| |
| #define XS_OPCODE(i,xo,rc) (MAKE_OPCODE(i) | (((xo) & 0x1ff) << 2) | \ |
| ((rc) & 0x1)) |
| #define XS_MASK XS_OPCODE(0x3f,0x1ff,0x1) |
| |
| |
| /*--------------------------------------------------- |
| * XO-Form Instructions: |
| * addX addcXaddeX addmeX addzeX divwX divwuX mulhwX |
| * mulhwuX mullwX negX subfX subfcX subfeX subfmeX |
| * subfzeX |
| *--------------------------------------------------- |
| * OPCD | D | A | B |OE| XO |Rc |
| * OPCD | D | A | B |0 | XO |Rc |
| * OPCD | D | A | 00000 |OE| XO |Rc |
| *---------------------------------------------------*/ |
| |
| #define XO_OPCODE(i,xo,oe,rc) (MAKE_OPCODE(i) | (((oe) & 0x1) << 10) | \ |
| (((xo) & 0x1ff) << 1) | ((rc) & 0x1)) |
| #define XO_MASK XO_OPCODE(0x3f,0x1ff,0x1,0x1) |
| |
| |
| /*--------------------------------------------------- |
| * A-Form Instructions: |
| * (none supported by MPC860) |
| *--------------------------------------------------- |
| * OPCD | D | A | B |00000| XO |Rc |
| * OPCD | D | A | B | C | XO |Rc |
| * OPCD | D | A | 00000 | C | XO |Rc |
| * OPCD | D | 00000 | B |00000| XO |Rc |
| *---------------------------------------------------*/ |
| |
| #define A_OPCODE(i,xo,rc) (MAKE_OPCODE(i) | (((xo) & 0x1f) << 1) | \ |
| ((rc) & 0x1)) |
| #define A_MASK A_OPCODE(0x3f,0x1f,0x1) |
| |
| |
| /*--------------------------------------------------- |
| * M-Form Instructions: |
| * rlwimiX rlwinmX rlwnmX |
| *--------------------------------------------------- |
| * OPCD | S | A | SH | MB | ME |Rc |
| * OPCD | S | A | B | MB | ME |Rc |
| *---------------------------------------------------*/ |
| |
| #define M_OPCODE(i,rc) (MAKE_OPCODE(i) | ((rc) & 0x1)) |
| #define M_MASK M_OPCODE(0x3f,0x1) |
| |
| |
| /*--------------------------------------------------- |
| * MD-Form Instructions: |
| * (none supported by MPC860) |
| *--------------------------------------------------- |
| * OPCD | S | A | sh | mb | XO |sh|Rc |
| * OPCD | S | A | sh | me | XO |sh|Rc |
| *---------------------------------------------------*/ |
| |
| #define MD_OPCODE(i,xo,rc) (MAKE_OPCODE(i) | (((xo) & 0x7) << 2) | \ |
| ((rc) & 0x1)) |
| #define MD_MASK MD_OPCODE(0x3f,0x7,0x1) |
| |
| |
| /*--------------------------------------------------- |
| * MDS-Form Instructions: |
| * (none supported by MPC860) |
| *--------------------------------------------------- |
| * OPCD | S | A | B | mb | XO |Rc |
| * OPCD | S | A | B | me | XO |Rc |
| *---------------------------------------------------*/ |
| |
| #define MDS_OPCODE(i,xo,rc) (MAKE_OPCODE(i) | (((xo) & 0xf) << 1) | \ |
| ((rc) & 0x1)) |
| #define MDS_MASK MDS_OPCODE(0x3f,0xf,0x1) |
| |
| #ifndef FALSE |
| #define FALSE 0 |
| #define TRUE (!FALSE) |
| #endif |
| |
| #define INSTRUCTION( memaddr ) ntohl(*(unsigned long *)(memaddr)) |
| |
| #define MAX_OPERANDS 8 |
| |
| struct ppc_ctx; |
| |
| struct opcode { |
| unsigned long opcode; /* The complete opcode as produced by |
| one of the XXX_OPCODE macros above */ |
| |
| unsigned long mask; /* The mask to use on an instruction |
| before comparing with the opcode |
| field to see if it matches */ |
| |
| enum OP_FIELD fields[MAX_OPERANDS]; |
| /* An array defining the operands for |
| this opcode. The values of the |
| array are the operand identifiers */ |
| |
| int (*hfunc)(struct ppc_ctx *); |
| /* Address of a function to handle the given |
| mnemonic */ |
| |
| char * name; /* The symbolic name of this opcode */ |
| |
| unsigned int hint; /* A bitwise-inclusive-OR of the |
| values shown below. These are used |
| tell the disassembler how to print |
| some operands for this opcode */ |
| }; |
| |
| /* values for opcode hints */ |
| #define H_RELATIVE 0x1 /* The address operand is relative */ |
| #define H_IMM_HIGH 0x2 /* [U|S]IMM field shifted high */ |
| #define H_RA0_IS_0 0x4 /* If rA = 0 then treat as literal 0 */ |
| |
| struct ppc_ctx { |
| struct opcode * op; |
| unsigned long instr; |
| unsigned int flags; |
| int datalen; |
| char data[ 256 ]; |
| char radix_fmt[ 8 ]; |
| unsigned char * virtual; |
| }; |
| |
| |
| /*====================================================================== |
| * |
| * FUNCTIONS |
| * |
| *======================================================================*/ |
| |
| /* Values for flags as passed to various ppc routines */ |
| #define F_RADOCTAL 0x1 /* output radix = unsigned octal */ |
| #define F_RADUDECIMAL 0x2 /* output radix = unsigned decimal */ |
| #define F_RADSDECIMAL 0x4 /* output radix = signed decimal */ |
| #define F_RADHEX 0x8 /* output radix = unsigned hex */ |
| #define F_SIMPLE 0x10 /* use simplified mnemonics */ |
| #define F_SYMBOL 0x20 /* use symbol lookups for addresses */ |
| #define F_INSTR 0x40 /* output the raw instruction */ |
| #define F_LOCALMEM 0x80 /* retrieve opcodes from local memory |
| rather than from the HMI */ |
| #define F_LINENO 0x100 /* show line number info if available */ |
| #define F_VALIDONLY 0x200 /* cache: valid entries only */ |
| |
| /* Values for assembler error codes */ |
| #define E_ASM_BAD_OPCODE 1 |
| #define E_ASM_NUM_OPERANDS 2 |
| #define E_ASM_BAD_REGISTER 3 |
| #define E_ASM_BAD_SPR 4 |
| #define E_ASM_BAD_TBR 5 |
| |
| extern int disppc __P((unsigned char *,unsigned char *,int, |
| int (*)(const char *), unsigned long)); |
| extern int print_source_line __P((char *,char *,int, |
| int (*pfunc)(const char *))); |
| extern int find_next_address __P((unsigned char *,int,struct pt_regs *)); |
| extern int handle_bc __P((struct ppc_ctx *)); |
| extern unsigned long asmppc __P((unsigned long,char*,int*)); |
| extern char *asm_error_str __P((int)); |
| |
| /*====================================================================== |
| * |
| * GLOBAL VARIABLES |
| * |
| *======================================================================*/ |
| |
| extern struct operand operands[]; |
| extern const unsigned int n_operands; |
| extern struct opcode opcodes[]; |
| extern const unsigned int n_opcodes; |
| |
| #endif /* _PPC_H */ |
| |
| |
| /* |
| * 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. |
| */ |
