1 /* $NetBSD: fpu_calcea.c,v 1.29 2026/11/01 12:13:24 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 1995 Gordon W. Ross 5 * portion Copyright (c) 1995 Ken Nakata 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. The name of the author may not be used to endorse or promote products 17 * derived from this software without specific prior written permission. 18 * 4. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by Gordon Ross 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "opt_m68k_arch.h" 35 36 #include <sys/cdefs.h> 37 __KERNEL_RCSID(0, "$NetBSD: fpu_calcea.c,v 1.29 2026/11/01 12:13:24 thorpej Exp $"); 38 39 #include <sys/param.h> 40 #include <sys/signal.h> 41 #include <sys/systm.h> 42 #include <machine/frame.h> 43 #include <m68k/m68k.h> 44 45 #include "fpu_emulate.h" 46 47 #ifdef DEBUG_FPE 48 #define DPRINTF(x) printf x 49 #else 50 #define DPRINTF(x) do {} while (/* CONSTCOND */ 0) 51 #endif 52 53 /* 54 * Prototypes of static functions 55 */ 56 static int decode_ea6(struct frame *, struct instruction *, 57 struct insn_ea *, int); 58 static int fetch_immed(struct frame *, struct instruction *, int *); 59 static int fetch_disp(struct frame *, struct instruction *, int, int *); 60 static int calc_ea(struct insn_ea *, char *, char **); 61 62 /* 63 * Helper routines for dealing with "effective address" values. 64 */ 65 66 /* 67 * Decode an effective address into internal form. 68 * Returns zero on success, else signal number. 69 */ 70 int 71 fpu_decode_ea(struct frame *frame, struct instruction *insn, 72 struct insn_ea *ea, int modreg) 73 { 74 int sig; 75 76 #ifdef DIAGNOSTIC 77 if (insn->is_datasize < 0) 78 panic("%s: called with uninitialized datasize", __func__); 79 #endif 80 81 sig = 0; 82 83 /* Set the most common value here. */ 84 ea->ea_regnum = 8 + (modreg & 7); 85 86 if ((modreg & 060) == 0) { 87 /* register direct */ 88 ea->ea_regnum = modreg & 0xf; 89 ea->ea_flags = EA_DIRECT; 90 DPRINTF(("%s: register direct reg=%d\n", 91 __func__, ea->ea_regnum)); 92 } else if ((modreg & 077) == 074) { 93 /* immediate */ 94 ea->ea_flags = EA_IMMED; 95 sig = fetch_immed(frame, insn, &ea->ea_immed[0]); 96 DPRINTF(("%s: immediate size=%d\n", 97 __func__, insn->is_datasize)); 98 } 99 /* 100 * rest of the address modes need to be separately 101 * handled for the LC040 and the others. 102 */ 103 #if 0 /* XXX */ 104 else if (frame->f_format == 4 && frame->f_fmt4.f_fa) { 105 /* LC040 */ 106 ea->ea_flags = EA_FRAME_EA; 107 ea->ea_fea = frame->f_fmt4.f_fa; 108 DPRINTF(("%s: 68LC040 - in-frame EA (%p) size %d\n", 109 __func__, (void *)ea->ea_fea, insn->is_datasize)); 110 if ((modreg & 070) == 030) { 111 /* postincrement mode */ 112 ea->ea_flags |= EA_POSTINCR; 113 } else if ((modreg & 070) == 040) { 114 /* predecrement mode */ 115 ea->ea_flags |= EA_PREDECR; 116 #ifdef M68060 117 #if defined(M68020) || defined(M68030) || defined(M68040) 118 if (cputype == CPU_68060) 119 #endif 120 if (insn->is_datasize == 12) 121 ea->ea_fea -= 8; 122 #endif 123 } 124 } 125 #endif /* XXX */ 126 else { 127 /* 020/030 */ 128 switch (modreg & 070) { 129 130 case 020: /* (An) */ 131 ea->ea_flags = 0; 132 DPRINTF(("%s: register indirect reg=%d\n", 133 __func__, ea->ea_regnum)); 134 break; 135 136 case 030: /* (An)+ */ 137 ea->ea_flags = EA_POSTINCR; 138 DPRINTF(("%s: reg indirect postincrement reg=%d\n", 139 __func__, ea->ea_regnum)); 140 break; 141 142 case 040: /* -(An) */ 143 ea->ea_flags = EA_PREDECR; 144 DPRINTF(("%s: reg indirect predecrement reg=%d\n", 145 __func__, ea->ea_regnum)); 146 break; 147 148 case 050: /* (d16,An) */ 149 ea->ea_flags = EA_OFFSET; 150 sig = fetch_disp(frame, insn, 1, &ea->ea_offset); 151 DPRINTF(("%s: reg indirect with displacement reg=%d\n", 152 __func__, ea->ea_regnum)); 153 break; 154 155 case 060: /* (d8,An,Xn) */ 156 ea->ea_flags = EA_INDEXED; 157 sig = decode_ea6(frame, insn, ea, modreg); 158 break; 159 160 case 070: /* misc. */ 161 ea->ea_regnum = (modreg & 7); 162 switch (modreg & 7) { 163 164 case 0: /* (xxxx).W */ 165 ea->ea_flags = EA_ABS; 166 sig = fetch_disp(frame, insn, 1, 167 &ea->ea_absaddr); 168 DPRINTF(("%s: absolute address (word)\n", 169 __func__)); 170 break; 171 172 case 1: /* (xxxxxxxx).L */ 173 ea->ea_flags = EA_ABS; 174 sig = fetch_disp(frame, insn, 2, 175 &ea->ea_absaddr); 176 DPRINTF(("%s: absolute address (long)\n", 177 __func__)); 178 break; 179 180 case 2: /* (d16,PC) */ 181 ea->ea_flags = EA_PC_REL | EA_OFFSET; 182 sig = fetch_disp(frame, insn, 1, 183 &ea->ea_absaddr); 184 DPRINTF(("%s: pc relative word displacement\n", 185 __func__)); 186 break; 187 188 case 3: /* (d8,PC,Xn) */ 189 ea->ea_flags = EA_PC_REL | EA_INDEXED; 190 sig = decode_ea6(frame, insn, ea, modreg); 191 break; 192 193 case 4: /* #data */ 194 /* it should have been taken care of earlier */ 195 default: 196 DPRINTF(("%s: invalid addr mode (7,%d)\n", 197 __func__, modreg & 7)); 198 return SIGILL; 199 } 200 break; 201 } 202 } 203 ea->ea_moffs = 0; 204 205 return sig; 206 } 207 208 /* 209 * Decode Mode=6 address modes 210 */ 211 static int 212 decode_ea6(struct frame *frame, struct instruction *insn, struct insn_ea *ea, 213 int modreg) 214 { 215 int idx; 216 int basedisp, outerdisp; 217 int bd_size, od_size; 218 int sig; 219 unsigned short extword; 220 221 if (ufetch_short((void *)(insn->is_pc + insn->is_advance), &extword)) 222 return SIGSEGV; 223 insn->is_advance += 2; 224 225 /* get register index */ 226 ea->ea_idxreg = (extword >> 12) & 0xf; 227 idx = frame->f_regs[ea->ea_idxreg]; 228 if ((extword & 0x0800) == 0) { 229 /* if word sized index, sign-extend */ 230 idx &= 0xffff; 231 if (idx & 0x8000) { 232 idx |= 0xffff0000; 233 } 234 } 235 /* scale register index */ 236 idx <<= ((extword >> 9) & 3); 237 238 if ((extword & 0x100) == 0) { 239 /* brief extension word - sign-extend the displacement */ 240 basedisp = (extword & 0xff); 241 if (basedisp & 0x80) { 242 basedisp |= 0xffffff00; 243 } 244 245 ea->ea_basedisp = idx + basedisp; 246 ea->ea_outerdisp = 0; 247 DPRINTF(("%s: brief ext word idxreg=%d, basedisp=%08x\n", 248 __func__, ea->ea_idxreg, ea->ea_basedisp)); 249 } else { 250 /* full extension word */ 251 if (extword & 0x80) { 252 ea->ea_flags |= EA_BASE_SUPPRSS; 253 } 254 bd_size = ((extword >> 4) & 3) - 1; 255 od_size = (extword & 3) - 1; 256 sig = fetch_disp(frame, insn, bd_size, &basedisp); 257 if (sig) 258 return sig; 259 if (od_size >= 0) 260 ea->ea_flags |= EA_MEM_INDIR; 261 sig = fetch_disp(frame, insn, od_size, &outerdisp); 262 if (sig) 263 return sig; 264 265 switch (extword & 0x44) { 266 case 0: /* preindexed */ 267 ea->ea_basedisp = basedisp + idx; 268 ea->ea_outerdisp = outerdisp; 269 break; 270 case 4: /* postindexed */ 271 ea->ea_basedisp = basedisp; 272 ea->ea_outerdisp = outerdisp + idx; 273 break; 274 case 0x40: /* no index */ 275 ea->ea_basedisp = basedisp; 276 ea->ea_outerdisp = outerdisp; 277 break; 278 default: 279 DPRINTF(("%s: invalid indirect mode: ext word %04x\n", 280 __func__, extword)); 281 return SIGILL; 282 break; 283 } 284 DPRINTF(("%s: full ext idxreg=%d, basedisp=%x, outerdisp=%x\n", 285 __func__, 286 ea->ea_idxreg, ea->ea_basedisp, ea->ea_outerdisp)); 287 } 288 DPRINTF(("%s: regnum=%d, flags=%x\n", 289 __func__, ea->ea_regnum, ea->ea_flags)); 290 return 0; 291 } 292 293 /* 294 * Load a value from an effective address. 295 * Returns zero on success, else signal number. 296 */ 297 int 298 fpu_load_ea(struct frame *frame, struct instruction *insn, struct insn_ea *ea, 299 char *dst) 300 { 301 int *reg; 302 char *src; 303 int len, step; 304 int sig; 305 306 #ifdef DIAGNOSTIC 307 if (ea->ea_regnum & ~0xF) 308 panic("%s: bad regnum", __func__); 309 #endif 310 311 DPRINTF(("%s: frame at %p\n", __func__, frame)); 312 /* dst is always int or larger. */ 313 len = insn->is_datasize; 314 if (len < 4) 315 dst += (4 - len); 316 step = (len == 1 && ea->ea_regnum == 15 /* sp */) ? 2 : len; 317 318 #if 0 319 if (ea->ea_flags & EA_FRAME_EA) { 320 /* Using LC040 frame EA */ 321 #ifdef DEBUG_FPE 322 if (ea->ea_flags & (EA_PREDECR|EA_POSTINCR)) { 323 printf("%s: frame ea %08x w/r%d\n", 324 __func__, ea->ea_fea, ea->ea_regnum); 325 } else { 326 printf("%s: frame ea %08x\n", __func__, ea->ea_fea); 327 } 328 #endif 329 src = (char *)ea->ea_fea; 330 if (copyin(src + ea->ea_moffs, dst, len) != 0) { 331 return SIGSEGV; 332 } 333 if (ea->ea_flags & EA_PREDECR) { 334 frame->f_regs[ea->ea_regnum] = ea->ea_fea; 335 ea->ea_fea -= step; 336 ea->ea_moffs = 0; 337 } else if (ea->ea_flags & EA_POSTINCR) { 338 ea->ea_fea += step; 339 frame->f_regs[ea->ea_regnum] = ea->ea_fea; 340 ea->ea_moffs = 0; 341 } else { 342 ea->ea_moffs += step; 343 } 344 /* That's it, folks */ 345 } else 346 #endif 347 if (ea->ea_flags & EA_DIRECT) { 348 if (len > 4) { 349 DPRINTF(("%s: operand doesn't fit CPU reg\n", 350 __func__)); 351 return SIGILL; 352 } 353 if (ea->ea_moffs > 0) { 354 DPRINTF(("%s: more than one move from CPU reg\n", 355 __func__)); 356 return SIGILL; 357 } 358 src = (char *)&frame->f_regs[ea->ea_regnum]; 359 /* The source is an int. */ 360 if (len < 4) { 361 src += (4 - len); 362 DPRINTF(("%s: short/byte opr - addr adjusted\n", 363 __func__)); 364 } 365 DPRINTF(("%s: src %p\n", __func__, src)); 366 memcpy(dst, src, len); 367 } else if (ea->ea_flags & EA_IMMED) { 368 DPRINTF(("%s: immed %08x%08x%08x size %d\n", __func__, 369 ea->ea_immed[0], ea->ea_immed[1], ea->ea_immed[2], len)); 370 src = (char *)&ea->ea_immed[0]; 371 if (len < 4) { 372 src += (4 - len); 373 DPRINTF(("%s: short/byte immed opr - addr adjusted\n", 374 __func__)); 375 } 376 memcpy(dst, src, len); 377 } else if (ea->ea_flags & EA_ABS) { 378 DPRINTF(("%s: abs addr %08x\n", __func__, ea->ea_absaddr)); 379 src = (char *)ea->ea_absaddr; 380 if (copyin(src, dst, len) != 0) { 381 return SIGSEGV; 382 } 383 } else /* register indirect */ { 384 if (ea->ea_flags & EA_PC_REL) { 385 DPRINTF(("%s: using PC\n", __func__)); 386 reg = NULL; 387 /* 388 * Grab the register contents. 4 is offset to the first 389 * extension word from the opcode 390 */ 391 src = (char *)insn->is_pc + 4; 392 DPRINTF(("%s: pc relative pc+4 = %p\n", __func__, src)); 393 } else /* not PC relative */ { 394 DPRINTF(("%s: using register %c%d\n", 395 __func__, 396 (ea->ea_regnum >= 8) ? 'a' : 'd', 397 ea->ea_regnum & 7)); 398 /* point to the register */ 399 reg = &frame->f_regs[ea->ea_regnum]; 400 401 if (ea->ea_flags & EA_PREDECR) { 402 DPRINTF(("%s: predecr mode - " 403 "reg decremented\n", __func__)); 404 *reg -= step; 405 ea->ea_moffs = 0; 406 } 407 408 /* Grab the register contents. */ 409 src = (char *)*reg; 410 DPRINTF(("%s: reg indirect reg = %p\n", __func__, src)); 411 } 412 413 sig = calc_ea(ea, src, &src); 414 if (sig) 415 return sig; 416 417 if (copyin(src + ea->ea_moffs, dst, len) != 0) { 418 return SIGSEGV; 419 } 420 421 /* do post-increment */ 422 if (ea->ea_flags & EA_POSTINCR) { 423 if (ea->ea_flags & EA_PC_REL) { 424 DPRINTF(("%s: tried to postincrement PC\n", 425 __func__)); 426 return SIGILL; 427 } 428 *reg += step; 429 ea->ea_moffs = 0; 430 DPRINTF(("%s: postinc mode - reg incremented\n", 431 __func__)); 432 } else { 433 ea->ea_moffs += len; 434 } 435 } 436 437 return 0; 438 } 439 440 /* 441 * Store a value at the effective address. 442 * Returns zero on success, else signal number. 443 */ 444 int 445 fpu_store_ea(struct frame *frame, struct instruction *insn, struct insn_ea *ea, 446 char *src) 447 { 448 int *reg; 449 char *dst; 450 int len, step; 451 int sig; 452 453 #ifdef DIAGNOSTIC 454 if (ea->ea_regnum & ~0xf) 455 panic("%s: bad regnum", __func__); 456 #endif 457 458 if (ea->ea_flags & (EA_IMMED|EA_PC_REL)) { 459 /* not alterable address mode */ 460 DPRINTF(("%s: not alterable address mode\n", __func__)); 461 return SIGILL; 462 } 463 464 /* src is always int or larger. */ 465 len = insn->is_datasize; 466 if (len < 4) 467 src += (4 - len); 468 step = (len == 1 && ea->ea_regnum == 15 /* sp */) ? 2 : len; 469 470 if (ea->ea_flags & EA_FRAME_EA) { 471 /* Using LC040 frame EA */ 472 #ifdef DEBUG_FPE 473 if (ea->ea_flags & (EA_PREDECR|EA_POSTINCR)) { 474 printf("%s: frame ea %08x w/r%d\n", 475 __func__, ea->ea_fea, ea->ea_regnum); 476 } else { 477 printf("%s: frame ea %08x\n", __func__, ea->ea_fea); 478 } 479 #endif 480 dst = (char *)ea->ea_fea; 481 if (copyout(src, dst + ea->ea_moffs, len) != 0) { 482 return SIGSEGV; 483 } 484 if (ea->ea_flags & EA_PREDECR) { 485 frame->f_regs[ea->ea_regnum] = ea->ea_fea; 486 ea->ea_fea -= step; 487 ea->ea_moffs = 0; 488 } else if (ea->ea_flags & EA_POSTINCR) { 489 ea->ea_fea += step; 490 frame->f_regs[ea->ea_regnum] = ea->ea_fea; 491 ea->ea_moffs = 0; 492 } else { 493 ea->ea_moffs += step; 494 } 495 /* That's it, folks */ 496 } else if (ea->ea_flags & EA_ABS) { 497 DPRINTF(("%s: abs addr %08x\n", __func__, ea->ea_absaddr)); 498 dst = (char *)ea->ea_absaddr; 499 if (copyout(src, dst + ea->ea_moffs, len) != 0) { 500 return SIGSEGV; 501 } 502 ea->ea_moffs += len; 503 } else if (ea->ea_flags & EA_DIRECT) { 504 if (len > 4) { 505 DPRINTF(("%s: operand doesn't fit CPU reg\n", 506 __func__)); 507 return SIGILL; 508 } 509 if (ea->ea_moffs > 0) { 510 DPRINTF(("%s: more than one move to CPU reg\n", 511 __func__)); 512 return SIGILL; 513 } 514 dst = (char *)&frame->f_regs[ea->ea_regnum]; 515 /* The destination is an int. */ 516 if (len < 4) { 517 dst += (4 - len); 518 DPRINTF(("%s: short/byte opr - dst addr adjusted\n", 519 __func__)); 520 } 521 DPRINTF(("%s: dst %p\n", __func__, dst)); 522 memcpy(dst, src, len); 523 } else /* One of MANY indirect forms... */ { 524 DPRINTF(("%s: using register %c%d\n", __func__, 525 (ea->ea_regnum >= 8) ? 'a' : 'd', ea->ea_regnum & 7)); 526 /* point to the register */ 527 reg = &(frame->f_regs[ea->ea_regnum]); 528 529 /* do pre-decrement */ 530 if (ea->ea_flags & EA_PREDECR) { 531 DPRINTF(("%s: predecr mode - reg decremented\n", 532 __func__)); 533 *reg -= step; 534 ea->ea_moffs = 0; 535 } 536 537 /* calculate the effective address */ 538 sig = calc_ea(ea, (char *)*reg, &dst); 539 if (sig) 540 return sig; 541 542 DPRINTF(("%s: dst addr=%p+%d\n", __func__, dst, ea->ea_moffs)); 543 if (copyout(src, dst + ea->ea_moffs, len) != 0) { 544 return SIGSEGV; 545 } 546 547 /* do post-increment */ 548 if (ea->ea_flags & EA_POSTINCR) { 549 *reg += step; 550 ea->ea_moffs = 0; 551 DPRINTF(("%s: postinc mode - reg incremented\n", 552 __func__)); 553 } else { 554 ea->ea_moffs += len; 555 } 556 } 557 558 return 0; 559 } 560 561 /* 562 * fetch_immed: fetch immediate operand 563 */ 564 static int 565 fetch_immed(struct frame *frame, struct instruction *insn, int *dst) 566 { 567 int data, ext_bytes; 568 unsigned short sval; 569 570 ext_bytes = insn->is_datasize; 571 572 if (0 < ext_bytes) { 573 if (ufetch_short((void *)(insn->is_pc + insn->is_advance), 574 &sval)) 575 return SIGSEGV; 576 data = sval; 577 if (ext_bytes == 1) { 578 /* sign-extend byte to long */ 579 data &= 0xff; 580 if (data & 0x80) 581 data |= 0xffffff00; 582 } else if (ext_bytes == 2) { 583 /* sign-extend word to long */ 584 data &= 0xffff; 585 if (data & 0x8000) 586 data |= 0xffff0000; 587 } 588 insn->is_advance += 2; 589 dst[0] = data; 590 } 591 if (2 < ext_bytes) { 592 if (ufetch_short((void *)(insn->is_pc + insn->is_advance), 593 &sval)) 594 return SIGSEGV; 595 insn->is_advance += 2; 596 dst[0] <<= 16; 597 dst[0] |= sval; 598 } 599 if (4 < ext_bytes) { 600 if (ufetch_short((void *)(insn->is_pc + insn->is_advance), 601 &sval)) 602 return SIGSEGV; 603 data = sval; 604 dst[1] = data << 16; 605 if (ufetch_short((void *)(insn->is_pc + insn->is_advance + 2), 606 &sval)) 607 return SIGSEGV; 608 insn->is_advance += 4; 609 dst[1] |= sval; 610 } 611 if (8 < ext_bytes) { 612 if (ufetch_short((void *)(insn->is_pc + insn->is_advance), 613 &sval)) 614 return SIGSEGV; 615 data = sval; 616 dst[2] = data << 16; 617 if (ufetch_short((void *)(insn->is_pc + insn->is_advance + 2), 618 &sval)) 619 return SIGSEGV; 620 insn->is_advance += 4; 621 dst[2] |= sval; 622 } 623 624 return 0; 625 } 626 627 /* 628 * fetch_disp: fetch displacement in full extension words 629 */ 630 static int 631 fetch_disp(struct frame *frame, struct instruction *insn, int size, int *res) 632 { 633 int disp, word; 634 unsigned short sval; 635 636 if (size == 1) { 637 if (ufetch_short((void *)(insn->is_pc + insn->is_advance), 638 &sval)) 639 return SIGSEGV; 640 disp = sval; 641 if (disp & 0x8000) { 642 /* sign-extend */ 643 disp |= 0xffff0000; 644 } 645 insn->is_advance += 2; 646 } else if (size == 2) { 647 if (ufetch_short((void *)(insn->is_pc + insn->is_advance), 648 &sval)) 649 return SIGSEGV; 650 word = sval; 651 disp = word << 16; 652 if (ufetch_short((void *)(insn->is_pc + insn->is_advance + 2), 653 &sval)) 654 return SIGSEGV; 655 disp |= sval; 656 insn->is_advance += 4; 657 } else { 658 disp = 0; 659 } 660 *res = disp; 661 return 0; 662 } 663 664 /* 665 * Calculates an effective address for all address modes except for 666 * register direct, absolute, and immediate modes. However, it does 667 * not take care of predecrement/postincrement of register content. 668 * Returns a signal value (0 == no error). 669 */ 670 static int 671 calc_ea(struct insn_ea *ea, char *ptr, char **eaddr) 672 /* ptr: base address (usually a register content) */ 673 /* eaddr: pointer to result pointer */ 674 { 675 int word; 676 unsigned short sval; 677 678 DPRINTF(("%s: reg indirect (reg) = %p\n", __func__, ptr)); 679 680 if (ea->ea_flags & EA_OFFSET) { 681 /* apply the signed offset */ 682 DPRINTF(("%s: offset %d\n", __func__, ea->ea_offset)); 683 ptr += ea->ea_offset; 684 } else if (ea->ea_flags & EA_INDEXED) { 685 DPRINTF(("%s: indexed mode\n", __func__)); 686 687 if (ea->ea_flags & EA_BASE_SUPPRSS) { 688 /* base register is suppressed */ 689 ptr = (char *)ea->ea_basedisp; 690 } else { 691 ptr += ea->ea_basedisp; 692 } 693 694 if (ea->ea_flags & EA_MEM_INDIR) { 695 DPRINTF(("%s: mem indir mode: basedisp=%08x, " 696 "outerdisp=%08x\n", 697 __func__, ea->ea_basedisp, ea->ea_outerdisp)); 698 DPRINTF(("%s: addr fetched from %p\n", __func__, ptr)); 699 /* memory indirect modes */ 700 if (ufetch_short((u_short *)ptr, &sval)) 701 return SIGSEGV; 702 word = sval; 703 word <<= 16; 704 if (ufetch_short((u_short *)(ptr + 2), &sval)) 705 return SIGSEGV; 706 word |= sval; 707 DPRINTF(("%s: fetched ptr 0x%08x\n", __func__, word)); 708 ptr = (char *)word + ea->ea_outerdisp; 709 } 710 } 711 712 *eaddr = ptr; 713 714 return 0; 715 } 716