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 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 299 #ifndef FALSE 300 #define FALSE 0 301 #define TRUE (!FALSE) 302 #endif 303 304 #define INSTRUCTION( memaddr ) ntohl(*(unsigned long *)(memaddr)) 305 306 #define MAX_OPERANDS 8 307 308 struct ppc_ctx; 309 310 struct opcode { 311 unsigned long opcode; /* The complete opcode as produced by 312 one of the XXX_OPCODE macros above */ 313 314 unsigned long mask; /* The mask to use on an instruction 315 before comparing with the opcode 316 field to see if it matches */ 317 318 enum OP_FIELD fields[MAX_OPERANDS]; 319 /* An array defining the operands for 320 this opcode. The values of the 321 array are the operand identifiers */ 322 323 int (*hfunc)(struct ppc_ctx *); 324 /* Address of a function to handle the given 325 mnemonic */ 326 327 char * name; /* The symbolic name of this opcode */ 328 329 unsigned int hint; /* A bitwise-inclusive-OR of the 330 values shown below. These are used 331 tell the disassembler how to print 332 some operands for this opcode */ 333 }; 334 335 /* values for opcode hints */ 336 #define H_RELATIVE 0x1 /* The address operand is relative */ 337 #define H_IMM_HIGH 0x2 /* [U|S]IMM field shifted high */ 338 #define H_RA0_IS_0 0x4 /* If rA = 0 then treat as literal 0 */ 339 340 struct ppc_ctx { 341 struct opcode * op; 342 unsigned long instr; 343 unsigned int flags; 344 int datalen; 345 char data[ 256 ]; 346 char radix_fmt[ 8 ]; 347 unsigned char * virtual; 348 }; 349 350 351 /*====================================================================== 352 * 353 * FUNCTIONS 354 * 355 *======================================================================*/ 356 357 /* Values for flags as passed to various ppc routines */ 358 #define F_RADOCTAL 0x1 /* output radix = unsigned octal */ 359 #define F_RADUDECIMAL 0x2 /* output radix = unsigned decimal */ 360 #define F_RADSDECIMAL 0x4 /* output radix = signed decimal */ 361 #define F_RADHEX 0x8 /* output radix = unsigned hex */ 362 #define F_SIMPLE 0x10 /* use simplified mnemonics */ 363 #define F_SYMBOL 0x20 /* use symbol lookups for addresses */ 364 #define F_INSTR 0x40 /* output the raw instruction */ 365 #define F_LOCALMEM 0x80 /* retrieve opcodes from local memory 366 rather than from the HMI */ 367 #define F_LINENO 0x100 /* show line number info if available */ 368 #define F_VALIDONLY 0x200 /* cache: valid entries only */ 369 370 /* Values for assembler error codes */ 371 #define E_ASM_BAD_OPCODE 1 372 #define E_ASM_NUM_OPERANDS 2 373 #define E_ASM_BAD_REGISTER 3 374 #define E_ASM_BAD_SPR 4 375 #define E_ASM_BAD_TBR 5 376 377 extern int disppc __P((unsigned char *,unsigned char *,int, 378 int (*)(const char *), unsigned long)); 379 extern int print_source_line __P((char *,char *,int, 380 int (*pfunc)(const char *))); 381 extern int find_next_address __P((unsigned char *,int,struct pt_regs *)); 382 extern int handle_bc __P((struct ppc_ctx *)); 383 extern unsigned long asmppc __P((unsigned long,char*,int*)); 384 extern char *asm_error_str __P((int)); 385 386 /*====================================================================== 387 * 388 * GLOBAL VARIABLES 389 * 390 *======================================================================*/ 391 392 extern struct operand operands[]; 393 extern const unsigned int n_operands; 394 extern struct opcode opcodes[]; 395 extern const unsigned int n_opcodes; 396 397 #endif /* _PPC_H */ 398 399 400 /* 401 * Copyright (c) 2000 William L. Pitts and W. Gerald Hicks 402 * All rights reserved. 403 * 404 * Redistribution and use in source and binary forms are freely 405 * permitted provided that the above copyright notice and this 406 * paragraph and the following disclaimer are duplicated in all 407 * such forms. 408 * 409 * This software is provided "AS IS" and without any express or 410 * implied warranties, including, without limitation, the implied 411 * warranties of merchantability and fitness for a particular 412 * purpose. 413 */ 414