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 #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 *); 319 /* Address of a function to handle the given 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 */ 409