Home | History | Annotate | Line # | Download | only in fpe
      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