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