[people/ms/u-boot.git] / include / bedbug / ppc.h

/* $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 */

\f
/*======================================================================
 *
 *  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.
 */
Commit	Line	Data
012771d8 WD	1	/* $Id$ */
	2
	3	#ifndef _PPC_H
	4	#define _PPC_H
	5
	6	/*======================================================================
	7	*
	8	* OPERANDS
	9	*
	10	======================================================================/
	11
	12	enum OP_FIELD {
	13	O_AA = 1, O_BD, O_BI, O_BO, O_crbD, O_crbA, O_crbB, O_CRM, O_d, O_frC, O_frD,
	14	O_frS, O_IMM, O_LI, O_LK, O_MB, O_ME, O_NB, O_OE, O_rA, O_rB, O_Rc, O_rD,
	15	O_rS, O_SH, O_SIMM, O_SR, O_TO, O_UIMM, O_crfD, O_crfS, O_L, O_spr, O_tbr,
	16	O_cr2 };
	17
	18	struct operand {
	19	enum OP_FIELD field; /* The operand identifier from the
	20	enum above */
	21
	22	char * name; /* Symbolic name of this operand */
	23
	24	unsigned int bits; /* The number of bits used by this
	25	operand */
	26
	27	unsigned int shift; /* How far to the right the operand
	28	should be shifted so that it is
	29	aligned at the beginning of the
	30	word */
	31
	32	unsigned int hint; /* A bitwise-inclusive-OR of the
	33	values shown below. These are used
	34	tell the disassembler how to print
	35	this operand */
	36	};
	37
	38	/* Values for operand hint */
	39	#define OH_SILENT 0x01 /* dont print this operand */
	40	#define OH_ADDR 0x02 /* this operand is an address */
	41	#define OH_REG 0x04 /* this operand is a register */
	42	#define OH_SPR 0x08 /* this operand is an SPR */
	43	#define OH_TBR 0x10 /* this operand is a TBR */
	44	#define OH_OFFSET 0x20 /* this operand is an offset */
	45	#define OH_LITERAL 0x40 /* a literal string */
	46
	47	\f
	48	/*======================================================================
	49	*
	50	* OPCODES
	51	*
	52	======================================================================/
	53
	54	/* From the MPCxxx instruction set documentation, all instructions are
	55	* 32 bits long and word aligned. Bits 0-5 always specify the primary
	56	* opcode. Many instructions also have an extended opcode.
	57	*/
	58
	59	#define GET_OPCD(i) (((unsigned long)(i) >> 26) & 0x3f)
	60	#define MAKE_OPCODE(i) ((((unsigned long)(i)) & 0x3f) << 26)
	61
	62	/* The MPC860 User's Manual, Appendix D.4 contains the definitions of the
	63	* instruction forms
	64	*/
65
66
67	/*-------------------------------------------------
68	* I-Form Instructions:
69	* bX
70	*-------------------------------------------------
71	* OPCD \| LI \|AA\|LK
72	-------------------------------------------------/
73
74	#define I_OPCODE(i,aa,lk) (MAKE_OPCODE(i) \| (((aa) & 0x1) << 1) \| ((lk) & 0x1))
75	#define I_MASK I_OPCODE(0x3f,0x1,0x1)
76
77
78	/*-------------------------------------------------
79	* B-Form Instructions:
80	* bcX
81	*-------------------------------------------------
82	* OPCD \| BO \| BI \| BD \|AA\|LK
83	-------------------------------------------------/
84
85	#define B_OPCODE(i,aa,lk) (MAKE_OPCODE(i) \| (((aa) & 0x1) << 1) \| ((lk) & 0x1))
86	#define B_MASK B_OPCODE(0x3f,0x1,0x1)
87
88
89	/*-------------------------------------------------
90	* SC-Form Instructions:
91	* sc
92	*-------------------------------------------------
93	* OPCD \| 00000 \| 00000 \| 00000000000000 \|1\|0
94	-------------------------------------------------/
95
96	#define SC_OPCODE(i) (MAKE_OPCODE(i) \| 0x2)
97	#define SC_MASK SC_OPCODE(0x3f)
98
99
100	/*-------------------------------------------------
101	* D-Form Instructions:
102	* addi addic addic. addis andi. andis. cmpi cmpli
103	* lbz lbzu lha lhau lhz lhzu lmw lwz lwzu mulli
104	* ori oris stb stbu sth sthu stmw stw stwu subfic
105	* twi xori xoris
106	*-------------------------------------------------
107	* OPCD \| D \| A \| d
108	* OPCD \| D \| A \| SIMM
109	* OPCD \| S \| A \| d
110	* OPCD \| S \| A \| UIMM
111	* OPCD \|crfD\|0\|L\| A \| SIMM
112	* OPCD \|crfD\|0\|L\| A \| UIMM
113	* OPCD \| TO \| A \| SIMM
114	-------------------------------------------------/
115
116	#define D_OPCODE(i) MAKE_OPCODE(i)
117	#define D_MASK MAKE_OPCODE(0x3f)
118
119
120	/*-------------------------------------------------
121	* DS-Form Instructions:
122	* (none supported by MPC860)
123	*-------------------------------------------------
124	* OPCD \| D \| A \| ds \|XO
125	* OPCD \| S \| A \| ds \|XO
126	-------------------------------------------------/
127
128	#define DS_OPCODE(i,xo) (MAKE_OPCODE(i) \| ((xo) & 0x3))
129	#define DS_MASK DS_OPCODE(0x3f,0x1)
130
131
132	/*---------------------------------------------------
133	* X-Form Instructions:
134	* andX andcX cmp cmpl cntlzwX dcbf dcbi dcbst dcbt
135	* dcbtst dcbz eciwx ecowx eieio eqvX extsbX extshX
136	* icbi lbzux lbxz lhaux lhax lhbrx lhzux lhxz lswi
137	* lswx lwarx lwbrx lwzux lwxz mcrfs mcrxr mfcr
138	* mfmsr mfsr mfsrin mtmsr mtsr mtsrin nandX norX
139	* orX orcX slwX srawX srawiX srwX stbux stbx
140	* sthbrx sthuxsthx stswi stswx stwbrx stwcx. stwux
141	* stwx sync tlbie tlbld tlbli tlbsync tw xorX
142	*---------------------------------------------------
143	* OPCD \| D \| A \| B \| XO \|0
144	* OPCD \| D \| A \| NB \| XO \|0
145	* OPCD \| D \| 00000 \| B \| XO \|0
146	* OPCD \| D \| 00000 \| 00000 \| XO \|0
147	* OPCD \| D \|0\| SR \| 00000 \| XO \|0
148	* OPCD \| S \| A \| B \| XO \|Rc
149	* OPCD \| S \| A \| B \| XO \|1
150	* OPCD \| S \| A \| B \| XO \|0
151	* OPCD \| S \| A \| NB \| XO \|0
152	* OPCD \| S \| A \| 00000 \| XO \|Rc
153	* OPCD \| S \| 00000 \| B \| XO \|0
154	* OPCD \| S \| 00000 \| 00000 \| XO \|0
155	* OPCD \| S \|0\| SR \| 00000 \| XO \|0
156	* OPCD \| S \| A \| SH \| XO \|Rc
157	* OPCD \|crfD\|0\|L\| A \| SH \| XO \|0
158	* OPCD \|crfD \|00\| A \| B \| XO \|0
159	* OPCD \|crfD \|00\|crfS \|00\| 00000 \| XO \|0
160	* OPCD \|crfD \|00\| 00000 \| 00000 \| XO \|0
161	* OPCD \|crfD \|00\| 00000 \| IMM \|0\| XO \|Rc
162	* OPCD \| TO \| A \| B \| XO \|0
163	* OPCD \| D \| 00000 \| B \| XO \|Rc
164	* OPCD \| D \| 00000 \| 00000 \| XO \|Rc
165	* OPCD \| crbD \| 00000 \| 00000 \| XO \|Rc
166	* OPCD \| 00000 \| A \| B \| XO \|0
167	* OPCD \| 00000 \| 00000 \| B \| XO \|0
168	* OPCD \| 00000 \| 00000 \| 00000 \| XO \|0
169	---------------------------------------------------/
170
171	#define X_OPCODE(i,xo,rc) (MAKE_OPCODE(i) \| (((xo) & 0x3ff) << 1) \| \
172	((rc) & 0x1))
173	#define X_MASK X_OPCODE(0x3f,0x3ff,0x1)
174
175
176	/*---------------------------------------------------
177	* XL-Form Instructions:
178	* bcctrX bclrX crand crandc creqv crnand crnor cror
179	* croc crxorisync mcrf rfi
180	*---------------------------------------------------
181	* OPCD \| BO \| BI \| 00000 \| XO \|LK
182	* OPCD \| crbD \| crbA \| crbB \| XO \|0
183	* OPCD \|crfD \|00\|crfS \|00\| 00000 \| XO \|0
184	* OPCD \| 00000 \| 00000 \| 00000 \| XO \|0
185	---------------------------------------------------/
186
187	#define XL_OPCODE(i,xo,lk) (MAKE_OPCODE(i) \| (((xo) & 0x3ff) << 1) \| \
188	((lk) & 0x1))
189	#define XL_MASK XL_OPCODE(0x3f,0x3ff,0x1)
190
191
192	/*---------------------------------------------------
193	* XFX-Form Instructions:
194	* mfspr mftb mtcrf mtspr
195	*---------------------------------------------------
196	* OPCD \| D \| spr \| XO \|0
197	* OPCD \| D \|0\| CRM \|0\| XO \|0
198	* OPCD \| S \| spr \| XO \|0
199	* OPCD \| D \| tbr \| XO \|0
200	---------------------------------------------------/
201
202	#define XFX_OPCODE(i,xo,rc) (MAKE_OPCODE(i) \| (((xo) & 0x3ff) << 1) \| \
203	((rc) & 0x1))
204	#define XFX_MASK XFX_OPCODE(0x3f,0x3ff,0x1)
205
206
207	/*---------------------------------------------------
208	* XFL-Form Instructions:
209	* (none supported by MPC860)
210	*---------------------------------------------------
211	* OPCD \|0\| FM \|0\| B \| XO \|0
212	---------------------------------------------------/
213
214	#define XFL_OPCODE(i,xo,rc) (MAKE_OPCODE(i) \| (((xo) & 0x3ff) << 1) \| \
215	((rc) & 0x1))
216	#define XFL_MASK XFL_OPCODE(0x3f,0x3ff,0x1)
217
218
219	/*---------------------------------------------------
220	* XS-Form Instructions:
221	* (none supported by MPC860)
222	*---------------------------------------------------
223	* OPCD \| S \| A \| sh \| XO \|sh\|LK
224	---------------------------------------------------/
225
226	#define XS_OPCODE(i,xo,rc) (MAKE_OPCODE(i) \| (((xo) & 0x1ff) << 2) \| \
227	((rc) & 0x1))
228	#define XS_MASK XS_OPCODE(0x3f,0x1ff,0x1)
229
230
231	/*---------------------------------------------------
232	* XO-Form Instructions:
233	* addX addcXaddeX addmeX addzeX divwX divwuX mulhwX
234	* mulhwuX mullwX negX subfX subfcX subfeX subfmeX
235	* subfzeX
236	*---------------------------------------------------
237	* OPCD \| D \| A \| B \|OE\| XO \|Rc
238	* OPCD \| D \| A \| B \|0 \| XO \|Rc
239	* OPCD \| D \| A \| 00000 \|OE\| XO \|Rc
240	---------------------------------------------------/
241
242	#define XO_OPCODE(i,xo,oe,rc) (MAKE_OPCODE(i) \| (((oe) & 0x1) << 10) \| \
243	(((xo) & 0x1ff) << 1) \| ((rc) & 0x1))
244	#define XO_MASK XO_OPCODE(0x3f,0x1ff,0x1,0x1)
245
246
247	/*---------------------------------------------------
248	* A-Form Instructions:
249	* (none supported by MPC860)
250	*---------------------------------------------------
251	* OPCD \| D \| A \| B \|00000\| XO \|Rc
252	* OPCD \| D \| A \| B \| C \| XO \|Rc
253	* OPCD \| D \| A \| 00000 \| C \| XO \|Rc
254	* OPCD \| D \| 00000 \| B \|00000\| XO \|Rc
255	---------------------------------------------------/
256
257	#define A_OPCODE(i,xo,rc) (MAKE_OPCODE(i) \| (((xo) & 0x1f) << 1) \| \
258	((rc) & 0x1))
259	#define A_MASK A_OPCODE(0x3f,0x1f,0x1)
260
261
262	/*---------------------------------------------------
263	* M-Form Instructions:
264	* rlwimiX rlwinmX rlwnmX
265	*---------------------------------------------------
266	* OPCD \| S \| A \| SH \| MB \| ME \|Rc
267	* OPCD \| S \| A \| B \| MB \| ME \|Rc
268	---------------------------------------------------/
269
270	#define M_OPCODE(i,rc) (MAKE_OPCODE(i) \| ((rc) & 0x1))
271	#define M_MASK M_OPCODE(0x3f,0x1)
272
273
274	/*---------------------------------------------------
275	* MD-Form Instructions:
276	* (none supported by MPC860)
277	*---------------------------------------------------
278	* OPCD \| S \| A \| sh \| mb \| XO \|sh\|Rc
279	* OPCD \| S \| A \| sh \| me \| XO \|sh\|Rc
280	---------------------------------------------------/
281
282	#define MD_OPCODE(i,xo,rc) (MAKE_OPCODE(i) \| (((xo) & 0x7) << 2) \| \
283	((rc) & 0x1))
284	#define MD_MASK MD_OPCODE(0x3f,0x7,0x1)
285
286
287	/*---------------------------------------------------
288	* MDS-Form Instructions:
289	* (none supported by MPC860)
290	*---------------------------------------------------
291	* OPCD \| S \| A \| B \| mb \| XO \|Rc
292	* OPCD \| S \| A \| B \| me \| XO \|Rc
293	---------------------------------------------------/
294
295	#define MDS_OPCODE(i,xo,rc) (MAKE_OPCODE(i) \| (((xo) & 0xf) << 1) \| \
296	((rc) & 0x1))
297	#define MDS_MASK MDS_OPCODE(0x3f,0xf,0x1)
298
012771d8 WD	299	#define INSTRUCTION( memaddr ) ntohl((unsigned long )(memaddr))
	300
	301	#define MAX_OPERANDS 8
	302
	303	struct ppc_ctx;
	304
	305	struct opcode {
	306	unsigned long opcode; /* The complete opcode as produced by
	307	one of the XXX_OPCODE macros above */
	308
	309	unsigned long mask; /* The mask to use on an instruction
	310	before comparing with the opcode
	311	field to see if it matches */
	312
	313	enum OP_FIELD fields[MAX_OPERANDS];
	314	/* An array defining the operands for
	315	this opcode. The values of the
	316	array are the operand identifiers */
	317
	318	int (hfunc)(struct ppc_ctx );
53677ef1	319	/* Address of a function to handle the given
012771d8 WD	320	mnemonic */
	321
	322	char * name; /* The symbolic name of this opcode */
	323
	324	unsigned int hint; /* A bitwise-inclusive-OR of the
	325	values shown below. These are used
	326	tell the disassembler how to print
	327	some operands for this opcode */
	328	};
	329
	330	/* values for opcode hints */
	331	#define H_RELATIVE 0x1 /* The address operand is relative */
	332	#define H_IMM_HIGH 0x2 /* [U\|S]IMM field shifted high */
	333	#define H_RA0_IS_0 0x4 /* If rA = 0 then treat as literal 0 */
	334
	335	struct ppc_ctx {
	336	struct opcode * op;
	337	unsigned long instr;
	338	unsigned int flags;
	339	int datalen;
	340	char data[ 256 ];
	341	char radix_fmt[ 8 ];
	342	unsigned char * virtual;
	343	};
	344
	345
	346	/*======================================================================
	347	*
	348	* FUNCTIONS
	349	*
	350	======================================================================/
	351
	352	/* Values for flags as passed to various ppc routines */
	353	#define F_RADOCTAL 0x1 /* output radix = unsigned octal */
	354	#define F_RADUDECIMAL 0x2 /* output radix = unsigned decimal */
	355	#define F_RADSDECIMAL 0x4 /* output radix = signed decimal */
	356	#define F_RADHEX 0x8 /* output radix = unsigned hex */
	357	#define F_SIMPLE 0x10 /* use simplified mnemonics */
	358	#define F_SYMBOL 0x20 /* use symbol lookups for addresses */
	359	#define F_INSTR 0x40 /* output the raw instruction */
	360	#define F_LOCALMEM 0x80 /* retrieve opcodes from local memory
	361	rather than from the HMI */
	362	#define F_LINENO 0x100 /* show line number info if available */
	363	#define F_VALIDONLY 0x200 /* cache: valid entries only */
	364
	365	/* Values for assembler error codes */
	366	#define E_ASM_BAD_OPCODE 1
	367	#define E_ASM_NUM_OPERANDS 2
	368	#define E_ASM_BAD_REGISTER 3
	369	#define E_ASM_BAD_SPR 4
	370	#define E_ASM_BAD_TBR 5
	371
	372	extern int disppc __P((unsigned char ,unsigned char ,int,
	373	int ()(const char ), unsigned long));
	374	extern int print_source_line __P((char ,char ,int,
	375	int (pfunc)(const char )));
	376	extern int find_next_address __P((unsigned char ,int,struct pt_regs ));
	377	extern int handle_bc __P((struct ppc_ctx *));
	378	extern unsigned long asmppc __P((unsigned long,char,int));
	379	extern char *asm_error_str __P((int));
	380
	381	/*======================================================================
	382	*
	383	* GLOBAL VARIABLES
384	*
385	======================================================================/
386
387	extern struct operand operands[];
388	extern const unsigned int n_operands;
389	extern struct opcode opcodes[];
390	extern const unsigned int n_opcodes;
391
392	#endif /* _PPC_H */
393
394
395	/*
396	* Copyright (c) 2000 William L. Pitts and W. Gerald Hicks
397	* All rights reserved.
398	*
399	* Redistribution and use in source and binary forms are freely
400	* permitted provided that the above copyright notice and this
401	* paragraph and the following disclaimer are duplicated in all
402	* such forms.
403	*
404	* This software is provided "AS IS" and without any express or
405	* implied warranties, including, without limitation, the implied
406	* warranties of merchantability and fitness for a particular
407	* purpose.
408	*/