| 1 | /* Disassemble V850 instructions. |
| 2 | Copyright (C) 1996 Free Software Foundation, Inc. |
| 3 | |
| 4 | This program is free software; you can redistribute it and/or modify |
| 5 | it under the terms of the GNU General Public License as published by |
| 6 | the Free Software Foundation; either version 2 of the License, or |
| 7 | (at your option) any later version. |
| 8 | |
| 9 | This program is distributed in the hope that it will be useful, |
| 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 12 | GNU General Public License for more details. |
| 13 | |
| 14 | You should have received a copy of the GNU General Public License |
| 15 | along with this program; if not, write to the Free Software |
| 16 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
| 17 | |
| 18 | |
| 19 | #include <stdio.h> |
| 20 | |
| 21 | #include "ansidecl.h" |
| 22 | #include "opcode/v850.h" |
| 23 | #include "dis-asm.h" |
| 24 | |
| 25 | static const char *const v850_reg_names[] = |
| 26 | { "r0", "r1", "r2", "sp", "gp", "r5", "r6", "r7", |
| 27 | "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", |
| 28 | "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", |
| 29 | "r24", "r25", "r26", "r27", "r28", "r29", "ep", "lp" }; |
| 30 | |
| 31 | static const char *const v850_sreg_names[] = |
| 32 | { "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7", |
| 33 | "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15", |
| 34 | /* start-sanitize-v850e */ |
| 35 | "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23", |
| 36 | "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31", |
| 37 | /* end-sanitize-v850e */ |
| 38 | "sr16", "sr17", "sr18", "sr19", "sr20", "sr21", "sr22", "sr23", |
| 39 | "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31" }; |
| 40 | |
| 41 | static const char *const v850_cc_names[] = |
| 42 | { "v", "c/l", "z", "nh", "s/n", "t", "lt", "le", |
| 43 | "nv", "nc/nl", "nz", "h", "ns/p", "sa", "ge", "gt" }; |
| 44 | |
| 45 | static int |
| 46 | disassemble (memaddr, info, insn) |
| 47 | bfd_vma memaddr; |
| 48 | struct disassemble_info *info; |
| 49 | unsigned long insn; |
| 50 | { |
| 51 | struct v850_opcode * op = (struct v850_opcode *)v850_opcodes; |
| 52 | const struct v850_operand * operand; |
| 53 | int match = 0; |
| 54 | int short_op = ((insn & 0x0600) != 0x0600); |
| 55 | int bytes_read; |
| 56 | int target_processor; |
| 57 | |
| 58 | /* start-sanitize-v850e */ |
| 59 | /* Special case: 32 bit MOV */ |
| 60 | if ((insn & 0xffe0) == 0x0620) |
| 61 | short_op = true; |
| 62 | /* end-sanitize-v850e */ |
| 63 | |
| 64 | bytes_read = short_op ? 2 : 4; |
| 65 | |
| 66 | /* If this is a two byte insn, then mask off the high bits. */ |
| 67 | if (short_op) |
| 68 | insn &= 0xffff; |
| 69 | |
| 70 | switch (info->mach) |
| 71 | { |
| 72 | case 0: |
| 73 | default: |
| 74 | target_processor = PROCESSOR_V850; |
| 75 | break; |
| 76 | |
| 77 | /* start-sanitize-v850e */ |
| 78 | case bfd_mach_v850e: |
| 79 | target_processor = PROCESSOR_V850E; |
| 80 | break; |
| 81 | |
| 82 | case bfd_mach_v850eq: |
| 83 | target_processor = PROCESSOR_V850EQ; |
| 84 | break; |
| 85 | /* end-sanitize-v850e */ |
| 86 | } |
| 87 | |
| 88 | /* Find the opcode. */ |
| 89 | while (op->name) |
| 90 | { |
| 91 | if ((op->mask & insn) == op->opcode |
| 92 | && (op->processors & target_processor)) |
| 93 | { |
| 94 | const unsigned char * opindex_ptr; |
| 95 | unsigned int opnum; |
| 96 | unsigned int memop; |
| 97 | |
| 98 | match = 1; |
| 99 | (*info->fprintf_func) (info->stream, "%s\t", op->name); |
| 100 | //fprintf (stderr, "match: mask: %x insn: %x, opcode: %x, name: %s\n", op->mask, insn, op->opcode, op->name ); |
| 101 | |
| 102 | memop = op->memop; |
| 103 | /* Now print the operands. |
| 104 | |
| 105 | MEMOP is the operand number at which a memory |
| 106 | address specification starts, or zero if this |
| 107 | instruction has no memory addresses. |
| 108 | |
| 109 | A memory address is always two arguments. |
| 110 | |
| 111 | This information allows us to determine when to |
| 112 | insert commas into the output stream as well as |
| 113 | when to insert disp[reg] expressions onto the |
| 114 | output stream. */ |
| 115 | |
| 116 | for (opindex_ptr = op->operands, opnum = 1; |
| 117 | *opindex_ptr != 0; |
| 118 | opindex_ptr++, opnum++) |
| 119 | { |
| 120 | long value; |
| 121 | int flag; |
| 122 | int status; |
| 123 | bfd_byte buffer[ 4 ]; |
| 124 | |
| 125 | operand = &v850_operands[*opindex_ptr]; |
| 126 | |
| 127 | if (operand->extract) |
| 128 | value = (operand->extract) (insn, 0); |
| 129 | else |
| 130 | { |
| 131 | if (operand->bits == -1) |
| 132 | value = (insn & operand->shift); |
| 133 | else |
| 134 | value = (insn >> operand->shift) & ((1 << operand->bits) - 1); |
| 135 | |
| 136 | if (operand->flags & V850_OPERAND_SIGNED) |
| 137 | value = ((long)(value << (32 - operand->bits)) |
| 138 | >> (32 - operand->bits)); |
| 139 | } |
| 140 | |
| 141 | /* The first operand is always output without any |
| 142 | special handling. |
| 143 | |
| 144 | For the following arguments: |
| 145 | |
| 146 | If memop && opnum == memop + 1, then we need '[' since |
| 147 | we're about to output the register used in a memory |
| 148 | reference. |
| 149 | |
| 150 | If memop && opnum == memop + 2, then we need ']' since |
| 151 | we just finished the register in a memory reference. We |
| 152 | also need a ',' before this operand. |
| 153 | |
| 154 | Else we just need a comma. |
| 155 | |
| 156 | We may need to output a trailing ']' if the last operand |
| 157 | in an instruction is the register for a memory address. |
| 158 | |
| 159 | The exception (and there's always an exception) is the |
| 160 | "jmp" insn which needs square brackets around it's only |
| 161 | register argument. */ |
| 162 | |
| 163 | if (memop && opnum == memop + 1) info->fprintf_func (info->stream, "["); |
| 164 | else if (memop && opnum == memop + 2) info->fprintf_func (info->stream, "],"); |
| 165 | else if (memop == 1 && opnum == 1 |
| 166 | && (operand->flags & V850_OPERAND_REG)) |
| 167 | info->fprintf_func (info->stream, "["); |
| 168 | else if (opnum > 1) info->fprintf_func (info->stream, ", "); |
| 169 | |
| 170 | /* extract the flags, ignorng ones which do not effect disassembly output. */ |
| 171 | flag = operand->flags; |
| 172 | flag &= ~ V850_OPERAND_SIGNED; |
| 173 | flag &= ~ V850_OPERAND_RELAX; |
| 174 | flag &= - flag; |
| 175 | |
| 176 | switch (flag) |
| 177 | { |
| 178 | case V850_OPERAND_REG: info->fprintf_func (info->stream, "%s", v850_reg_names[value]); break; |
| 179 | case V850_OPERAND_SRG: info->fprintf_func (info->stream, "%s", v850_sreg_names[value]); break; |
| 180 | case V850_OPERAND_CC: info->fprintf_func (info->stream, "%s", v850_cc_names[value]); break; |
| 181 | case V850_OPERAND_EP: info->fprintf_func (info->stream, "ep"); break; |
| 182 | default: info->fprintf_func (info->stream, "%d", value); break; |
| 183 | case V850_OPERAND_DISP: |
| 184 | { |
| 185 | bfd_vma addr = value + memaddr; |
| 186 | |
| 187 | /* On the v850 the top 8 bits of an address are used by an overlay manager. |
| 188 | Thus it may happen that when we are looking for a symbol to match |
| 189 | against an address with some of its top bits set, the search fails to |
| 190 | turn up an exact match. In this case we try to find an exact match |
| 191 | against a symbol in the lower address space, and if we find one, we |
| 192 | use that address. We only do this for JARL instructions however, as |
| 193 | we do not want to misinterpret branch instructions. */ |
| 194 | if (operand->bits == 22) |
| 195 | { |
| 196 | if ( ! info->symbol_at_address_func (addr, info) |
| 197 | && ((addr & 0xFF000000) != 0) |
| 198 | && info->symbol_at_address_func (addr & 0x00FFFFFF, info)) |
| 199 | { |
| 200 | addr &= 0x00FFFFFF; |
| 201 | } |
| 202 | } |
| 203 | info->print_address_func (addr, info); |
| 204 | break; |
| 205 | } |
| 206 | |
| 207 | /* start-sanitize-v850e */ |
| 208 | case V850E_PUSH_POP: |
| 209 | { |
| 210 | static int list12_regs[32] = { 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24 }; |
| 211 | static int list18_h_regs[32] = { 19, 18, 17, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 30, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24 }; |
| 212 | static int list18_l_regs[32] = { 3, 2, 1, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 14, 15, 13, 12, 7, 6, 5, 4, 11, 10, 9, 8 }; |
| 213 | int * regs; |
| 214 | int i; |
| 215 | unsigned long int mask = 0; |
| 216 | int pc = false; |
| 217 | int sr = false; |
| 218 | |
| 219 | |
| 220 | switch (operand->shift) |
| 221 | { |
| 222 | case 0xffe00001: regs = list12_regs; break; |
| 223 | case 0xfff8000f: regs = list18_h_regs; break; |
| 224 | case 0xfff8001f: regs = list18_l_regs; value &= ~0x10; break; /* Do not include magic bit */ |
| 225 | default: |
| 226 | fprintf (stderr, "unknown operand shift: %x\n", operand->shift ); |
| 227 | abort(); |
| 228 | } |
| 229 | |
| 230 | for (i = 0; i < 32; i++) |
| 231 | { |
| 232 | if (value & (1 << i)) |
| 233 | { |
| 234 | switch (regs[ i ]) |
| 235 | { |
| 236 | default: mask |= (1 << regs[ i ]); break; |
| 237 | case 0: fprintf (stderr, "unknown pop reg: %d\n", i ); abort(); |
| 238 | case -1: pc = true; break; |
| 239 | case -2: sr = true; break; |
| 240 | } |
| 241 | } |
| 242 | } |
| 243 | |
| 244 | info->fprintf_func (info->stream, "{"); |
| 245 | |
| 246 | if (mask || pc || sr) |
| 247 | { |
| 248 | if (mask) |
| 249 | { |
| 250 | unsigned int bit; |
| 251 | int shown_one = false; |
| 252 | |
| 253 | for (bit = 0; bit < 32; bit++) |
| 254 | if (mask & (1 << bit)) |
| 255 | { |
| 256 | unsigned long int first = bit; |
| 257 | unsigned long int last; |
| 258 | |
| 259 | if (shown_one) |
| 260 | info->fprintf_func (info->stream, ", "); |
| 261 | else |
| 262 | shown_one = true; |
| 263 | |
| 264 | info->fprintf_func (info->stream, v850_reg_names[first]); |
| 265 | |
| 266 | for (bit++; bit < 32; bit++) |
| 267 | if ((mask & (1 << bit)) == 0) |
| 268 | break; |
| 269 | |
| 270 | last = bit; |
| 271 | |
| 272 | if (last > first + 1) |
| 273 | { |
| 274 | info->fprintf_func (info->stream, " - %s", v850_reg_names[ last - 1 ]); |
| 275 | } |
| 276 | } |
| 277 | } |
| 278 | |
| 279 | if (pc) |
| 280 | info->fprintf_func (info->stream, "%sPC", mask ? ", " : ""); |
| 281 | if (sr) |
| 282 | info->fprintf_func (info->stream, "%sSR", (mask || pc) ? ", " : ""); |
| 283 | } |
| 284 | |
| 285 | info->fprintf_func (info->stream, "}"); |
| 286 | } |
| 287 | break; |
| 288 | |
| 289 | case V850E_IMMEDIATE16: |
| 290 | status = info->read_memory_func (memaddr + bytes_read, buffer, 2, info); |
| 291 | if (status == 0) |
| 292 | { |
| 293 | bytes_read += 2; |
| 294 | value = bfd_getl16 (buffer); |
| 295 | |
| 296 | /* If this is a DISPOSE instruction with ff set to 0x10, then shift value up by 16. */ |
| 297 | if ((insn & 0x001fffc0) == 0x00130780) |
| 298 | value <<= 16; |
| 299 | |
| 300 | info->fprintf_func (info->stream, "0x%x", value); |
| 301 | } |
| 302 | else |
| 303 | { |
| 304 | info->memory_error_func (status, memaddr + bytes_read, info); |
| 305 | } |
| 306 | break; |
| 307 | |
| 308 | case V850E_IMMEDIATE32: |
| 309 | status = info->read_memory_func (memaddr + bytes_read, buffer, 4, info); |
| 310 | if (status == 0) |
| 311 | { |
| 312 | bytes_read += 4; |
| 313 | value = bfd_getl32 (buffer); |
| 314 | info->fprintf_func (info->stream, "0x%lx", value); |
| 315 | } |
| 316 | else |
| 317 | { |
| 318 | info->memory_error_func (status, memaddr + bytes_read, info); |
| 319 | } |
| 320 | break; |
| 321 | /* end-sanitize-v850e */ |
| 322 | } |
| 323 | |
| 324 | /* Handle jmp correctly. */ |
| 325 | if (memop == 1 && opnum == 1 |
| 326 | && ((operand->flags & V850_OPERAND_REG) != 0)) |
| 327 | (*info->fprintf_func) (info->stream, "]"); |
| 328 | } |
| 329 | |
| 330 | /* Close any square bracket we left open. */ |
| 331 | if (memop && opnum == memop + 2) |
| 332 | (*info->fprintf_func) (info->stream, "]"); |
| 333 | |
| 334 | /* All done. */ |
| 335 | break; |
| 336 | } |
| 337 | op++; |
| 338 | } |
| 339 | |
| 340 | if (!match) |
| 341 | { |
| 342 | if (short_op) |
| 343 | info->fprintf_func (info->stream, ".short\t0x%04x", insn); |
| 344 | else |
| 345 | info->fprintf_func (info->stream, ".long\t0x%08x", insn); |
| 346 | } |
| 347 | |
| 348 | return bytes_read; |
| 349 | } |
| 350 | |
| 351 | int |
| 352 | print_insn_v850 (memaddr, info) |
| 353 | bfd_vma memaddr; |
| 354 | struct disassemble_info * info; |
| 355 | { |
| 356 | int status; |
| 357 | bfd_byte buffer[ 4 ]; |
| 358 | unsigned long insn; |
| 359 | |
| 360 | /* First figure out how big the opcode is. */ |
| 361 | |
| 362 | status = info->read_memory_func (memaddr, buffer, 2, info); |
| 363 | if (status == 0) |
| 364 | { |
| 365 | insn = bfd_getl16 (buffer); |
| 366 | |
| 367 | if ( (insn & 0x0600) == 0x0600 |
| 368 | && (insn & 0xffe0) != 0x0620) |
| 369 | { |
| 370 | /* If this is a 4 byte insn, read 4 bytes of stuff. */ |
| 371 | status = info->read_memory_func (memaddr, buffer, 4, info); |
| 372 | |
| 373 | if (status == 0) |
| 374 | insn = bfd_getl32 (buffer); |
| 375 | } |
| 376 | } |
| 377 | |
| 378 | if (status != 0) |
| 379 | { |
| 380 | info->memory_error_func (status, memaddr, info); |
| 381 | return -1; |
| 382 | } |
| 383 | |
| 384 | /* Make sure we tell our caller how many bytes we consumed. */ |
| 385 | return disassemble (memaddr, info, insn); |
| 386 | } |