OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [final_interface/] [gdb-5.0/] [sim/] [i960/] [sem.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom 
/* Simulator instruction semantics for i960base.
2 
 
3 
THIS FILE IS MACHINE GENERATED WITH CGEN.
4 
 
5 
Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
6 
 
7 
This file is part of the GNU Simulators.
8 
 
9 
This program is free software; you can redistribute it and/or modify
10 
it under the terms of the GNU General Public License as published by
11 
the Free Software Foundation; either version 2, or (at your option)
12 
any later version.
13 
 
14 
This program is distributed in the hope that it will be useful,
15 
but WITHOUT ANY WARRANTY; without even the implied warranty of
16 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 
GNU General Public License for more details.
18 
 
19 
You should have received a copy of the GNU General Public License along
20 
with this program; if not, write to the Free Software Foundation, Inc.,
21 
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 
 
23 
*/
24 
 
25 
#define WANT_CPU i960base
26 
#define WANT_CPU_I960BASE
27 
 
28 
#include "sim-main.h"
29 
#include "cgen-mem.h"
30 
#include "cgen-ops.h"
31 
 
32 
#undef GET_ATTR
33 
#define GET_ATTR(cpu, num, attr) CGEN_ATTR_VALUE (NULL, abuf->idesc->attrs, CGEN_INSN_##attr)
34 
 
35 
/* This is used so that we can compile two copies of the semantic code,
36 
   one with full feature support and one without that runs fast(er).
37 
   FAST_P, when desired, is defined on the command line, -DFAST_P=1.  */
38 
#if FAST_P
39 
#define SEM_FN_NAME(cpu,fn) XCONCAT3 (cpu,_semf_,fn)
40 
#undef TRACE_RESULT
41 
#define TRACE_RESULT(cpu, abuf, name, type, val)
42 
#else
43 
#define SEM_FN_NAME(cpu,fn) XCONCAT3 (cpu,_sem_,fn)
44 
#endif
45 
 
46 
/* x-invalid: --invalid-- */
47 
 
48 
static SEM_PC
49 
SEM_FN_NAME (i960base,x_invalid) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
50 
{
51 
#define FLD(f) abuf->fields.fmt_empty.f
52 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
53 
  int UNUSED written = 0;
54 
  IADDR UNUSED pc = abuf->addr;
55 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
56 
 
57 
  {
58 
    /* Update the recorded pc in the cpu state struct.
59 
       Only necessary for WITH_SCACHE case, but to avoid the
60 
       conditional compilation ....  */
61 
    SET_H_PC (pc);
62 
    /* Virtual insns have zero size.  Overwrite vpc with address of next insn
63 
       using the default-insn-bitsize spec.  When executing insns in parallel
64 
       we may want to queue the fault and continue execution.  */
65 
    vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
66 
    vpc = sim_engine_invalid_insn (current_cpu, pc, vpc);
67 
  }
68 
 
69 
  return vpc;
70 
#undef FLD
71 
}
72 
 
73 
/* x-after: --after-- */
74 
 
75 
static SEM_PC
76 
SEM_FN_NAME (i960base,x_after) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
77 
{
78 
#define FLD(f) abuf->fields.fmt_empty.f
79 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
80 
  int UNUSED written = 0;
81 
  IADDR UNUSED pc = abuf->addr;
82 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
83 
 
84 
  {
85 
#if WITH_SCACHE_PBB_I960BASE
86 
    i960base_pbb_after (current_cpu, sem_arg);
87 
#endif
88 
  }
89 
 
90 
  return vpc;
91 
#undef FLD
92 
}
93 
 
94 
/* x-before: --before-- */
95 
 
96 
static SEM_PC
97 
SEM_FN_NAME (i960base,x_before) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
98 
{
99 
#define FLD(f) abuf->fields.fmt_empty.f
100 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
101 
  int UNUSED written = 0;
102 
  IADDR UNUSED pc = abuf->addr;
103 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
104 
 
105 
  {
106 
#if WITH_SCACHE_PBB_I960BASE
107 
    i960base_pbb_before (current_cpu, sem_arg);
108 
#endif
109 
  }
110 
 
111 
  return vpc;
112 
#undef FLD
113 
}
114 
 
115 
/* x-cti-chain: --cti-chain-- */
116 
 
117 
static SEM_PC
118 
SEM_FN_NAME (i960base,x_cti_chain) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
119 
{
120 
#define FLD(f) abuf->fields.fmt_empty.f
121 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
122 
  int UNUSED written = 0;
123 
  IADDR UNUSED pc = abuf->addr;
124 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
125 
 
126 
  {
127 
#if WITH_SCACHE_PBB_I960BASE
128 
#ifdef DEFINE_SWITCH
129 
    vpc = i960base_pbb_cti_chain (current_cpu, sem_arg,
130 
                               pbb_br_type, pbb_br_npc);
131 
    BREAK (sem);
132 
#else
133 
    /* FIXME: Allow provision of explicit ifmt spec in insn spec.  */
134 
    vpc = i960base_pbb_cti_chain (current_cpu, sem_arg,
135 
                               CPU_PBB_BR_TYPE (current_cpu),
136 
                               CPU_PBB_BR_NPC (current_cpu));
137 
#endif
138 
#endif
139 
  }
140 
 
141 
  return vpc;
142 
#undef FLD
143 
}
144 
 
145 
/* x-chain: --chain-- */
146 
 
147 
static SEM_PC
148 
SEM_FN_NAME (i960base,x_chain) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
149 
{
150 
#define FLD(f) abuf->fields.fmt_empty.f
151 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
152 
  int UNUSED written = 0;
153 
  IADDR UNUSED pc = abuf->addr;
154 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
155 
 
156 
  {
157 
#if WITH_SCACHE_PBB_I960BASE
158 
    vpc = i960base_pbb_chain (current_cpu, sem_arg);
159 
#ifdef DEFINE_SWITCH
160 
    BREAK (sem);
161 
#endif
162 
#endif
163 
  }
164 
 
165 
  return vpc;
166 
#undef FLD
167 
}
168 
 
169 
/* x-begin: --begin-- */
170 
 
171 
static SEM_PC
172 
SEM_FN_NAME (i960base,x_begin) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
173 
{
174 
#define FLD(f) abuf->fields.fmt_empty.f
175 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
176 
  int UNUSED written = 0;
177 
  IADDR UNUSED pc = abuf->addr;
178 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
179 
 
180 
  {
181 
#if WITH_SCACHE_PBB_I960BASE
182 
#ifdef DEFINE_SWITCH
183 
    /* In the switch case FAST_P is a constant, allowing several optimizations
184 
       in any called inline functions.  */
185 
    vpc = i960base_pbb_begin (current_cpu, FAST_P);
186 
#else
187 
    vpc = i960base_pbb_begin (current_cpu, STATE_RUN_FAST_P (CPU_STATE (current_cpu)));
188 
#endif
189 
#endif
190 
  }
191 
 
192 
  return vpc;
193 
#undef FLD
194 
}
195 
 
196 
/* mulo: mulo $src1, $src2, $dst */
197 
 
198 
static SEM_PC
199 
SEM_FN_NAME (i960base,mulo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
200 
{
201 
#define FLD(f) abuf->fields.sfmt_emul.f
202 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
203 
  int UNUSED written = 0;
204 
  IADDR UNUSED pc = abuf->addr;
205 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
206 
 
207 
  {
208 
    SI opval = MULSI (* FLD (i_src1), * FLD (i_src2));
209 
    * FLD (i_dst) = opval;
210 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
211 
  }
212 
 
213 
  return vpc;
214 
#undef FLD
215 
}
216 
 
217 
/* mulo1: mulo $lit1, $src2, $dst */
218 
 
219 
static SEM_PC
220 
SEM_FN_NAME (i960base,mulo1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
221 
{
222 
#define FLD(f) abuf->fields.sfmt_emul1.f
223 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
224 
  int UNUSED written = 0;
225 
  IADDR UNUSED pc = abuf->addr;
226 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
227 
 
228 
  {
229 
    SI opval = MULSI (FLD (f_src1), * FLD (i_src2));
230 
    * FLD (i_dst) = opval;
231 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
232 
  }
233 
 
234 
  return vpc;
235 
#undef FLD
236 
}
237 
 
238 
/* mulo2: mulo $src1, $lit2, $dst */
239 
 
240 
static SEM_PC
241 
SEM_FN_NAME (i960base,mulo2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
242 
{
243 
#define FLD(f) abuf->fields.sfmt_emul2.f
244 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
245 
  int UNUSED written = 0;
246 
  IADDR UNUSED pc = abuf->addr;
247 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
248 
 
249 
  {
250 
    SI opval = MULSI (* FLD (i_src1), FLD (f_src2));
251 
    * FLD (i_dst) = opval;
252 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
253 
  }
254 
 
255 
  return vpc;
256 
#undef FLD
257 
}
258 
 
259 
/* mulo3: mulo $lit1, $lit2, $dst */
260 
 
261 
static SEM_PC
262 
SEM_FN_NAME (i960base,mulo3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
263 
{
264 
#define FLD(f) abuf->fields.sfmt_emul3.f
265 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
266 
  int UNUSED written = 0;
267 
  IADDR UNUSED pc = abuf->addr;
268 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
269 
 
270 
  {
271 
    SI opval = MULSI (FLD (f_src1), FLD (f_src2));
272 
    * FLD (i_dst) = opval;
273 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
274 
  }
275 
 
276 
  return vpc;
277 
#undef FLD
278 
}
279 
 
280 
/* remo: remo $src1, $src2, $dst */
281 
 
282 
static SEM_PC
283 
SEM_FN_NAME (i960base,remo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
284 
{
285 
#define FLD(f) abuf->fields.sfmt_emul.f
286 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
287 
  int UNUSED written = 0;
288 
  IADDR UNUSED pc = abuf->addr;
289 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
290 
 
291 
  {
292 
    SI opval = UMODSI (* FLD (i_src2), * FLD (i_src1));
293 
    * FLD (i_dst) = opval;
294 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
295 
  }
296 
 
297 
  return vpc;
298 
#undef FLD
299 
}
300 
 
301 
/* remo1: remo $lit1, $src2, $dst */
302 
 
303 
static SEM_PC
304 
SEM_FN_NAME (i960base,remo1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
305 
{
306 
#define FLD(f) abuf->fields.sfmt_emul1.f
307 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
308 
  int UNUSED written = 0;
309 
  IADDR UNUSED pc = abuf->addr;
310 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
311 
 
312 
  {
313 
    SI opval = UMODSI (* FLD (i_src2), FLD (f_src1));
314 
    * FLD (i_dst) = opval;
315 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
316 
  }
317 
 
318 
  return vpc;
319 
#undef FLD
320 
}
321 
 
322 
/* remo2: remo $src1, $lit2, $dst */
323 
 
324 
static SEM_PC
325 
SEM_FN_NAME (i960base,remo2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
326 
{
327 
#define FLD(f) abuf->fields.sfmt_emul2.f
328 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
329 
  int UNUSED written = 0;
330 
  IADDR UNUSED pc = abuf->addr;
331 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
332 
 
333 
  {
334 
    SI opval = UMODSI (FLD (f_src2), * FLD (i_src1));
335 
    * FLD (i_dst) = opval;
336 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
337 
  }
338 
 
339 
  return vpc;
340 
#undef FLD
341 
}
342 
 
343 
/* remo3: remo $lit1, $lit2, $dst */
344 
 
345 
static SEM_PC
346 
SEM_FN_NAME (i960base,remo3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
347 
{
348 
#define FLD(f) abuf->fields.sfmt_emul3.f
349 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
350 
  int UNUSED written = 0;
351 
  IADDR UNUSED pc = abuf->addr;
352 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
353 
 
354 
  {
355 
    SI opval = UMODSI (FLD (f_src2), FLD (f_src1));
356 
    * FLD (i_dst) = opval;
357 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
358 
  }
359 
 
360 
  return vpc;
361 
#undef FLD
362 
}
363 
 
364 
/* divo: divo $src1, $src2, $dst */
365 
 
366 
static SEM_PC
367 
SEM_FN_NAME (i960base,divo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
368 
{
369 
#define FLD(f) abuf->fields.sfmt_emul.f
370 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
371 
  int UNUSED written = 0;
372 
  IADDR UNUSED pc = abuf->addr;
373 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
374 
 
375 
  {
376 
    SI opval = UDIVSI (* FLD (i_src2), * FLD (i_src1));
377 
    * FLD (i_dst) = opval;
378 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
379 
  }
380 
 
381 
  return vpc;
382 
#undef FLD
383 
}
384 
 
385 
/* divo1: divo $lit1, $src2, $dst */
386 
 
387 
static SEM_PC
388 
SEM_FN_NAME (i960base,divo1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
389 
{
390 
#define FLD(f) abuf->fields.sfmt_emul1.f
391 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
392 
  int UNUSED written = 0;
393 
  IADDR UNUSED pc = abuf->addr;
394 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
395 
 
396 
  {
397 
    SI opval = UDIVSI (* FLD (i_src2), FLD (f_src1));
398 
    * FLD (i_dst) = opval;
399 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
400 
  }
401 
 
402 
  return vpc;
403 
#undef FLD
404 
}
405 
 
406 
/* divo2: divo $src1, $lit2, $dst */
407 
 
408 
static SEM_PC
409 
SEM_FN_NAME (i960base,divo2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
410 
{
411 
#define FLD(f) abuf->fields.sfmt_emul2.f
412 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
413 
  int UNUSED written = 0;
414 
  IADDR UNUSED pc = abuf->addr;
415 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
416 
 
417 
  {
418 
    SI opval = UDIVSI (FLD (f_src2), * FLD (i_src1));
419 
    * FLD (i_dst) = opval;
420 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
421 
  }
422 
 
423 
  return vpc;
424 
#undef FLD
425 
}
426 
 
427 
/* divo3: divo $lit1, $lit2, $dst */
428 
 
429 
static SEM_PC
430 
SEM_FN_NAME (i960base,divo3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
431 
{
432 
#define FLD(f) abuf->fields.sfmt_emul3.f
433 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
434 
  int UNUSED written = 0;
435 
  IADDR UNUSED pc = abuf->addr;
436 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
437 
 
438 
  {
439 
    SI opval = UDIVSI (FLD (f_src2), FLD (f_src1));
440 
    * FLD (i_dst) = opval;
441 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
442 
  }
443 
 
444 
  return vpc;
445 
#undef FLD
446 
}
447 
 
448 
/* remi: remi $src1, $src2, $dst */
449 
 
450 
static SEM_PC
451 
SEM_FN_NAME (i960base,remi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
452 
{
453 
#define FLD(f) abuf->fields.sfmt_emul.f
454 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
455 
  int UNUSED written = 0;
456 
  IADDR UNUSED pc = abuf->addr;
457 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
458 
 
459 
  {
460 
    SI opval = MODSI (* FLD (i_src2), * FLD (i_src1));
461 
    * FLD (i_dst) = opval;
462 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
463 
  }
464 
 
465 
  return vpc;
466 
#undef FLD
467 
}
468 
 
469 
/* remi1: remi $lit1, $src2, $dst */
470 
 
471 
static SEM_PC
472 
SEM_FN_NAME (i960base,remi1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
473 
{
474 
#define FLD(f) abuf->fields.sfmt_emul1.f
475 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
476 
  int UNUSED written = 0;
477 
  IADDR UNUSED pc = abuf->addr;
478 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
479 
 
480 
  {
481 
    SI opval = MODSI (* FLD (i_src2), FLD (f_src1));
482 
    * FLD (i_dst) = opval;
483 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
484 
  }
485 
 
486 
  return vpc;
487 
#undef FLD
488 
}
489 
 
490 
/* remi2: remi $src1, $lit2, $dst */
491 
 
492 
static SEM_PC
493 
SEM_FN_NAME (i960base,remi2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
494 
{
495 
#define FLD(f) abuf->fields.sfmt_emul2.f
496 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
497 
  int UNUSED written = 0;
498 
  IADDR UNUSED pc = abuf->addr;
499 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
500 
 
501 
  {
502 
    SI opval = MODSI (FLD (f_src2), * FLD (i_src1));
503 
    * FLD (i_dst) = opval;
504 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
505 
  }
506 
 
507 
  return vpc;
508 
#undef FLD
509 
}
510 
 
511 
/* remi3: remi $lit1, $lit2, $dst */
512 
 
513 
static SEM_PC
514 
SEM_FN_NAME (i960base,remi3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
515 
{
516 
#define FLD(f) abuf->fields.sfmt_emul3.f
517 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
518 
  int UNUSED written = 0;
519 
  IADDR UNUSED pc = abuf->addr;
520 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
521 
 
522 
  {
523 
    SI opval = MODSI (FLD (f_src2), FLD (f_src1));
524 
    * FLD (i_dst) = opval;
525 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
526 
  }
527 
 
528 
  return vpc;
529 
#undef FLD
530 
}
531 
 
532 
/* divi: divi $src1, $src2, $dst */
533 
 
534 
static SEM_PC
535 
SEM_FN_NAME (i960base,divi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
536 
{
537 
#define FLD(f) abuf->fields.sfmt_emul.f
538 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
539 
  int UNUSED written = 0;
540 
  IADDR UNUSED pc = abuf->addr;
541 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
542 
 
543 
  {
544 
    SI opval = DIVSI (* FLD (i_src2), * FLD (i_src1));
545 
    * FLD (i_dst) = opval;
546 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
547 
  }
548 
 
549 
  return vpc;
550 
#undef FLD
551 
}
552 
 
553 
/* divi1: divi $lit1, $src2, $dst */
554 
 
555 
static SEM_PC
556 
SEM_FN_NAME (i960base,divi1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
557 
{
558 
#define FLD(f) abuf->fields.sfmt_emul1.f
559 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
560 
  int UNUSED written = 0;
561 
  IADDR UNUSED pc = abuf->addr;
562 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
563 
 
564 
  {
565 
    SI opval = DIVSI (* FLD (i_src2), FLD (f_src1));
566 
    * FLD (i_dst) = opval;
567 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
568 
  }
569 
 
570 
  return vpc;
571 
#undef FLD
572 
}
573 
 
574 
/* divi2: divi $src1, $lit2, $dst */
575 
 
576 
static SEM_PC
577 
SEM_FN_NAME (i960base,divi2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
578 
{
579 
#define FLD(f) abuf->fields.sfmt_emul2.f
580 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
581 
  int UNUSED written = 0;
582 
  IADDR UNUSED pc = abuf->addr;
583 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
584 
 
585 
  {
586 
    SI opval = DIVSI (FLD (f_src2), * FLD (i_src1));
587 
    * FLD (i_dst) = opval;
588 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
589 
  }
590 
 
591 
  return vpc;
592 
#undef FLD
593 
}
594 
 
595 
/* divi3: divi $lit1, $lit2, $dst */
596 
 
597 
static SEM_PC
598 
SEM_FN_NAME (i960base,divi3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
599 
{
600 
#define FLD(f) abuf->fields.sfmt_emul3.f
601 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
602 
  int UNUSED written = 0;
603 
  IADDR UNUSED pc = abuf->addr;
604 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
605 
 
606 
  {
607 
    SI opval = DIVSI (FLD (f_src2), FLD (f_src1));
608 
    * FLD (i_dst) = opval;
609 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
610 
  }
611 
 
612 
  return vpc;
613 
#undef FLD
614 
}
615 
 
616 
/* addo: addo $src1, $src2, $dst */
617 
 
618 
static SEM_PC
619 
SEM_FN_NAME (i960base,addo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
620 
{
621 
#define FLD(f) abuf->fields.sfmt_emul.f
622 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
623 
  int UNUSED written = 0;
624 
  IADDR UNUSED pc = abuf->addr;
625 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
626 
 
627 
  {
628 
    SI opval = ADDSI (* FLD (i_src1), * FLD (i_src2));
629 
    * FLD (i_dst) = opval;
630 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
631 
  }
632 
 
633 
  return vpc;
634 
#undef FLD
635 
}
636 
 
637 
/* addo1: addo $lit1, $src2, $dst */
638 
 
639 
static SEM_PC
640 
SEM_FN_NAME (i960base,addo1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
641 
{
642 
#define FLD(f) abuf->fields.sfmt_emul1.f
643 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
644 
  int UNUSED written = 0;
645 
  IADDR UNUSED pc = abuf->addr;
646 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
647 
 
648 
  {
649 
    SI opval = ADDSI (FLD (f_src1), * FLD (i_src2));
650 
    * FLD (i_dst) = opval;
651 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
652 
  }
653 
 
654 
  return vpc;
655 
#undef FLD
656 
}
657 
 
658 
/* addo2: addo $src1, $lit2, $dst */
659 
 
660 
static SEM_PC
661 
SEM_FN_NAME (i960base,addo2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
662 
{
663 
#define FLD(f) abuf->fields.sfmt_emul2.f
664 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
665 
  int UNUSED written = 0;
666 
  IADDR UNUSED pc = abuf->addr;
667 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
668 
 
669 
  {
670 
    SI opval = ADDSI (* FLD (i_src1), FLD (f_src2));
671 
    * FLD (i_dst) = opval;
672 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
673 
  }
674 
 
675 
  return vpc;
676 
#undef FLD
677 
}
678 
 
679 
/* addo3: addo $lit1, $lit2, $dst */
680 
 
681 
static SEM_PC
682 
SEM_FN_NAME (i960base,addo3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
683 
{
684 
#define FLD(f) abuf->fields.sfmt_emul3.f
685 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
686 
  int UNUSED written = 0;
687 
  IADDR UNUSED pc = abuf->addr;
688 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
689 
 
690 
  {
691 
    SI opval = ADDSI (FLD (f_src1), FLD (f_src2));
692 
    * FLD (i_dst) = opval;
693 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
694 
  }
695 
 
696 
  return vpc;
697 
#undef FLD
698 
}
699 
 
700 
/* subo: subo $src1, $src2, $dst */
701 
 
702 
static SEM_PC
703 
SEM_FN_NAME (i960base,subo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
704 
{
705 
#define FLD(f) abuf->fields.sfmt_emul.f
706 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
707 
  int UNUSED written = 0;
708 
  IADDR UNUSED pc = abuf->addr;
709 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
710 
 
711 
  {
712 
    SI opval = SUBSI (* FLD (i_src2), * FLD (i_src1));
713 
    * FLD (i_dst) = opval;
714 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
715 
  }
716 
 
717 
  return vpc;
718 
#undef FLD
719 
}
720 
 
721 
/* subo1: subo $lit1, $src2, $dst */
722 
 
723 
static SEM_PC
724 
SEM_FN_NAME (i960base,subo1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
725 
{
726 
#define FLD(f) abuf->fields.sfmt_emul1.f
727 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
728 
  int UNUSED written = 0;
729 
  IADDR UNUSED pc = abuf->addr;
730 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
731 
 
732 
  {
733 
    SI opval = SUBSI (* FLD (i_src2), FLD (f_src1));
734 
    * FLD (i_dst) = opval;
735 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
736 
  }
737 
 
738 
  return vpc;
739 
#undef FLD
740 
}
741 
 
742 
/* subo2: subo $src1, $lit2, $dst */
743 
 
744 
static SEM_PC
745 
SEM_FN_NAME (i960base,subo2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
746 
{
747 
#define FLD(f) abuf->fields.sfmt_emul2.f
748 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
749 
  int UNUSED written = 0;
750 
  IADDR UNUSED pc = abuf->addr;
751 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
752 
 
753 
  {
754 
    SI opval = SUBSI (FLD (f_src2), * FLD (i_src1));
755 
    * FLD (i_dst) = opval;
756 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
757 
  }
758 
 
759 
  return vpc;
760 
#undef FLD
761 
}
762 
 
763 
/* subo3: subo $lit1, $lit2, $dst */
764 
 
765 
static SEM_PC
766 
SEM_FN_NAME (i960base,subo3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
767 
{
768 
#define FLD(f) abuf->fields.sfmt_emul3.f
769 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
770 
  int UNUSED written = 0;
771 
  IADDR UNUSED pc = abuf->addr;
772 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
773 
 
774 
  {
775 
    SI opval = SUBSI (FLD (f_src2), FLD (f_src1));
776 
    * FLD (i_dst) = opval;
777 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
778 
  }
779 
 
780 
  return vpc;
781 
#undef FLD
782 
}
783 
 
784 
/* notbit: notbit $src1, $src2, $dst */
785 
 
786 
static SEM_PC
787 
SEM_FN_NAME (i960base,notbit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
788 
{
789 
#define FLD(f) abuf->fields.sfmt_emul.f
790 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
791 
  int UNUSED written = 0;
792 
  IADDR UNUSED pc = abuf->addr;
793 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
794 
 
795 
  {
796 
    SI opval = XORSI (SLLSI (1, * FLD (i_src1)), * FLD (i_src2));
797 
    * FLD (i_dst) = opval;
798 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
799 
  }
800 
 
801 
  return vpc;
802 
#undef FLD
803 
}
804 
 
805 
/* notbit1: notbit $lit1, $src2, $dst */
806 
 
807 
static SEM_PC
808 
SEM_FN_NAME (i960base,notbit1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
809 
{
810 
#define FLD(f) abuf->fields.sfmt_emul1.f
811 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
812 
  int UNUSED written = 0;
813 
  IADDR UNUSED pc = abuf->addr;
814 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
815 
 
816 
  {
817 
    SI opval = XORSI (SLLSI (1, FLD (f_src1)), * FLD (i_src2));
818 
    * FLD (i_dst) = opval;
819 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
820 
  }
821 
 
822 
  return vpc;
823 
#undef FLD
824 
}
825 
 
826 
/* notbit2: notbit $src1, $lit2, $dst */
827 
 
828 
static SEM_PC
829 
SEM_FN_NAME (i960base,notbit2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
830 
{
831 
#define FLD(f) abuf->fields.sfmt_emul2.f
832 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
833 
  int UNUSED written = 0;
834 
  IADDR UNUSED pc = abuf->addr;
835 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
836 
 
837 
  {
838 
    SI opval = XORSI (SLLSI (1, * FLD (i_src1)), FLD (f_src2));
839 
    * FLD (i_dst) = opval;
840 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
841 
  }
842 
 
843 
  return vpc;
844 
#undef FLD
845 
}
846 
 
847 
/* notbit3: notbit $lit1, $lit2, $dst */
848 
 
849 
static SEM_PC
850 
SEM_FN_NAME (i960base,notbit3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
851 
{
852 
#define FLD(f) abuf->fields.sfmt_emul3.f
853 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
854 
  int UNUSED written = 0;
855 
  IADDR UNUSED pc = abuf->addr;
856 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
857 
 
858 
  {
859 
    SI opval = XORSI (SLLSI (1, FLD (f_src1)), FLD (f_src2));
860 
    * FLD (i_dst) = opval;
861 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
862 
  }
863 
 
864 
  return vpc;
865 
#undef FLD
866 
}
867 
 
868 
/* and: and $src1, $src2, $dst */
869 
 
870 
static SEM_PC
871 
SEM_FN_NAME (i960base,and) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
872 
{
873 
#define FLD(f) abuf->fields.sfmt_emul.f
874 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
875 
  int UNUSED written = 0;
876 
  IADDR UNUSED pc = abuf->addr;
877 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
878 
 
879 
  {
880 
    SI opval = ANDSI (* FLD (i_src1), * FLD (i_src2));
881 
    * FLD (i_dst) = opval;
882 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
883 
  }
884 
 
885 
  return vpc;
886 
#undef FLD
887 
}
888 
 
889 
/* and1: and $lit1, $src2, $dst */
890 
 
891 
static SEM_PC
892 
SEM_FN_NAME (i960base,and1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
893 
{
894 
#define FLD(f) abuf->fields.sfmt_emul1.f
895 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
896 
  int UNUSED written = 0;
897 
  IADDR UNUSED pc = abuf->addr;
898 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
899 
 
900 
  {
901 
    SI opval = ANDSI (FLD (f_src1), * FLD (i_src2));
902 
    * FLD (i_dst) = opval;
903 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
904 
  }
905 
 
906 
  return vpc;
907 
#undef FLD
908 
}
909 
 
910 
/* and2: and $src1, $lit2, $dst */
911 
 
912 
static SEM_PC
913 
SEM_FN_NAME (i960base,and2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
914 
{
915 
#define FLD(f) abuf->fields.sfmt_emul2.f
916 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
917 
  int UNUSED written = 0;
918 
  IADDR UNUSED pc = abuf->addr;
919 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
920 
 
921 
  {
922 
    SI opval = ANDSI (* FLD (i_src1), FLD (f_src2));
923 
    * FLD (i_dst) = opval;
924 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
925 
  }
926 
 
927 
  return vpc;
928 
#undef FLD
929 
}
930 
 
931 
/* and3: and $lit1, $lit2, $dst */
932 
 
933 
static SEM_PC
934 
SEM_FN_NAME (i960base,and3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
935 
{
936 
#define FLD(f) abuf->fields.sfmt_emul3.f
937 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
938 
  int UNUSED written = 0;
939 
  IADDR UNUSED pc = abuf->addr;
940 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
941 
 
942 
  {
943 
    SI opval = ANDSI (FLD (f_src1), FLD (f_src2));
944 
    * FLD (i_dst) = opval;
945 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
946 
  }
947 
 
948 
  return vpc;
949 
#undef FLD
950 
}
951 
 
952 
/* andnot: andnot $src1, $src2, $dst */
953 
 
954 
static SEM_PC
955 
SEM_FN_NAME (i960base,andnot) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
956 
{
957 
#define FLD(f) abuf->fields.sfmt_emul.f
958 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
959 
  int UNUSED written = 0;
960 
  IADDR UNUSED pc = abuf->addr;
961 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
962 
 
963 
  {
964 
    SI opval = ANDSI (* FLD (i_src2), INVSI (* FLD (i_src1)));
965 
    * FLD (i_dst) = opval;
966 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
967 
  }
968 
 
969 
  return vpc;
970 
#undef FLD
971 
}
972 
 
973 
/* andnot1: andnot $lit1, $src2, $dst */
974 
 
975 
static SEM_PC
976 
SEM_FN_NAME (i960base,andnot1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
977 
{
978 
#define FLD(f) abuf->fields.sfmt_emul1.f
979 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
980 
  int UNUSED written = 0;
981 
  IADDR UNUSED pc = abuf->addr;
982 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
983 
 
984 
  {
985 
    SI opval = ANDSI (* FLD (i_src2), INVSI (FLD (f_src1)));
986 
    * FLD (i_dst) = opval;
987 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
988 
  }
989 
 
990 
  return vpc;
991 
#undef FLD
992 
}
993 
 
994 
/* andnot2: andnot $src1, $lit2, $dst */
995 
 
996 
static SEM_PC
997 
SEM_FN_NAME (i960base,andnot2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
998 
{
999 
#define FLD(f) abuf->fields.sfmt_emul2.f
1000 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1001 
  int UNUSED written = 0;
1002 
  IADDR UNUSED pc = abuf->addr;
1003 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1004 
 
1005 
  {
1006 
    SI opval = ANDSI (FLD (f_src2), INVSI (* FLD (i_src1)));
1007 
    * FLD (i_dst) = opval;
1008 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1009 
  }
1010 
 
1011 
  return vpc;
1012 
#undef FLD
1013 
}
1014 
 
1015 
/* andnot3: andnot $lit1, $lit2, $dst */
1016 
 
1017 
static SEM_PC
1018 
SEM_FN_NAME (i960base,andnot3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1019 
{
1020 
#define FLD(f) abuf->fields.sfmt_emul3.f
1021 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1022 
  int UNUSED written = 0;
1023 
  IADDR UNUSED pc = abuf->addr;
1024 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1025 
 
1026 
  {
1027 
    SI opval = ANDSI (FLD (f_src2), INVSI (FLD (f_src1)));
1028 
    * FLD (i_dst) = opval;
1029 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1030 
  }
1031 
 
1032 
  return vpc;
1033 
#undef FLD
1034 
}
1035 
 
1036 
/* setbit: setbit $src1, $src2, $dst */
1037 
 
1038 
static SEM_PC
1039 
SEM_FN_NAME (i960base,setbit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1040 
{
1041 
#define FLD(f) abuf->fields.sfmt_emul.f
1042 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1043 
  int UNUSED written = 0;
1044 
  IADDR UNUSED pc = abuf->addr;
1045 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1046 
 
1047 
  {
1048 
    SI opval = ORSI (SLLSI (1, * FLD (i_src1)), * FLD (i_src2));
1049 
    * FLD (i_dst) = opval;
1050 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1051 
  }
1052 
 
1053 
  return vpc;
1054 
#undef FLD
1055 
}
1056 
 
1057 
/* setbit1: setbit $lit1, $src2, $dst */
1058 
 
1059 
static SEM_PC
1060 
SEM_FN_NAME (i960base,setbit1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1061 
{
1062 
#define FLD(f) abuf->fields.sfmt_emul1.f
1063 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1064 
  int UNUSED written = 0;
1065 
  IADDR UNUSED pc = abuf->addr;
1066 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1067 
 
1068 
  {
1069 
    SI opval = ORSI (SLLSI (1, FLD (f_src1)), * FLD (i_src2));
1070 
    * FLD (i_dst) = opval;
1071 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1072 
  }
1073 
 
1074 
  return vpc;
1075 
#undef FLD
1076 
}
1077 
 
1078 
/* setbit2: setbit $src1, $lit2, $dst */
1079 
 
1080 
static SEM_PC
1081 
SEM_FN_NAME (i960base,setbit2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1082 
{
1083 
#define FLD(f) abuf->fields.sfmt_emul2.f
1084 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1085 
  int UNUSED written = 0;
1086 
  IADDR UNUSED pc = abuf->addr;
1087 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1088 
 
1089 
  {
1090 
    SI opval = ORSI (SLLSI (1, * FLD (i_src1)), FLD (f_src2));
1091 
    * FLD (i_dst) = opval;
1092 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1093 
  }
1094 
 
1095 
  return vpc;
1096 
#undef FLD
1097 
}
1098 
 
1099 
/* setbit3: setbit $lit1, $lit2, $dst */
1100 
 
1101 
static SEM_PC
1102 
SEM_FN_NAME (i960base,setbit3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1103 
{
1104 
#define FLD(f) abuf->fields.sfmt_emul3.f
1105 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1106 
  int UNUSED written = 0;
1107 
  IADDR UNUSED pc = abuf->addr;
1108 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1109 
 
1110 
  {
1111 
    SI opval = ORSI (SLLSI (1, FLD (f_src1)), FLD (f_src2));
1112 
    * FLD (i_dst) = opval;
1113 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1114 
  }
1115 
 
1116 
  return vpc;
1117 
#undef FLD
1118 
}
1119 
 
1120 
/* notand: notand $src1, $src2, $dst */
1121 
 
1122 
static SEM_PC
1123 
SEM_FN_NAME (i960base,notand) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1124 
{
1125 
#define FLD(f) abuf->fields.sfmt_emul.f
1126 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1127 
  int UNUSED written = 0;
1128 
  IADDR UNUSED pc = abuf->addr;
1129 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1130 
 
1131 
  {
1132 
    SI opval = ANDSI (INVSI (* FLD (i_src2)), * FLD (i_src1));
1133 
    * FLD (i_dst) = opval;
1134 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1135 
  }
1136 
 
1137 
  return vpc;
1138 
#undef FLD
1139 
}
1140 
 
1141 
/* notand1: notand $lit1, $src2, $dst */
1142 
 
1143 
static SEM_PC
1144 
SEM_FN_NAME (i960base,notand1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1145 
{
1146 
#define FLD(f) abuf->fields.sfmt_emul1.f
1147 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1148 
  int UNUSED written = 0;
1149 
  IADDR UNUSED pc = abuf->addr;
1150 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1151 
 
1152 
  {
1153 
    SI opval = ANDSI (INVSI (* FLD (i_src2)), FLD (f_src1));
1154 
    * FLD (i_dst) = opval;
1155 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1156 
  }
1157 
 
1158 
  return vpc;
1159 
#undef FLD
1160 
}
1161 
 
1162 
/* notand2: notand $src1, $lit2, $dst */
1163 
 
1164 
static SEM_PC
1165 
SEM_FN_NAME (i960base,notand2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1166 
{
1167 
#define FLD(f) abuf->fields.sfmt_emul2.f
1168 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1169 
  int UNUSED written = 0;
1170 
  IADDR UNUSED pc = abuf->addr;
1171 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1172 
 
1173 
  {
1174 
    SI opval = ANDSI (INVSI (FLD (f_src2)), * FLD (i_src1));
1175 
    * FLD (i_dst) = opval;
1176 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1177 
  }
1178 
 
1179 
  return vpc;
1180 
#undef FLD
1181 
}
1182 
 
1183 
/* notand3: notand $lit1, $lit2, $dst */
1184 
 
1185 
static SEM_PC
1186 
SEM_FN_NAME (i960base,notand3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1187 
{
1188 
#define FLD(f) abuf->fields.sfmt_emul3.f
1189 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1190 
  int UNUSED written = 0;
1191 
  IADDR UNUSED pc = abuf->addr;
1192 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1193 
 
1194 
  {
1195 
    SI opval = ANDSI (INVSI (FLD (f_src2)), FLD (f_src1));
1196 
    * FLD (i_dst) = opval;
1197 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1198 
  }
1199 
 
1200 
  return vpc;
1201 
#undef FLD
1202 
}
1203 
 
1204 
/* xor: xor $src1, $src2, $dst */
1205 
 
1206 
static SEM_PC
1207 
SEM_FN_NAME (i960base,xor) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1208 
{
1209 
#define FLD(f) abuf->fields.sfmt_emul.f
1210 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1211 
  int UNUSED written = 0;
1212 
  IADDR UNUSED pc = abuf->addr;
1213 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1214 
 
1215 
  {
1216 
    SI opval = XORSI (* FLD (i_src1), * FLD (i_src2));
1217 
    * FLD (i_dst) = opval;
1218 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1219 
  }
1220 
 
1221 
  return vpc;
1222 
#undef FLD
1223 
}
1224 
 
1225 
/* xor1: xor $lit1, $src2, $dst */
1226 
 
1227 
static SEM_PC
1228 
SEM_FN_NAME (i960base,xor1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1229 
{
1230 
#define FLD(f) abuf->fields.sfmt_emul1.f
1231 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1232 
  int UNUSED written = 0;
1233 
  IADDR UNUSED pc = abuf->addr;
1234 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1235 
 
1236 
  {
1237 
    SI opval = XORSI (FLD (f_src1), * FLD (i_src2));
1238 
    * FLD (i_dst) = opval;
1239 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1240 
  }
1241 
 
1242 
  return vpc;
1243 
#undef FLD
1244 
}
1245 
 
1246 
/* xor2: xor $src1, $lit2, $dst */
1247 
 
1248 
static SEM_PC
1249 
SEM_FN_NAME (i960base,xor2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1250 
{
1251 
#define FLD(f) abuf->fields.sfmt_emul2.f
1252 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1253 
  int UNUSED written = 0;
1254 
  IADDR UNUSED pc = abuf->addr;
1255 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1256 
 
1257 
  {
1258 
    SI opval = XORSI (* FLD (i_src1), FLD (f_src2));
1259 
    * FLD (i_dst) = opval;
1260 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1261 
  }
1262 
 
1263 
  return vpc;
1264 
#undef FLD
1265 
}
1266 
 
1267 
/* xor3: xor $lit1, $lit2, $dst */
1268 
 
1269 
static SEM_PC
1270 
SEM_FN_NAME (i960base,xor3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1271 
{
1272 
#define FLD(f) abuf->fields.sfmt_emul3.f
1273 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1274 
  int UNUSED written = 0;
1275 
  IADDR UNUSED pc = abuf->addr;
1276 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1277 
 
1278 
  {
1279 
    SI opval = XORSI (FLD (f_src1), FLD (f_src2));
1280 
    * FLD (i_dst) = opval;
1281 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1282 
  }
1283 
 
1284 
  return vpc;
1285 
#undef FLD
1286 
}
1287 
 
1288 
/* or: or $src1, $src2, $dst */
1289 
 
1290 
static SEM_PC
1291 
SEM_FN_NAME (i960base,or) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1292 
{
1293 
#define FLD(f) abuf->fields.sfmt_emul.f
1294 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1295 
  int UNUSED written = 0;
1296 
  IADDR UNUSED pc = abuf->addr;
1297 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1298 
 
1299 
  {
1300 
    SI opval = ORSI (* FLD (i_src1), * FLD (i_src2));
1301 
    * FLD (i_dst) = opval;
1302 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1303 
  }
1304 
 
1305 
  return vpc;
1306 
#undef FLD
1307 
}
1308 
 
1309 
/* or1: or $lit1, $src2, $dst */
1310 
 
1311 
static SEM_PC
1312 
SEM_FN_NAME (i960base,or1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1313 
{
1314 
#define FLD(f) abuf->fields.sfmt_emul1.f
1315 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1316 
  int UNUSED written = 0;
1317 
  IADDR UNUSED pc = abuf->addr;
1318 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1319 
 
1320 
  {
1321 
    SI opval = ORSI (FLD (f_src1), * FLD (i_src2));
1322 
    * FLD (i_dst) = opval;
1323 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1324 
  }
1325 
 
1326 
  return vpc;
1327 
#undef FLD
1328 
}
1329 
 
1330 
/* or2: or $src1, $lit2, $dst */
1331 
 
1332 
static SEM_PC
1333 
SEM_FN_NAME (i960base,or2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1334 
{
1335 
#define FLD(f) abuf->fields.sfmt_emul2.f
1336 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1337 
  int UNUSED written = 0;
1338 
  IADDR UNUSED pc = abuf->addr;
1339 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1340 
 
1341 
  {
1342 
    SI opval = ORSI (* FLD (i_src1), FLD (f_src2));
1343 
    * FLD (i_dst) = opval;
1344 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1345 
  }
1346 
 
1347 
  return vpc;
1348 
#undef FLD
1349 
}
1350 
 
1351 
/* or3: or $lit1, $lit2, $dst */
1352 
 
1353 
static SEM_PC
1354 
SEM_FN_NAME (i960base,or3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1355 
{
1356 
#define FLD(f) abuf->fields.sfmt_emul3.f
1357 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1358 
  int UNUSED written = 0;
1359 
  IADDR UNUSED pc = abuf->addr;
1360 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1361 
 
1362 
  {
1363 
    SI opval = ORSI (FLD (f_src1), FLD (f_src2));
1364 
    * FLD (i_dst) = opval;
1365 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1366 
  }
1367 
 
1368 
  return vpc;
1369 
#undef FLD
1370 
}
1371 
 
1372 
/* nor: nor $src1, $src2, $dst */
1373 
 
1374 
static SEM_PC
1375 
SEM_FN_NAME (i960base,nor) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1376 
{
1377 
#define FLD(f) abuf->fields.sfmt_emul.f
1378 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1379 
  int UNUSED written = 0;
1380 
  IADDR UNUSED pc = abuf->addr;
1381 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1382 
 
1383 
  {
1384 
    SI opval = ANDSI (INVSI (* FLD (i_src2)), INVSI (* FLD (i_src1)));
1385 
    * FLD (i_dst) = opval;
1386 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1387 
  }
1388 
 
1389 
  return vpc;
1390 
#undef FLD
1391 
}
1392 
 
1393 
/* nor1: nor $lit1, $src2, $dst */
1394 
 
1395 
static SEM_PC
1396 
SEM_FN_NAME (i960base,nor1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1397 
{
1398 
#define FLD(f) abuf->fields.sfmt_emul1.f
1399 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1400 
  int UNUSED written = 0;
1401 
  IADDR UNUSED pc = abuf->addr;
1402 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1403 
 
1404 
  {
1405 
    SI opval = ANDSI (INVSI (* FLD (i_src2)), INVSI (FLD (f_src1)));
1406 
    * FLD (i_dst) = opval;
1407 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1408 
  }
1409 
 
1410 
  return vpc;
1411 
#undef FLD
1412 
}
1413 
 
1414 
/* nor2: nor $src1, $lit2, $dst */
1415 
 
1416 
static SEM_PC
1417 
SEM_FN_NAME (i960base,nor2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1418 
{
1419 
#define FLD(f) abuf->fields.sfmt_emul2.f
1420 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1421 
  int UNUSED written = 0;
1422 
  IADDR UNUSED pc = abuf->addr;
1423 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1424 
 
1425 
  {
1426 
    SI opval = ANDSI (INVSI (FLD (f_src2)), INVSI (* FLD (i_src1)));
1427 
    * FLD (i_dst) = opval;
1428 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1429 
  }
1430 
 
1431 
  return vpc;
1432 
#undef FLD
1433 
}
1434 
 
1435 
/* nor3: nor $lit1, $lit2, $dst */
1436 
 
1437 
static SEM_PC
1438 
SEM_FN_NAME (i960base,nor3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1439 
{
1440 
#define FLD(f) abuf->fields.sfmt_emul3.f
1441 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1442 
  int UNUSED written = 0;
1443 
  IADDR UNUSED pc = abuf->addr;
1444 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1445 
 
1446 
  {
1447 
    SI opval = ANDSI (INVSI (FLD (f_src2)), INVSI (FLD (f_src1)));
1448 
    * FLD (i_dst) = opval;
1449 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1450 
  }
1451 
 
1452 
  return vpc;
1453 
#undef FLD
1454 
}
1455 
 
1456 
/* xnor: xnor $src1, $src2, $dst */
1457 
 
1458 
static SEM_PC
1459 
SEM_FN_NAME (i960base,xnor) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1460 
{
1461 
#define FLD(f) abuf->fields.sfmt_emul.f
1462 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1463 
  int UNUSED written = 0;
1464 
  IADDR UNUSED pc = abuf->addr;
1465 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1466 
 
1467 
  {
1468 
    SI opval = INVSI (XORSI (* FLD (i_src1), * FLD (i_src2)));
1469 
    * FLD (i_dst) = opval;
1470 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1471 
  }
1472 
 
1473 
  return vpc;
1474 
#undef FLD
1475 
}
1476 
 
1477 
/* xnor1: xnor $lit1, $src2, $dst */
1478 
 
1479 
static SEM_PC
1480 
SEM_FN_NAME (i960base,xnor1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1481 
{
1482 
#define FLD(f) abuf->fields.sfmt_emul1.f
1483 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1484 
  int UNUSED written = 0;
1485 
  IADDR UNUSED pc = abuf->addr;
1486 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1487 
 
1488 
  {
1489 
    SI opval = INVSI (XORSI (FLD (f_src1), * FLD (i_src2)));
1490 
    * FLD (i_dst) = opval;
1491 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1492 
  }
1493 
 
1494 
  return vpc;
1495 
#undef FLD
1496 
}
1497 
 
1498 
/* xnor2: xnor $src1, $lit2, $dst */
1499 
 
1500 
static SEM_PC
1501 
SEM_FN_NAME (i960base,xnor2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1502 
{
1503 
#define FLD(f) abuf->fields.sfmt_emul2.f
1504 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1505 
  int UNUSED written = 0;
1506 
  IADDR UNUSED pc = abuf->addr;
1507 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1508 
 
1509 
  {
1510 
    SI opval = INVSI (XORSI (* FLD (i_src1), FLD (f_src2)));
1511 
    * FLD (i_dst) = opval;
1512 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1513 
  }
1514 
 
1515 
  return vpc;
1516 
#undef FLD
1517 
}
1518 
 
1519 
/* xnor3: xnor $lit1, $lit2, $dst */
1520 
 
1521 
static SEM_PC
1522 
SEM_FN_NAME (i960base,xnor3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1523 
{
1524 
#define FLD(f) abuf->fields.sfmt_emul3.f
1525 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1526 
  int UNUSED written = 0;
1527 
  IADDR UNUSED pc = abuf->addr;
1528 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1529 
 
1530 
  {
1531 
    SI opval = INVSI (XORSI (FLD (f_src1), FLD (f_src2)));
1532 
    * FLD (i_dst) = opval;
1533 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1534 
  }
1535 
 
1536 
  return vpc;
1537 
#undef FLD
1538 
}
1539 
 
1540 
/* not: not $src1, $src2, $dst */
1541 
 
1542 
static SEM_PC
1543 
SEM_FN_NAME (i960base,not) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1544 
{
1545 
#define FLD(f) abuf->fields.sfmt_emul2.f
1546 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1547 
  int UNUSED written = 0;
1548 
  IADDR UNUSED pc = abuf->addr;
1549 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1550 
 
1551 
  {
1552 
    SI opval = INVSI (* FLD (i_src1));
1553 
    * FLD (i_dst) = opval;
1554 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1555 
  }
1556 
 
1557 
  return vpc;
1558 
#undef FLD
1559 
}
1560 
 
1561 
/* not1: not $lit1, $src2, $dst */
1562 
 
1563 
static SEM_PC
1564 
SEM_FN_NAME (i960base,not1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1565 
{
1566 
#define FLD(f) abuf->fields.sfmt_emul3.f
1567 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1568 
  int UNUSED written = 0;
1569 
  IADDR UNUSED pc = abuf->addr;
1570 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1571 
 
1572 
  {
1573 
    SI opval = INVSI (FLD (f_src1));
1574 
    * FLD (i_dst) = opval;
1575 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1576 
  }
1577 
 
1578 
  return vpc;
1579 
#undef FLD
1580 
}
1581 
 
1582 
/* not2: not $src1, $lit2, $dst */
1583 
 
1584 
static SEM_PC
1585 
SEM_FN_NAME (i960base,not2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1586 
{
1587 
#define FLD(f) abuf->fields.sfmt_emul2.f
1588 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1589 
  int UNUSED written = 0;
1590 
  IADDR UNUSED pc = abuf->addr;
1591 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1592 
 
1593 
  {
1594 
    SI opval = INVSI (* FLD (i_src1));
1595 
    * FLD (i_dst) = opval;
1596 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1597 
  }
1598 
 
1599 
  return vpc;
1600 
#undef FLD
1601 
}
1602 
 
1603 
/* not3: not $lit1, $lit2, $dst */
1604 
 
1605 
static SEM_PC
1606 
SEM_FN_NAME (i960base,not3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1607 
{
1608 
#define FLD(f) abuf->fields.sfmt_emul3.f
1609 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1610 
  int UNUSED written = 0;
1611 
  IADDR UNUSED pc = abuf->addr;
1612 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1613 
 
1614 
  {
1615 
    SI opval = INVSI (FLD (f_src1));
1616 
    * FLD (i_dst) = opval;
1617 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1618 
  }
1619 
 
1620 
  return vpc;
1621 
#undef FLD
1622 
}
1623 
 
1624 
/* ornot: ornot $src1, $src2, $dst */
1625 
 
1626 
static SEM_PC
1627 
SEM_FN_NAME (i960base,ornot) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1628 
{
1629 
#define FLD(f) abuf->fields.sfmt_emul.f
1630 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1631 
  int UNUSED written = 0;
1632 
  IADDR UNUSED pc = abuf->addr;
1633 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1634 
 
1635 
  {
1636 
    SI opval = ORSI (* FLD (i_src2), INVSI (* FLD (i_src1)));
1637 
    * FLD (i_dst) = opval;
1638 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1639 
  }
1640 
 
1641 
  return vpc;
1642 
#undef FLD
1643 
}
1644 
 
1645 
/* ornot1: ornot $lit1, $src2, $dst */
1646 
 
1647 
static SEM_PC
1648 
SEM_FN_NAME (i960base,ornot1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1649 
{
1650 
#define FLD(f) abuf->fields.sfmt_emul1.f
1651 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1652 
  int UNUSED written = 0;
1653 
  IADDR UNUSED pc = abuf->addr;
1654 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1655 
 
1656 
  {
1657 
    SI opval = ORSI (* FLD (i_src2), INVSI (FLD (f_src1)));
1658 
    * FLD (i_dst) = opval;
1659 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1660 
  }
1661 
 
1662 
  return vpc;
1663 
#undef FLD
1664 
}
1665 
 
1666 
/* ornot2: ornot $src1, $lit2, $dst */
1667 
 
1668 
static SEM_PC
1669 
SEM_FN_NAME (i960base,ornot2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1670 
{
1671 
#define FLD(f) abuf->fields.sfmt_emul2.f
1672 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1673 
  int UNUSED written = 0;
1674 
  IADDR UNUSED pc = abuf->addr;
1675 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1676 
 
1677 
  {
1678 
    SI opval = ORSI (FLD (f_src2), INVSI (* FLD (i_src1)));
1679 
    * FLD (i_dst) = opval;
1680 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1681 
  }
1682 
 
1683 
  return vpc;
1684 
#undef FLD
1685 
}
1686 
 
1687 
/* ornot3: ornot $lit1, $lit2, $dst */
1688 
 
1689 
static SEM_PC
1690 
SEM_FN_NAME (i960base,ornot3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1691 
{
1692 
#define FLD(f) abuf->fields.sfmt_emul3.f
1693 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1694 
  int UNUSED written = 0;
1695 
  IADDR UNUSED pc = abuf->addr;
1696 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1697 
 
1698 
  {
1699 
    SI opval = ORSI (FLD (f_src2), INVSI (FLD (f_src1)));
1700 
    * FLD (i_dst) = opval;
1701 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1702 
  }
1703 
 
1704 
  return vpc;
1705 
#undef FLD
1706 
}
1707 
 
1708 
/* clrbit: clrbit $src1, $src2, $dst */
1709 
 
1710 
static SEM_PC
1711 
SEM_FN_NAME (i960base,clrbit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1712 
{
1713 
#define FLD(f) abuf->fields.sfmt_emul.f
1714 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1715 
  int UNUSED written = 0;
1716 
  IADDR UNUSED pc = abuf->addr;
1717 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1718 
 
1719 
  {
1720 
    SI opval = ANDSI (INVSI (SLLSI (1, * FLD (i_src1))), * FLD (i_src2));
1721 
    * FLD (i_dst) = opval;
1722 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1723 
  }
1724 
 
1725 
  return vpc;
1726 
#undef FLD
1727 
}
1728 
 
1729 
/* clrbit1: clrbit $lit1, $src2, $dst */
1730 
 
1731 
static SEM_PC
1732 
SEM_FN_NAME (i960base,clrbit1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1733 
{
1734 
#define FLD(f) abuf->fields.sfmt_emul1.f
1735 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1736 
  int UNUSED written = 0;
1737 
  IADDR UNUSED pc = abuf->addr;
1738 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1739 
 
1740 
  {
1741 
    SI opval = ANDSI (INVSI (SLLSI (1, FLD (f_src1))), * FLD (i_src2));
1742 
    * FLD (i_dst) = opval;
1743 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1744 
  }
1745 
 
1746 
  return vpc;
1747 
#undef FLD
1748 
}
1749 
 
1750 
/* clrbit2: clrbit $src1, $lit2, $dst */
1751 
 
1752 
static SEM_PC
1753 
SEM_FN_NAME (i960base,clrbit2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1754 
{
1755 
#define FLD(f) abuf->fields.sfmt_emul2.f
1756 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1757 
  int UNUSED written = 0;
1758 
  IADDR UNUSED pc = abuf->addr;
1759 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1760 
 
1761 
  {
1762 
    SI opval = ANDSI (INVSI (SLLSI (1, * FLD (i_src1))), FLD (f_src2));
1763 
    * FLD (i_dst) = opval;
1764 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1765 
  }
1766 
 
1767 
  return vpc;
1768 
#undef FLD
1769 
}
1770 
 
1771 
/* clrbit3: clrbit $lit1, $lit2, $dst */
1772 
 
1773 
static SEM_PC
1774 
SEM_FN_NAME (i960base,clrbit3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1775 
{
1776 
#define FLD(f) abuf->fields.sfmt_emul3.f
1777 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1778 
  int UNUSED written = 0;
1779 
  IADDR UNUSED pc = abuf->addr;
1780 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1781 
 
1782 
  {
1783 
    SI opval = ANDSI (INVSI (SLLSI (1, FLD (f_src1))), FLD (f_src2));
1784 
    * FLD (i_dst) = opval;
1785 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1786 
  }
1787 
 
1788 
  return vpc;
1789 
#undef FLD
1790 
}
1791 
 
1792 
/* shlo: shlo $src1, $src2, $dst */
1793 
 
1794 
static SEM_PC
1795 
SEM_FN_NAME (i960base,shlo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1796 
{
1797 
#define FLD(f) abuf->fields.sfmt_emul.f
1798 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1799 
  int UNUSED written = 0;
1800 
  IADDR UNUSED pc = abuf->addr;
1801 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1802 
 
1803 
  {
1804 
    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SLLSI (* FLD (i_src2), * FLD (i_src1)));
1805 
    * FLD (i_dst) = opval;
1806 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1807 
  }
1808 
 
1809 
  return vpc;
1810 
#undef FLD
1811 
}
1812 
 
1813 
/* shlo1: shlo $lit1, $src2, $dst */
1814 
 
1815 
static SEM_PC
1816 
SEM_FN_NAME (i960base,shlo1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1817 
{
1818 
#define FLD(f) abuf->fields.sfmt_emul1.f
1819 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1820 
  int UNUSED written = 0;
1821 
  IADDR UNUSED pc = abuf->addr;
1822 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1823 
 
1824 
  {
1825 
    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SLLSI (* FLD (i_src2), FLD (f_src1)));
1826 
    * FLD (i_dst) = opval;
1827 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1828 
  }
1829 
 
1830 
  return vpc;
1831 
#undef FLD
1832 
}
1833 
 
1834 
/* shlo2: shlo $src1, $lit2, $dst */
1835 
 
1836 
static SEM_PC
1837 
SEM_FN_NAME (i960base,shlo2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1838 
{
1839 
#define FLD(f) abuf->fields.sfmt_emul2.f
1840 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1841 
  int UNUSED written = 0;
1842 
  IADDR UNUSED pc = abuf->addr;
1843 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1844 
 
1845 
  {
1846 
    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SLLSI (FLD (f_src2), * FLD (i_src1)));
1847 
    * FLD (i_dst) = opval;
1848 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1849 
  }
1850 
 
1851 
  return vpc;
1852 
#undef FLD
1853 
}
1854 
 
1855 
/* shlo3: shlo $lit1, $lit2, $dst */
1856 
 
1857 
static SEM_PC
1858 
SEM_FN_NAME (i960base,shlo3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1859 
{
1860 
#define FLD(f) abuf->fields.sfmt_emul3.f
1861 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1862 
  int UNUSED written = 0;
1863 
  IADDR UNUSED pc = abuf->addr;
1864 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1865 
 
1866 
  {
1867 
    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SLLSI (FLD (f_src2), FLD (f_src1)));
1868 
    * FLD (i_dst) = opval;
1869 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1870 
  }
1871 
 
1872 
  return vpc;
1873 
#undef FLD
1874 
}
1875 
 
1876 
/* shro: shro $src1, $src2, $dst */
1877 
 
1878 
static SEM_PC
1879 
SEM_FN_NAME (i960base,shro) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1880 
{
1881 
#define FLD(f) abuf->fields.sfmt_emul.f
1882 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1883 
  int UNUSED written = 0;
1884 
  IADDR UNUSED pc = abuf->addr;
1885 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1886 
 
1887 
  {
1888 
    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SRLSI (* FLD (i_src2), * FLD (i_src1)));
1889 
    * FLD (i_dst) = opval;
1890 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1891 
  }
1892 
 
1893 
  return vpc;
1894 
#undef FLD
1895 
}
1896 
 
1897 
/* shro1: shro $lit1, $src2, $dst */
1898 
 
1899 
static SEM_PC
1900 
SEM_FN_NAME (i960base,shro1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1901 
{
1902 
#define FLD(f) abuf->fields.sfmt_emul1.f
1903 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1904 
  int UNUSED written = 0;
1905 
  IADDR UNUSED pc = abuf->addr;
1906 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1907 
 
1908 
  {
1909 
    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SRLSI (* FLD (i_src2), FLD (f_src1)));
1910 
    * FLD (i_dst) = opval;
1911 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1912 
  }
1913 
 
1914 
  return vpc;
1915 
#undef FLD
1916 
}
1917 
 
1918 
/* shro2: shro $src1, $lit2, $dst */
1919 
 
1920 
static SEM_PC
1921 
SEM_FN_NAME (i960base,shro2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1922 
{
1923 
#define FLD(f) abuf->fields.sfmt_emul2.f
1924 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1925 
  int UNUSED written = 0;
1926 
  IADDR UNUSED pc = abuf->addr;
1927 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1928 
 
1929 
  {
1930 
    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SRLSI (FLD (f_src2), * FLD (i_src1)));
1931 
    * FLD (i_dst) = opval;
1932 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1933 
  }
1934 
 
1935 
  return vpc;
1936 
#undef FLD
1937 
}
1938 
 
1939 
/* shro3: shro $lit1, $lit2, $dst */
1940 
 
1941 
static SEM_PC
1942 
SEM_FN_NAME (i960base,shro3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1943 
{
1944 
#define FLD(f) abuf->fields.sfmt_emul3.f
1945 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1946 
  int UNUSED written = 0;
1947 
  IADDR UNUSED pc = abuf->addr;
1948 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1949 
 
1950 
  {
1951 
    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SRLSI (FLD (f_src2), FLD (f_src1)));
1952 
    * FLD (i_dst) = opval;
1953 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1954 
  }
1955 
 
1956 
  return vpc;
1957 
#undef FLD
1958 
}
1959 
 
1960 
/* shli: shli $src1, $src2, $dst */
1961 
 
1962 
static SEM_PC
1963 
SEM_FN_NAME (i960base,shli) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1964 
{
1965 
#define FLD(f) abuf->fields.sfmt_emul.f
1966 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1967 
  int UNUSED written = 0;
1968 
  IADDR UNUSED pc = abuf->addr;
1969 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1970 
 
1971 
  {
1972 
    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SLLSI (* FLD (i_src2), * FLD (i_src1)));
1973 
    * FLD (i_dst) = opval;
1974 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1975 
  }
1976 
 
1977 
  return vpc;
1978 
#undef FLD
1979 
}
1980 
 
1981 
/* shli1: shli $lit1, $src2, $dst */
1982 
 
1983 
static SEM_PC
1984 
SEM_FN_NAME (i960base,shli1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1985 
{
1986 
#define FLD(f) abuf->fields.sfmt_emul1.f
1987 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1988 
  int UNUSED written = 0;
1989 
  IADDR UNUSED pc = abuf->addr;
1990 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1991 
 
1992 
  {
1993 
    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SLLSI (* FLD (i_src2), FLD (f_src1)));
1994 
    * FLD (i_dst) = opval;
1995 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1996 
  }
1997 
 
1998 
  return vpc;
1999 
#undef FLD
2000 
}
2001 
 
2002 
/* shli2: shli $src1, $lit2, $dst */
2003 
 
2004 
static SEM_PC
2005 
SEM_FN_NAME (i960base,shli2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2006 
{
2007 
#define FLD(f) abuf->fields.sfmt_emul2.f
2008 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2009 
  int UNUSED written = 0;
2010 
  IADDR UNUSED pc = abuf->addr;
2011 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2012 
 
2013 
  {
2014 
    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SLLSI (FLD (f_src2), * FLD (i_src1)));
2015 
    * FLD (i_dst) = opval;
2016 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2017 
  }
2018 
 
2019 
  return vpc;
2020 
#undef FLD
2021 
}
2022 
 
2023 
/* shli3: shli $lit1, $lit2, $dst */
2024 
 
2025 
static SEM_PC
2026 
SEM_FN_NAME (i960base,shli3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2027 
{
2028 
#define FLD(f) abuf->fields.sfmt_emul3.f
2029 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2030 
  int UNUSED written = 0;
2031 
  IADDR UNUSED pc = abuf->addr;
2032 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2033 
 
2034 
  {
2035 
    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SLLSI (FLD (f_src2), FLD (f_src1)));
2036 
    * FLD (i_dst) = opval;
2037 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2038 
  }
2039 
 
2040 
  return vpc;
2041 
#undef FLD
2042 
}
2043 
 
2044 
/* shri: shri $src1, $src2, $dst */
2045 
 
2046 
static SEM_PC
2047 
SEM_FN_NAME (i960base,shri) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2048 
{
2049 
#define FLD(f) abuf->fields.sfmt_emul.f
2050 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2051 
  int UNUSED written = 0;
2052 
  IADDR UNUSED pc = abuf->addr;
2053 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2054 
 
2055 
  {
2056 
    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (SRASI (* FLD (i_src2), 31)) : (SRASI (* FLD (i_src2), * FLD (i_src1)));
2057 
    * FLD (i_dst) = opval;
2058 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2059 
  }
2060 
 
2061 
  return vpc;
2062 
#undef FLD
2063 
}
2064 
 
2065 
/* shri1: shri $lit1, $src2, $dst */
2066 
 
2067 
static SEM_PC
2068 
SEM_FN_NAME (i960base,shri1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2069 
{
2070 
#define FLD(f) abuf->fields.sfmt_emul1.f
2071 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2072 
  int UNUSED written = 0;
2073 
  IADDR UNUSED pc = abuf->addr;
2074 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2075 
 
2076 
  {
2077 
    SI opval = (GEUSI (FLD (f_src1), 32)) ? (SRASI (* FLD (i_src2), 31)) : (SRASI (* FLD (i_src2), FLD (f_src1)));
2078 
    * FLD (i_dst) = opval;
2079 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2080 
  }
2081 
 
2082 
  return vpc;
2083 
#undef FLD
2084 
}
2085 
 
2086 
/* shri2: shri $src1, $lit2, $dst */
2087 
 
2088 
static SEM_PC
2089 
SEM_FN_NAME (i960base,shri2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2090 
{
2091 
#define FLD(f) abuf->fields.sfmt_emul2.f
2092 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2093 
  int UNUSED written = 0;
2094 
  IADDR UNUSED pc = abuf->addr;
2095 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2096 
 
2097 
  {
2098 
    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (SRASI (FLD (f_src2), 31)) : (SRASI (FLD (f_src2), * FLD (i_src1)));
2099 
    * FLD (i_dst) = opval;
2100 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2101 
  }
2102 
 
2103 
  return vpc;
2104 
#undef FLD
2105 
}
2106 
 
2107 
/* shri3: shri $lit1, $lit2, $dst */
2108 
 
2109 
static SEM_PC
2110 
SEM_FN_NAME (i960base,shri3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2111 
{
2112 
#define FLD(f) abuf->fields.sfmt_emul3.f
2113 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2114 
  int UNUSED written = 0;
2115 
  IADDR UNUSED pc = abuf->addr;
2116 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2117 
 
2118 
  {
2119 
    SI opval = (GEUSI (FLD (f_src1), 32)) ? (SRASI (FLD (f_src2), 31)) : (SRASI (FLD (f_src2), FLD (f_src1)));
2120 
    * FLD (i_dst) = opval;
2121 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2122 
  }
2123 
 
2124 
  return vpc;
2125 
#undef FLD
2126 
}
2127 
 
2128 
/* emul: emul $src1, $src2, $dst */
2129 
 
2130 
static SEM_PC
2131 
SEM_FN_NAME (i960base,emul) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2132 
{
2133 
#define FLD(f) abuf->fields.sfmt_emul.f
2134 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2135 
  int UNUSED written = 0;
2136 
  IADDR UNUSED pc = abuf->addr;
2137 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2138 
 
2139 
{
2140 
  DI tmp_temp;
2141 
  SI tmp_dregno;
2142 
  tmp_temp = MULDI (ZEXTSIDI (* FLD (i_src1)), ZEXTSIDI (* FLD (i_src2)));
2143 
  tmp_dregno = FLD (f_srcdst);
2144 
  {
2145 
    SI opval = TRUNCDISI (tmp_temp);
2146 
    * FLD (i_dst) = opval;
2147 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2148 
  }
2149 
  {
2150 
    SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
2151 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2152 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
2153 
  }
2154 
}
2155 
 
2156 
  return vpc;
2157 
#undef FLD
2158 
}
2159 
 
2160 
/* emul1: emul $lit1, $src2, $dst */
2161 
 
2162 
static SEM_PC
2163 
SEM_FN_NAME (i960base,emul1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2164 
{
2165 
#define FLD(f) abuf->fields.sfmt_emul1.f
2166 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2167 
  int UNUSED written = 0;
2168 
  IADDR UNUSED pc = abuf->addr;
2169 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2170 
 
2171 
{
2172 
  DI tmp_temp;
2173 
  SI tmp_dregno;
2174 
  tmp_temp = MULDI (ZEXTSIDI (FLD (f_src1)), ZEXTSIDI (* FLD (i_src2)));
2175 
  tmp_dregno = FLD (f_srcdst);
2176 
  {
2177 
    SI opval = TRUNCDISI (tmp_temp);
2178 
    * FLD (i_dst) = opval;
2179 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2180 
  }
2181 
  {
2182 
    SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
2183 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2184 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
2185 
  }
2186 
}
2187 
 
2188 
  return vpc;
2189 
#undef FLD
2190 
}
2191 
 
2192 
/* emul2: emul $src1, $lit2, $dst */
2193 
 
2194 
static SEM_PC
2195 
SEM_FN_NAME (i960base,emul2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2196 
{
2197 
#define FLD(f) abuf->fields.sfmt_emul2.f
2198 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2199 
  int UNUSED written = 0;
2200 
  IADDR UNUSED pc = abuf->addr;
2201 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2202 
 
2203 
{
2204 
  DI tmp_temp;
2205 
  SI tmp_dregno;
2206 
  tmp_temp = MULDI (ZEXTSIDI (* FLD (i_src1)), ZEXTSIDI (FLD (f_src2)));
2207 
  tmp_dregno = FLD (f_srcdst);
2208 
  {
2209 
    SI opval = TRUNCDISI (tmp_temp);
2210 
    * FLD (i_dst) = opval;
2211 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2212 
  }
2213 
  {
2214 
    SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
2215 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2216 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
2217 
  }
2218 
}
2219 
 
2220 
  return vpc;
2221 
#undef FLD
2222 
}
2223 
 
2224 
/* emul3: emul $lit1, $lit2, $dst */
2225 
 
2226 
static SEM_PC
2227 
SEM_FN_NAME (i960base,emul3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2228 
{
2229 
#define FLD(f) abuf->fields.sfmt_emul3.f
2230 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2231 
  int UNUSED written = 0;
2232 
  IADDR UNUSED pc = abuf->addr;
2233 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2234 
 
2235 
{
2236 
  DI tmp_temp;
2237 
  SI tmp_dregno;
2238 
  tmp_temp = MULDI (ZEXTSIDI (FLD (f_src1)), ZEXTSIDI (FLD (f_src2)));
2239 
  tmp_dregno = FLD (f_srcdst);
2240 
  {
2241 
    SI opval = TRUNCDISI (tmp_temp);
2242 
    * FLD (i_dst) = opval;
2243 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2244 
  }
2245 
  {
2246 
    SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
2247 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2248 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
2249 
  }
2250 
}
2251 
 
2252 
  return vpc;
2253 
#undef FLD
2254 
}
2255 
 
2256 
/* mov: mov $src1, $dst */
2257 
 
2258 
static SEM_PC
2259 
SEM_FN_NAME (i960base,mov) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2260 
{
2261 
#define FLD(f) abuf->fields.sfmt_emul2.f
2262 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2263 
  int UNUSED written = 0;
2264 
  IADDR UNUSED pc = abuf->addr;
2265 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2266 
 
2267 
  {
2268 
    SI opval = * FLD (i_src1);
2269 
    * FLD (i_dst) = opval;
2270 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2271 
  }
2272 
 
2273 
  return vpc;
2274 
#undef FLD
2275 
}
2276 
 
2277 
/* mov1: mov $lit1, $dst */
2278 
 
2279 
static SEM_PC
2280 
SEM_FN_NAME (i960base,mov1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2281 
{
2282 
#define FLD(f) abuf->fields.sfmt_emul3.f
2283 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2284 
  int UNUSED written = 0;
2285 
  IADDR UNUSED pc = abuf->addr;
2286 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2287 
 
2288 
  {
2289 
    SI opval = FLD (f_src1);
2290 
    * FLD (i_dst) = opval;
2291 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2292 
  }
2293 
 
2294 
  return vpc;
2295 
#undef FLD
2296 
}
2297 
 
2298 
/* movl: movl $src1, $dst */
2299 
 
2300 
static SEM_PC
2301 
SEM_FN_NAME (i960base,movl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2302 
{
2303 
#define FLD(f) abuf->fields.sfmt_movq.f
2304 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2305 
  int UNUSED written = 0;
2306 
  IADDR UNUSED pc = abuf->addr;
2307 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2308 
 
2309 
{
2310 
  SI tmp_dregno;
2311 
  SI tmp_sregno;
2312 
  tmp_dregno = FLD (f_srcdst);
2313 
  tmp_sregno = FLD (f_src1);
2314 
  {
2315 
    SI opval = * FLD (i_src1);
2316 
    * FLD (i_dst) = opval;
2317 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2318 
  }
2319 
  {
2320 
    SI opval = CPU (h_gr[((FLD (f_src1)) + (1))]);
2321 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2322 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
2323 
  }
2324 
}
2325 
 
2326 
  return vpc;
2327 
#undef FLD
2328 
}
2329 
 
2330 
/* movl1: movl $lit1, $dst */
2331 
 
2332 
static SEM_PC
2333 
SEM_FN_NAME (i960base,movl1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2334 
{
2335 
#define FLD(f) abuf->fields.sfmt_emul3.f
2336 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2337 
  int UNUSED written = 0;
2338 
  IADDR UNUSED pc = abuf->addr;
2339 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2340 
 
2341 
{
2342 
  SI tmp_dregno;
2343 
  tmp_dregno = FLD (f_srcdst);
2344 
  {
2345 
    SI opval = FLD (f_src1);
2346 
    * FLD (i_dst) = opval;
2347 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2348 
  }
2349 
  {
2350 
    SI opval = 0;
2351 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2352 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
2353 
  }
2354 
}
2355 
 
2356 
  return vpc;
2357 
#undef FLD
2358 
}
2359 
 
2360 
/* movt: movt $src1, $dst */
2361 
 
2362 
static SEM_PC
2363 
SEM_FN_NAME (i960base,movt) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2364 
{
2365 
#define FLD(f) abuf->fields.sfmt_movq.f
2366 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2367 
  int UNUSED written = 0;
2368 
  IADDR UNUSED pc = abuf->addr;
2369 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2370 
 
2371 
{
2372 
  SI tmp_dregno;
2373 
  SI tmp_sregno;
2374 
  tmp_dregno = FLD (f_srcdst);
2375 
  tmp_sregno = FLD (f_src1);
2376 
  {
2377 
    SI opval = * FLD (i_src1);
2378 
    * FLD (i_dst) = opval;
2379 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2380 
  }
2381 
  {
2382 
    SI opval = CPU (h_gr[((FLD (f_src1)) + (1))]);
2383 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2384 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
2385 
  }
2386 
  {
2387 
    SI opval = CPU (h_gr[((FLD (f_src1)) + (2))]);
2388 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
2389 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
2390 
  }
2391 
}
2392 
 
2393 
  return vpc;
2394 
#undef FLD
2395 
}
2396 
 
2397 
/* movt1: movt $lit1, $dst */
2398 
 
2399 
static SEM_PC
2400 
SEM_FN_NAME (i960base,movt1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2401 
{
2402 
#define FLD(f) abuf->fields.sfmt_movq.f
2403 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2404 
  int UNUSED written = 0;
2405 
  IADDR UNUSED pc = abuf->addr;
2406 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2407 
 
2408 
{
2409 
  SI tmp_dregno;
2410 
  tmp_dregno = FLD (f_srcdst);
2411 
  {
2412 
    SI opval = FLD (f_src1);
2413 
    * FLD (i_dst) = opval;
2414 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2415 
  }
2416 
  {
2417 
    SI opval = 0;
2418 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2419 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
2420 
  }
2421 
  {
2422 
    SI opval = 0;
2423 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
2424 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
2425 
  }
2426 
}
2427 
 
2428 
  return vpc;
2429 
#undef FLD
2430 
}
2431 
 
2432 
/* movq: movq $src1, $dst */
2433 
 
2434 
static SEM_PC
2435 
SEM_FN_NAME (i960base,movq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2436 
{
2437 
#define FLD(f) abuf->fields.sfmt_movq.f
2438 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2439 
  int UNUSED written = 0;
2440 
  IADDR UNUSED pc = abuf->addr;
2441 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2442 
 
2443 
{
2444 
  SI tmp_dregno;
2445 
  SI tmp_sregno;
2446 
  tmp_dregno = FLD (f_srcdst);
2447 
  tmp_sregno = FLD (f_src1);
2448 
  {
2449 
    SI opval = * FLD (i_src1);
2450 
    * FLD (i_dst) = opval;
2451 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2452 
  }
2453 
  {
2454 
    SI opval = CPU (h_gr[((FLD (f_src1)) + (1))]);
2455 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2456 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
2457 
  }
2458 
  {
2459 
    SI opval = CPU (h_gr[((FLD (f_src1)) + (2))]);
2460 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
2461 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
2462 
  }
2463 
  {
2464 
    SI opval = CPU (h_gr[((FLD (f_src1)) + (3))]);
2465 
    CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
2466 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-3", 'x', opval);
2467 
  }
2468 
}
2469 
 
2470 
  return vpc;
2471 
#undef FLD
2472 
}
2473 
 
2474 
/* movq1: movq $lit1, $dst */
2475 
 
2476 
static SEM_PC
2477 
SEM_FN_NAME (i960base,movq1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2478 
{
2479 
#define FLD(f) abuf->fields.sfmt_movq.f
2480 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2481 
  int UNUSED written = 0;
2482 
  IADDR UNUSED pc = abuf->addr;
2483 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2484 
 
2485 
{
2486 
  SI tmp_dregno;
2487 
  tmp_dregno = FLD (f_srcdst);
2488 
  {
2489 
    SI opval = FLD (f_src1);
2490 
    * FLD (i_dst) = opval;
2491 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2492 
  }
2493 
  {
2494 
    SI opval = 0;
2495 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2496 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
2497 
  }
2498 
  {
2499 
    SI opval = 0;
2500 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
2501 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
2502 
  }
2503 
  {
2504 
    SI opval = 0;
2505 
    CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
2506 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-3", 'x', opval);
2507 
  }
2508 
}
2509 
 
2510 
  return vpc;
2511 
#undef FLD
2512 
}
2513 
 
2514 
/* modpc: modpc $src1, $src2, $dst */
2515 
 
2516 
static SEM_PC
2517 
SEM_FN_NAME (i960base,modpc) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2518 
{
2519 
#define FLD(f) abuf->fields.sfmt_emul1.f
2520 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2521 
  int UNUSED written = 0;
2522 
  IADDR UNUSED pc = abuf->addr;
2523 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2524 
 
2525 
  {
2526 
    SI opval = * FLD (i_src2);
2527 
    * FLD (i_dst) = opval;
2528 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2529 
  }
2530 
 
2531 
  return vpc;
2532 
#undef FLD
2533 
}
2534 
 
2535 
/* modac: modac $src1, $src2, $dst */
2536 
 
2537 
static SEM_PC
2538 
SEM_FN_NAME (i960base,modac) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2539 
{
2540 
#define FLD(f) abuf->fields.sfmt_emul1.f
2541 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2542 
  int UNUSED written = 0;
2543 
  IADDR UNUSED pc = abuf->addr;
2544 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2545 
 
2546 
  {
2547 
    SI opval = * FLD (i_src2);
2548 
    * FLD (i_dst) = opval;
2549 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2550 
  }
2551 
 
2552 
  return vpc;
2553 
#undef FLD
2554 
}
2555 
 
2556 
/* lda-offset: lda $offset, $dst */
2557 
 
2558 
static SEM_PC
2559 
SEM_FN_NAME (i960base,lda_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2560 
{
2561 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
2562 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2563 
  int UNUSED written = 0;
2564 
  IADDR UNUSED pc = abuf->addr;
2565 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2566 
 
2567 
  {
2568 
    SI opval = FLD (f_offset);
2569 
    * FLD (i_dst) = opval;
2570 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2571 
  }
2572 
 
2573 
  return vpc;
2574 
#undef FLD
2575 
}
2576 
 
2577 
/* lda-indirect-offset: lda $offset($abase), $dst */
2578 
 
2579 
static SEM_PC
2580 
SEM_FN_NAME (i960base,lda_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2581 
{
2582 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
2583 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2584 
  int UNUSED written = 0;
2585 
  IADDR UNUSED pc = abuf->addr;
2586 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2587 
 
2588 
  {
2589 
    SI opval = ADDSI (FLD (f_offset), * FLD (i_abase));
2590 
    * FLD (i_dst) = opval;
2591 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2592 
  }
2593 
 
2594 
  return vpc;
2595 
#undef FLD
2596 
}
2597 
 
2598 
/* lda-indirect: lda ($abase), $dst */
2599 
 
2600 
static SEM_PC
2601 
SEM_FN_NAME (i960base,lda_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2602 
{
2603 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
2604 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2605 
  int UNUSED written = 0;
2606 
  IADDR UNUSED pc = abuf->addr;
2607 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2608 
 
2609 
  {
2610 
    SI opval = * FLD (i_abase);
2611 
    * FLD (i_dst) = opval;
2612 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2613 
  }
2614 
 
2615 
  return vpc;
2616 
#undef FLD
2617 
}
2618 
 
2619 
/* lda-indirect-index: lda ($abase)[$index*S$scale], $dst */
2620 
 
2621 
static SEM_PC
2622 
SEM_FN_NAME (i960base,lda_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2623 
{
2624 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
2625 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2626 
  int UNUSED written = 0;
2627 
  IADDR UNUSED pc = abuf->addr;
2628 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2629 
 
2630 
  {
2631 
    SI opval = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
2632 
    * FLD (i_dst) = opval;
2633 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2634 
  }
2635 
 
2636 
  return vpc;
2637 
#undef FLD
2638 
}
2639 
 
2640 
/* lda-disp: lda $optdisp, $dst */
2641 
 
2642 
static SEM_PC
2643 
SEM_FN_NAME (i960base,lda_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2644 
{
2645 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
2646 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2647 
  int UNUSED written = 0;
2648 
  IADDR UNUSED pc = abuf->addr;
2649 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2650 
 
2651 
  {
2652 
    SI opval = FLD (f_optdisp);
2653 
    * FLD (i_dst) = opval;
2654 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2655 
  }
2656 
 
2657 
  return vpc;
2658 
#undef FLD
2659 
}
2660 
 
2661 
/* lda-indirect-disp: lda $optdisp($abase), $dst */
2662 
 
2663 
static SEM_PC
2664 
SEM_FN_NAME (i960base,lda_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2665 
{
2666 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
2667 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2668 
  int UNUSED written = 0;
2669 
  IADDR UNUSED pc = abuf->addr;
2670 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2671 
 
2672 
  {
2673 
    SI opval = ADDSI (FLD (f_optdisp), * FLD (i_abase));
2674 
    * FLD (i_dst) = opval;
2675 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2676 
  }
2677 
 
2678 
  return vpc;
2679 
#undef FLD
2680 
}
2681 
 
2682 
/* lda-index-disp: lda $optdisp[$index*S$scale], $dst */
2683 
 
2684 
static SEM_PC
2685 
SEM_FN_NAME (i960base,lda_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2686 
{
2687 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
2688 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2689 
  int UNUSED written = 0;
2690 
  IADDR UNUSED pc = abuf->addr;
2691 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2692 
 
2693 
  {
2694 
    SI opval = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
2695 
    * FLD (i_dst) = opval;
2696 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2697 
  }
2698 
 
2699 
  return vpc;
2700 
#undef FLD
2701 
}
2702 
 
2703 
/* lda-indirect-index-disp: lda $optdisp($abase)[$index*S$scale], $dst */
2704 
 
2705 
static SEM_PC
2706 
SEM_FN_NAME (i960base,lda_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2707 
{
2708 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
2709 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2710 
  int UNUSED written = 0;
2711 
  IADDR UNUSED pc = abuf->addr;
2712 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2713 
 
2714 
  {
2715 
    SI opval = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
2716 
    * FLD (i_dst) = opval;
2717 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2718 
  }
2719 
 
2720 
  return vpc;
2721 
#undef FLD
2722 
}
2723 
 
2724 
/* ld-offset: ld $offset, $dst */
2725 
 
2726 
static SEM_PC
2727 
SEM_FN_NAME (i960base,ld_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2728 
{
2729 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
2730 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2731 
  int UNUSED written = 0;
2732 
  IADDR UNUSED pc = abuf->addr;
2733 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2734 
 
2735 
  {
2736 
    SI opval = GETMEMSI (current_cpu, pc, FLD (f_offset));
2737 
    * FLD (i_dst) = opval;
2738 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2739 
  }
2740 
 
2741 
  return vpc;
2742 
#undef FLD
2743 
}
2744 
 
2745 
/* ld-indirect-offset: ld $offset($abase), $dst */
2746 
 
2747 
static SEM_PC
2748 
SEM_FN_NAME (i960base,ld_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2749 
{
2750 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
2751 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2752 
  int UNUSED written = 0;
2753 
  IADDR UNUSED pc = abuf->addr;
2754 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2755 
 
2756 
  {
2757 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)));
2758 
    * FLD (i_dst) = opval;
2759 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2760 
  }
2761 
 
2762 
  return vpc;
2763 
#undef FLD
2764 
}
2765 
 
2766 
/* ld-indirect: ld ($abase), $dst */
2767 
 
2768 
static SEM_PC
2769 
SEM_FN_NAME (i960base,ld_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2770 
{
2771 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
2772 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2773 
  int UNUSED written = 0;
2774 
  IADDR UNUSED pc = abuf->addr;
2775 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2776 
 
2777 
  {
2778 
    SI opval = GETMEMSI (current_cpu, pc, * FLD (i_abase));
2779 
    * FLD (i_dst) = opval;
2780 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2781 
  }
2782 
 
2783 
  return vpc;
2784 
#undef FLD
2785 
}
2786 
 
2787 
/* ld-indirect-index: ld ($abase)[$index*S$scale], $dst */
2788 
 
2789 
static SEM_PC
2790 
SEM_FN_NAME (i960base,ld_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2791 
{
2792 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
2793 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2794 
  int UNUSED written = 0;
2795 
  IADDR UNUSED pc = abuf->addr;
2796 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2797 
 
2798 
  {
2799 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
2800 
    * FLD (i_dst) = opval;
2801 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2802 
  }
2803 
 
2804 
  return vpc;
2805 
#undef FLD
2806 
}
2807 
 
2808 
/* ld-disp: ld $optdisp, $dst */
2809 
 
2810 
static SEM_PC
2811 
SEM_FN_NAME (i960base,ld_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2812 
{
2813 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
2814 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2815 
  int UNUSED written = 0;
2816 
  IADDR UNUSED pc = abuf->addr;
2817 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2818 
 
2819 
  {
2820 
    SI opval = GETMEMSI (current_cpu, pc, FLD (f_optdisp));
2821 
    * FLD (i_dst) = opval;
2822 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2823 
  }
2824 
 
2825 
  return vpc;
2826 
#undef FLD
2827 
}
2828 
 
2829 
/* ld-indirect-disp: ld $optdisp($abase), $dst */
2830 
 
2831 
static SEM_PC
2832 
SEM_FN_NAME (i960base,ld_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2833 
{
2834 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
2835 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2836 
  int UNUSED written = 0;
2837 
  IADDR UNUSED pc = abuf->addr;
2838 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2839 
 
2840 
  {
2841 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)));
2842 
    * FLD (i_dst) = opval;
2843 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2844 
  }
2845 
 
2846 
  return vpc;
2847 
#undef FLD
2848 
}
2849 
 
2850 
/* ld-index-disp: ld $optdisp[$index*S$scale], $dst */
2851 
 
2852 
static SEM_PC
2853 
SEM_FN_NAME (i960base,ld_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2854 
{
2855 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
2856 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2857 
  int UNUSED written = 0;
2858 
  IADDR UNUSED pc = abuf->addr;
2859 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2860 
 
2861 
  {
2862 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
2863 
    * FLD (i_dst) = opval;
2864 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2865 
  }
2866 
 
2867 
  return vpc;
2868 
#undef FLD
2869 
}
2870 
 
2871 
/* ld-indirect-index-disp: ld $optdisp($abase)[$index*S$scale], $dst */
2872 
 
2873 
static SEM_PC
2874 
SEM_FN_NAME (i960base,ld_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2875 
{
2876 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
2877 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2878 
  int UNUSED written = 0;
2879 
  IADDR UNUSED pc = abuf->addr;
2880 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2881 
 
2882 
  {
2883 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))));
2884 
    * FLD (i_dst) = opval;
2885 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2886 
  }
2887 
 
2888 
  return vpc;
2889 
#undef FLD
2890 
}
2891 
 
2892 
/* ldob-offset: ldob $offset, $dst */
2893 
 
2894 
static SEM_PC
2895 
SEM_FN_NAME (i960base,ldob_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2896 
{
2897 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
2898 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2899 
  int UNUSED written = 0;
2900 
  IADDR UNUSED pc = abuf->addr;
2901 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2902 
 
2903 
  {
2904 
    SI opval = GETMEMUQI (current_cpu, pc, FLD (f_offset));
2905 
    * FLD (i_dst) = opval;
2906 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2907 
  }
2908 
 
2909 
  return vpc;
2910 
#undef FLD
2911 
}
2912 
 
2913 
/* ldob-indirect-offset: ldob $offset($abase), $dst */
2914 
 
2915 
static SEM_PC
2916 
SEM_FN_NAME (i960base,ldob_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2917 
{
2918 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
2919 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2920 
  int UNUSED written = 0;
2921 
  IADDR UNUSED pc = abuf->addr;
2922 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2923 
 
2924 
  {
2925 
    SI opval = GETMEMUQI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)));
2926 
    * FLD (i_dst) = opval;
2927 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2928 
  }
2929 
 
2930 
  return vpc;
2931 
#undef FLD
2932 
}
2933 
 
2934 
/* ldob-indirect: ldob ($abase), $dst */
2935 
 
2936 
static SEM_PC
2937 
SEM_FN_NAME (i960base,ldob_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2938 
{
2939 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
2940 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2941 
  int UNUSED written = 0;
2942 
  IADDR UNUSED pc = abuf->addr;
2943 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2944 
 
2945 
  {
2946 
    SI opval = GETMEMUQI (current_cpu, pc, * FLD (i_abase));
2947 
    * FLD (i_dst) = opval;
2948 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2949 
  }
2950 
 
2951 
  return vpc;
2952 
#undef FLD
2953 
}
2954 
 
2955 
/* ldob-indirect-index: ldob ($abase)[$index*S$scale], $dst */
2956 
 
2957 
static SEM_PC
2958 
SEM_FN_NAME (i960base,ldob_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2959 
{
2960 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
2961 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2962 
  int UNUSED written = 0;
2963 
  IADDR UNUSED pc = abuf->addr;
2964 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2965 
 
2966 
  {
2967 
    SI opval = GETMEMUQI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
2968 
    * FLD (i_dst) = opval;
2969 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2970 
  }
2971 
 
2972 
  return vpc;
2973 
#undef FLD
2974 
}
2975 
 
2976 
/* ldob-disp: ldob $optdisp, $dst */
2977 
 
2978 
static SEM_PC
2979 
SEM_FN_NAME (i960base,ldob_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2980 
{
2981 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
2982 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2983 
  int UNUSED written = 0;
2984 
  IADDR UNUSED pc = abuf->addr;
2985 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2986 
 
2987 
  {
2988 
    SI opval = GETMEMUQI (current_cpu, pc, FLD (f_optdisp));
2989 
    * FLD (i_dst) = opval;
2990 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2991 
  }
2992 
 
2993 
  return vpc;
2994 
#undef FLD
2995 
}
2996 
 
2997 
/* ldob-indirect-disp: ldob $optdisp($abase), $dst */
2998 
 
2999 
static SEM_PC
3000 
SEM_FN_NAME (i960base,ldob_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3001 
{
3002 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3003 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3004 
  int UNUSED written = 0;
3005 
  IADDR UNUSED pc = abuf->addr;
3006 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3007 
 
3008 
  {
3009 
    SI opval = GETMEMUQI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)));
3010 
    * FLD (i_dst) = opval;
3011 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3012 
  }
3013 
 
3014 
  return vpc;
3015 
#undef FLD
3016 
}
3017 
 
3018 
/* ldob-index-disp: ldob $optdisp[$index*S$scale], $dst */
3019 
 
3020 
static SEM_PC
3021 
SEM_FN_NAME (i960base,ldob_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3022 
{
3023 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3024 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3025 
  int UNUSED written = 0;
3026 
  IADDR UNUSED pc = abuf->addr;
3027 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3028 
 
3029 
  {
3030 
    SI opval = GETMEMUQI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3031 
    * FLD (i_dst) = opval;
3032 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3033 
  }
3034 
 
3035 
  return vpc;
3036 
#undef FLD
3037 
}
3038 
 
3039 
/* ldob-indirect-index-disp: ldob $optdisp($abase)[$index*S$scale], $dst */
3040 
 
3041 
static SEM_PC
3042 
SEM_FN_NAME (i960base,ldob_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3043 
{
3044 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3045 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3046 
  int UNUSED written = 0;
3047 
  IADDR UNUSED pc = abuf->addr;
3048 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3049 
 
3050 
  {
3051 
    SI opval = GETMEMUQI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))));
3052 
    * FLD (i_dst) = opval;
3053 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3054 
  }
3055 
 
3056 
  return vpc;
3057 
#undef FLD
3058 
}
3059 
 
3060 
/* ldos-offset: ldos $offset, $dst */
3061 
 
3062 
static SEM_PC
3063 
SEM_FN_NAME (i960base,ldos_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3064 
{
3065 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3066 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3067 
  int UNUSED written = 0;
3068 
  IADDR UNUSED pc = abuf->addr;
3069 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3070 
 
3071 
  {
3072 
    SI opval = GETMEMUHI (current_cpu, pc, FLD (f_offset));
3073 
    * FLD (i_dst) = opval;
3074 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3075 
  }
3076 
 
3077 
  return vpc;
3078 
#undef FLD
3079 
}
3080 
 
3081 
/* ldos-indirect-offset: ldos $offset($abase), $dst */
3082 
 
3083 
static SEM_PC
3084 
SEM_FN_NAME (i960base,ldos_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3085 
{
3086 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3087 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3088 
  int UNUSED written = 0;
3089 
  IADDR UNUSED pc = abuf->addr;
3090 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3091 
 
3092 
  {
3093 
    SI opval = GETMEMUHI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)));
3094 
    * FLD (i_dst) = opval;
3095 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3096 
  }
3097 
 
3098 
  return vpc;
3099 
#undef FLD
3100 
}
3101 
 
3102 
/* ldos-indirect: ldos ($abase), $dst */
3103 
 
3104 
static SEM_PC
3105 
SEM_FN_NAME (i960base,ldos_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3106 
{
3107 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3108 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3109 
  int UNUSED written = 0;
3110 
  IADDR UNUSED pc = abuf->addr;
3111 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3112 
 
3113 
  {
3114 
    SI opval = GETMEMUHI (current_cpu, pc, * FLD (i_abase));
3115 
    * FLD (i_dst) = opval;
3116 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3117 
  }
3118 
 
3119 
  return vpc;
3120 
#undef FLD
3121 
}
3122 
 
3123 
/* ldos-indirect-index: ldos ($abase)[$index*S$scale], $dst */
3124 
 
3125 
static SEM_PC
3126 
SEM_FN_NAME (i960base,ldos_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3127 
{
3128 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3129 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3130 
  int UNUSED written = 0;
3131 
  IADDR UNUSED pc = abuf->addr;
3132 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3133 
 
3134 
  {
3135 
    SI opval = GETMEMUHI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3136 
    * FLD (i_dst) = opval;
3137 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3138 
  }
3139 
 
3140 
  return vpc;
3141 
#undef FLD
3142 
}
3143 
 
3144 
/* ldos-disp: ldos $optdisp, $dst */
3145 
 
3146 
static SEM_PC
3147 
SEM_FN_NAME (i960base,ldos_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3148 
{
3149 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3150 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3151 
  int UNUSED written = 0;
3152 
  IADDR UNUSED pc = abuf->addr;
3153 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3154 
 
3155 
  {
3156 
    SI opval = GETMEMUHI (current_cpu, pc, FLD (f_optdisp));
3157 
    * FLD (i_dst) = opval;
3158 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3159 
  }
3160 
 
3161 
  return vpc;
3162 
#undef FLD
3163 
}
3164 
 
3165 
/* ldos-indirect-disp: ldos $optdisp($abase), $dst */
3166 
 
3167 
static SEM_PC
3168 
SEM_FN_NAME (i960base,ldos_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3169 
{
3170 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3171 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3172 
  int UNUSED written = 0;
3173 
  IADDR UNUSED pc = abuf->addr;
3174 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3175 
 
3176 
  {
3177 
    SI opval = GETMEMUHI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)));
3178 
    * FLD (i_dst) = opval;
3179 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3180 
  }
3181 
 
3182 
  return vpc;
3183 
#undef FLD
3184 
}
3185 
 
3186 
/* ldos-index-disp: ldos $optdisp[$index*S$scale], $dst */
3187 
 
3188 
static SEM_PC
3189 
SEM_FN_NAME (i960base,ldos_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3190 
{
3191 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3192 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3193 
  int UNUSED written = 0;
3194 
  IADDR UNUSED pc = abuf->addr;
3195 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3196 
 
3197 
  {
3198 
    SI opval = GETMEMUHI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3199 
    * FLD (i_dst) = opval;
3200 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3201 
  }
3202 
 
3203 
  return vpc;
3204 
#undef FLD
3205 
}
3206 
 
3207 
/* ldos-indirect-index-disp: ldos $optdisp($abase)[$index*S$scale], $dst */
3208 
 
3209 
static SEM_PC
3210 
SEM_FN_NAME (i960base,ldos_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3211 
{
3212 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3213 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3214 
  int UNUSED written = 0;
3215 
  IADDR UNUSED pc = abuf->addr;
3216 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3217 
 
3218 
  {
3219 
    SI opval = GETMEMUHI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))));
3220 
    * FLD (i_dst) = opval;
3221 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3222 
  }
3223 
 
3224 
  return vpc;
3225 
#undef FLD
3226 
}
3227 
 
3228 
/* ldib-offset: ldib $offset, $dst */
3229 
 
3230 
static SEM_PC
3231 
SEM_FN_NAME (i960base,ldib_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3232 
{
3233 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3234 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3235 
  int UNUSED written = 0;
3236 
  IADDR UNUSED pc = abuf->addr;
3237 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3238 
 
3239 
  {
3240 
    SI opval = GETMEMQI (current_cpu, pc, FLD (f_offset));
3241 
    * FLD (i_dst) = opval;
3242 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3243 
  }
3244 
 
3245 
  return vpc;
3246 
#undef FLD
3247 
}
3248 
 
3249 
/* ldib-indirect-offset: ldib $offset($abase), $dst */
3250 
 
3251 
static SEM_PC
3252 
SEM_FN_NAME (i960base,ldib_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3253 
{
3254 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3255 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3256 
  int UNUSED written = 0;
3257 
  IADDR UNUSED pc = abuf->addr;
3258 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3259 
 
3260 
  {
3261 
    SI opval = GETMEMQI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)));
3262 
    * FLD (i_dst) = opval;
3263 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3264 
  }
3265 
 
3266 
  return vpc;
3267 
#undef FLD
3268 
}
3269 
 
3270 
/* ldib-indirect: ldib ($abase), $dst */
3271 
 
3272 
static SEM_PC
3273 
SEM_FN_NAME (i960base,ldib_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3274 
{
3275 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3276 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3277 
  int UNUSED written = 0;
3278 
  IADDR UNUSED pc = abuf->addr;
3279 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3280 
 
3281 
  {
3282 
    SI opval = GETMEMQI (current_cpu, pc, * FLD (i_abase));
3283 
    * FLD (i_dst) = opval;
3284 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3285 
  }
3286 
 
3287 
  return vpc;
3288 
#undef FLD
3289 
}
3290 
 
3291 
/* ldib-indirect-index: ldib ($abase)[$index*S$scale], $dst */
3292 
 
3293 
static SEM_PC
3294 
SEM_FN_NAME (i960base,ldib_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3295 
{
3296 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3297 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3298 
  int UNUSED written = 0;
3299 
  IADDR UNUSED pc = abuf->addr;
3300 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3301 
 
3302 
  {
3303 
    SI opval = GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3304 
    * FLD (i_dst) = opval;
3305 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3306 
  }
3307 
 
3308 
  return vpc;
3309 
#undef FLD
3310 
}
3311 
 
3312 
/* ldib-disp: ldib $optdisp, $dst */
3313 
 
3314 
static SEM_PC
3315 
SEM_FN_NAME (i960base,ldib_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3316 
{
3317 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3318 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3319 
  int UNUSED written = 0;
3320 
  IADDR UNUSED pc = abuf->addr;
3321 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3322 
 
3323 
  {
3324 
    SI opval = GETMEMQI (current_cpu, pc, FLD (f_optdisp));
3325 
    * FLD (i_dst) = opval;
3326 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3327 
  }
3328 
 
3329 
  return vpc;
3330 
#undef FLD
3331 
}
3332 
 
3333 
/* ldib-indirect-disp: ldib $optdisp($abase), $dst */
3334 
 
3335 
static SEM_PC
3336 
SEM_FN_NAME (i960base,ldib_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3337 
{
3338 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3339 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3340 
  int UNUSED written = 0;
3341 
  IADDR UNUSED pc = abuf->addr;
3342 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3343 
 
3344 
  {
3345 
    SI opval = GETMEMQI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)));
3346 
    * FLD (i_dst) = opval;
3347 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3348 
  }
3349 
 
3350 
  return vpc;
3351 
#undef FLD
3352 
}
3353 
 
3354 
/* ldib-index-disp: ldib $optdisp[$index*S$scale], $dst */
3355 
 
3356 
static SEM_PC
3357 
SEM_FN_NAME (i960base,ldib_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3358 
{
3359 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3360 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3361 
  int UNUSED written = 0;
3362 
  IADDR UNUSED pc = abuf->addr;
3363 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3364 
 
3365 
  {
3366 
    SI opval = GETMEMQI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3367 
    * FLD (i_dst) = opval;
3368 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3369 
  }
3370 
 
3371 
  return vpc;
3372 
#undef FLD
3373 
}
3374 
 
3375 
/* ldib-indirect-index-disp: ldib $optdisp($abase)[$index*S$scale], $dst */
3376 
 
3377 
static SEM_PC
3378 
SEM_FN_NAME (i960base,ldib_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3379 
{
3380 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3381 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3382 
  int UNUSED written = 0;
3383 
  IADDR UNUSED pc = abuf->addr;
3384 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3385 
 
3386 
  {
3387 
    SI opval = GETMEMQI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))));
3388 
    * FLD (i_dst) = opval;
3389 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3390 
  }
3391 
 
3392 
  return vpc;
3393 
#undef FLD
3394 
}
3395 
 
3396 
/* ldis-offset: ldis $offset, $dst */
3397 
 
3398 
static SEM_PC
3399 
SEM_FN_NAME (i960base,ldis_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3400 
{
3401 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3402 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3403 
  int UNUSED written = 0;
3404 
  IADDR UNUSED pc = abuf->addr;
3405 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3406 
 
3407 
  {
3408 
    SI opval = GETMEMHI (current_cpu, pc, FLD (f_offset));
3409 
    * FLD (i_dst) = opval;
3410 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3411 
  }
3412 
 
3413 
  return vpc;
3414 
#undef FLD
3415 
}
3416 
 
3417 
/* ldis-indirect-offset: ldis $offset($abase), $dst */
3418 
 
3419 
static SEM_PC
3420 
SEM_FN_NAME (i960base,ldis_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3421 
{
3422 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3423 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3424 
  int UNUSED written = 0;
3425 
  IADDR UNUSED pc = abuf->addr;
3426 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3427 
 
3428 
  {
3429 
    SI opval = GETMEMHI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)));
3430 
    * FLD (i_dst) = opval;
3431 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3432 
  }
3433 
 
3434 
  return vpc;
3435 
#undef FLD
3436 
}
3437 
 
3438 
/* ldis-indirect: ldis ($abase), $dst */
3439 
 
3440 
static SEM_PC
3441 
SEM_FN_NAME (i960base,ldis_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3442 
{
3443 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3444 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3445 
  int UNUSED written = 0;
3446 
  IADDR UNUSED pc = abuf->addr;
3447 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3448 
 
3449 
  {
3450 
    SI opval = GETMEMHI (current_cpu, pc, * FLD (i_abase));
3451 
    * FLD (i_dst) = opval;
3452 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3453 
  }
3454 
 
3455 
  return vpc;
3456 
#undef FLD
3457 
}
3458 
 
3459 
/* ldis-indirect-index: ldis ($abase)[$index*S$scale], $dst */
3460 
 
3461 
static SEM_PC
3462 
SEM_FN_NAME (i960base,ldis_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3463 
{
3464 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3465 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3466 
  int UNUSED written = 0;
3467 
  IADDR UNUSED pc = abuf->addr;
3468 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3469 
 
3470 
  {
3471 
    SI opval = GETMEMHI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3472 
    * FLD (i_dst) = opval;
3473 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3474 
  }
3475 
 
3476 
  return vpc;
3477 
#undef FLD
3478 
}
3479 
 
3480 
/* ldis-disp: ldis $optdisp, $dst */
3481 
 
3482 
static SEM_PC
3483 
SEM_FN_NAME (i960base,ldis_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3484 
{
3485 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3486 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3487 
  int UNUSED written = 0;
3488 
  IADDR UNUSED pc = abuf->addr;
3489 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3490 
 
3491 
  {
3492 
    SI opval = GETMEMHI (current_cpu, pc, FLD (f_optdisp));
3493 
    * FLD (i_dst) = opval;
3494 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3495 
  }
3496 
 
3497 
  return vpc;
3498 
#undef FLD
3499 
}
3500 
 
3501 
/* ldis-indirect-disp: ldis $optdisp($abase), $dst */
3502 
 
3503 
static SEM_PC
3504 
SEM_FN_NAME (i960base,ldis_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3505 
{
3506 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3507 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3508 
  int UNUSED written = 0;
3509 
  IADDR UNUSED pc = abuf->addr;
3510 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3511 
 
3512 
  {
3513 
    SI opval = GETMEMHI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)));
3514 
    * FLD (i_dst) = opval;
3515 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3516 
  }
3517 
 
3518 
  return vpc;
3519 
#undef FLD
3520 
}
3521 
 
3522 
/* ldis-index-disp: ldis $optdisp[$index*S$scale], $dst */
3523 
 
3524 
static SEM_PC
3525 
SEM_FN_NAME (i960base,ldis_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3526 
{
3527 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3528 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3529 
  int UNUSED written = 0;
3530 
  IADDR UNUSED pc = abuf->addr;
3531 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3532 
 
3533 
  {
3534 
    SI opval = GETMEMHI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3535 
    * FLD (i_dst) = opval;
3536 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3537 
  }
3538 
 
3539 
  return vpc;
3540 
#undef FLD
3541 
}
3542 
 
3543 
/* ldis-indirect-index-disp: ldis $optdisp($abase)[$index*S$scale], $dst */
3544 
 
3545 
static SEM_PC
3546 
SEM_FN_NAME (i960base,ldis_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3547 
{
3548 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3549 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3550 
  int UNUSED written = 0;
3551 
  IADDR UNUSED pc = abuf->addr;
3552 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3553 
 
3554 
  {
3555 
    SI opval = GETMEMHI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))));
3556 
    * FLD (i_dst) = opval;
3557 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3558 
  }
3559 
 
3560 
  return vpc;
3561 
#undef FLD
3562 
}
3563 
 
3564 
/* ldl-offset: ldl $offset, $dst */
3565 
 
3566 
static SEM_PC
3567 
SEM_FN_NAME (i960base,ldl_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3568 
{
3569 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3570 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3571 
  int UNUSED written = 0;
3572 
  IADDR UNUSED pc = abuf->addr;
3573 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3574 
 
3575 
{
3576 
  SI tmp_temp;
3577 
  SI tmp_dregno;
3578 
  tmp_dregno = FLD (f_srcdst);
3579 
  tmp_temp = FLD (f_offset);
3580 
  {
3581 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3582 
    * FLD (i_dst) = opval;
3583 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3584 
  }
3585 
  {
3586 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3587 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3588 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
3589 
  }
3590 
}
3591 
 
3592 
  return vpc;
3593 
#undef FLD
3594 
}
3595 
 
3596 
/* ldl-indirect-offset: ldl $offset($abase), $dst */
3597 
 
3598 
static SEM_PC
3599 
SEM_FN_NAME (i960base,ldl_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3600 
{
3601 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3602 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3603 
  int UNUSED written = 0;
3604 
  IADDR UNUSED pc = abuf->addr;
3605 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3606 
 
3607 
{
3608 
  SI tmp_temp;
3609 
  SI tmp_dregno;
3610 
  tmp_dregno = FLD (f_srcdst);
3611 
  tmp_temp = ADDSI (FLD (f_offset), * FLD (i_abase));
3612 
  {
3613 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3614 
    * FLD (i_dst) = opval;
3615 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3616 
  }
3617 
  {
3618 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3619 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3620 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
3621 
  }
3622 
}
3623 
 
3624 
  return vpc;
3625 
#undef FLD
3626 
}
3627 
 
3628 
/* ldl-indirect: ldl ($abase), $dst */
3629 
 
3630 
static SEM_PC
3631 
SEM_FN_NAME (i960base,ldl_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3632 
{
3633 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3634 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3635 
  int UNUSED written = 0;
3636 
  IADDR UNUSED pc = abuf->addr;
3637 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3638 
 
3639 
{
3640 
  SI tmp_temp;
3641 
  SI tmp_dregno;
3642 
  tmp_dregno = FLD (f_srcdst);
3643 
  tmp_temp = * FLD (i_abase);
3644 
  {
3645 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3646 
    * FLD (i_dst) = opval;
3647 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3648 
  }
3649 
  {
3650 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3651 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3652 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
3653 
  }
3654 
}
3655 
 
3656 
  return vpc;
3657 
#undef FLD
3658 
}
3659 
 
3660 
/* ldl-indirect-index: ldl ($abase)[$index*S$scale], $dst */
3661 
 
3662 
static SEM_PC
3663 
SEM_FN_NAME (i960base,ldl_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3664 
{
3665 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3666 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3667 
  int UNUSED written = 0;
3668 
  IADDR UNUSED pc = abuf->addr;
3669 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3670 
 
3671 
{
3672 
  SI tmp_temp;
3673 
  SI tmp_dregno;
3674 
  tmp_dregno = FLD (f_srcdst);
3675 
  tmp_temp = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
3676 
  {
3677 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3678 
    * FLD (i_dst) = opval;
3679 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3680 
  }
3681 
  {
3682 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3683 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3684 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
3685 
  }
3686 
}
3687 
 
3688 
  return vpc;
3689 
#undef FLD
3690 
}
3691 
 
3692 
/* ldl-disp: ldl $optdisp, $dst */
3693 
 
3694 
static SEM_PC
3695 
SEM_FN_NAME (i960base,ldl_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3696 
{
3697 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3698 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3699 
  int UNUSED written = 0;
3700 
  IADDR UNUSED pc = abuf->addr;
3701 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3702 
 
3703 
{
3704 
  SI tmp_temp;
3705 
  SI tmp_dregno;
3706 
  tmp_dregno = FLD (f_srcdst);
3707 
  tmp_temp = FLD (f_optdisp);
3708 
  {
3709 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3710 
    * FLD (i_dst) = opval;
3711 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3712 
  }
3713 
  {
3714 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3715 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3716 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
3717 
  }
3718 
}
3719 
 
3720 
  return vpc;
3721 
#undef FLD
3722 
}
3723 
 
3724 
/* ldl-indirect-disp: ldl $optdisp($abase), $dst */
3725 
 
3726 
static SEM_PC
3727 
SEM_FN_NAME (i960base,ldl_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3728 
{
3729 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3730 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3731 
  int UNUSED written = 0;
3732 
  IADDR UNUSED pc = abuf->addr;
3733 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3734 
 
3735 
{
3736 
  SI tmp_temp;
3737 
  SI tmp_dregno;
3738 
  tmp_dregno = FLD (f_srcdst);
3739 
  tmp_temp = ADDSI (FLD (f_optdisp), * FLD (i_abase));
3740 
  {
3741 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3742 
    * FLD (i_dst) = opval;
3743 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3744 
  }
3745 
  {
3746 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3747 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3748 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
3749 
  }
3750 
}
3751 
 
3752 
  return vpc;
3753 
#undef FLD
3754 
}
3755 
 
3756 
/* ldl-index-disp: ldl $optdisp[$index*S$scale], $dst */
3757 
 
3758 
static SEM_PC
3759 
SEM_FN_NAME (i960base,ldl_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3760 
{
3761 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3762 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3763 
  int UNUSED written = 0;
3764 
  IADDR UNUSED pc = abuf->addr;
3765 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3766 
 
3767 
{
3768 
  SI tmp_temp;
3769 
  SI tmp_dregno;
3770 
  tmp_dregno = FLD (f_srcdst);
3771 
  tmp_temp = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
3772 
  {
3773 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3774 
    * FLD (i_dst) = opval;
3775 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3776 
  }
3777 
  {
3778 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3779 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3780 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
3781 
  }
3782 
}
3783 
 
3784 
  return vpc;
3785 
#undef FLD
3786 
}
3787 
 
3788 
/* ldl-indirect-index-disp: ldl $optdisp($abase)[$index*S$scale], $dst */
3789 
 
3790 
static SEM_PC
3791 
SEM_FN_NAME (i960base,ldl_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3792 
{
3793 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3794 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3795 
  int UNUSED written = 0;
3796 
  IADDR UNUSED pc = abuf->addr;
3797 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3798 
 
3799 
{
3800 
  SI tmp_temp;
3801 
  SI tmp_dregno;
3802 
  tmp_dregno = FLD (f_srcdst);
3803 
  tmp_temp = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3804 
  {
3805 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3806 
    * FLD (i_dst) = opval;
3807 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3808 
  }
3809 
  {
3810 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3811 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3812 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
3813 
  }
3814 
}
3815 
 
3816 
  return vpc;
3817 
#undef FLD
3818 
}
3819 
 
3820 
/* ldt-offset: ldt $offset, $dst */
3821 
 
3822 
static SEM_PC
3823 
SEM_FN_NAME (i960base,ldt_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3824 
{
3825 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3826 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3827 
  int UNUSED written = 0;
3828 
  IADDR UNUSED pc = abuf->addr;
3829 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3830 
 
3831 
{
3832 
  SI tmp_temp;
3833 
  SI tmp_dregno;
3834 
  tmp_dregno = FLD (f_srcdst);
3835 
  tmp_temp = FLD (f_offset);
3836 
  {
3837 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3838 
    * FLD (i_dst) = opval;
3839 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3840 
  }
3841 
  {
3842 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3843 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3844 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
3845 
  }
3846 
  {
3847 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3848 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3849 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
3850 
  }
3851 
}
3852 
 
3853 
  return vpc;
3854 
#undef FLD
3855 
}
3856 
 
3857 
/* ldt-indirect-offset: ldt $offset($abase), $dst */
3858 
 
3859 
static SEM_PC
3860 
SEM_FN_NAME (i960base,ldt_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3861 
{
3862 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3863 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3864 
  int UNUSED written = 0;
3865 
  IADDR UNUSED pc = abuf->addr;
3866 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3867 
 
3868 
{
3869 
  SI tmp_temp;
3870 
  SI tmp_dregno;
3871 
  tmp_dregno = FLD (f_srcdst);
3872 
  tmp_temp = ADDSI (FLD (f_offset), * FLD (i_abase));
3873 
  {
3874 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3875 
    * FLD (i_dst) = opval;
3876 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3877 
  }
3878 
  {
3879 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3880 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3881 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
3882 
  }
3883 
  {
3884 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3885 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3886 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
3887 
  }
3888 
}
3889 
 
3890 
  return vpc;
3891 
#undef FLD
3892 
}
3893 
 
3894 
/* ldt-indirect: ldt ($abase), $dst */
3895 
 
3896 
static SEM_PC
3897 
SEM_FN_NAME (i960base,ldt_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3898 
{
3899 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
3900 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3901 
  int UNUSED written = 0;
3902 
  IADDR UNUSED pc = abuf->addr;
3903 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3904 
 
3905 
{
3906 
  SI tmp_temp;
3907 
  SI tmp_dregno;
3908 
  tmp_dregno = FLD (f_srcdst);
3909 
  tmp_temp = * FLD (i_abase);
3910 
  {
3911 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3912 
    * FLD (i_dst) = opval;
3913 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3914 
  }
3915 
  {
3916 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3917 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3918 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
3919 
  }
3920 
  {
3921 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3922 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3923 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
3924 
  }
3925 
}
3926 
 
3927 
  return vpc;
3928 
#undef FLD
3929 
}
3930 
 
3931 
/* ldt-indirect-index: ldt ($abase)[$index*S$scale], $dst */
3932 
 
3933 
static SEM_PC
3934 
SEM_FN_NAME (i960base,ldt_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3935 
{
3936 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3937 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3938 
  int UNUSED written = 0;
3939 
  IADDR UNUSED pc = abuf->addr;
3940 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3941 
 
3942 
{
3943 
  SI tmp_temp;
3944 
  SI tmp_dregno;
3945 
  tmp_dregno = FLD (f_srcdst);
3946 
  tmp_temp = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
3947 
  {
3948 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3949 
    * FLD (i_dst) = opval;
3950 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3951 
  }
3952 
  {
3953 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3954 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3955 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
3956 
  }
3957 
  {
3958 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3959 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3960 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
3961 
  }
3962 
}
3963 
 
3964 
  return vpc;
3965 
#undef FLD
3966 
}
3967 
 
3968 
/* ldt-disp: ldt $optdisp, $dst */
3969 
 
3970 
static SEM_PC
3971 
SEM_FN_NAME (i960base,ldt_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3972 
{
3973 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
3974 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3975 
  int UNUSED written = 0;
3976 
  IADDR UNUSED pc = abuf->addr;
3977 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3978 
 
3979 
{
3980 
  SI tmp_temp;
3981 
  SI tmp_dregno;
3982 
  tmp_dregno = FLD (f_srcdst);
3983 
  tmp_temp = FLD (f_optdisp);
3984 
  {
3985 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3986 
    * FLD (i_dst) = opval;
3987 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3988 
  }
3989 
  {
3990 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3991 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3992 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
3993 
  }
3994 
  {
3995 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3996 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3997 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
3998 
  }
3999 
}
4000 
 
4001 
  return vpc;
4002 
#undef FLD
4003 
}
4004 
 
4005 
/* ldt-indirect-disp: ldt $optdisp($abase), $dst */
4006 
 
4007 
static SEM_PC
4008 
SEM_FN_NAME (i960base,ldt_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4009 
{
4010 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
4011 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4012 
  int UNUSED written = 0;
4013 
  IADDR UNUSED pc = abuf->addr;
4014 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4015 
 
4016 
{
4017 
  SI tmp_temp;
4018 
  SI tmp_dregno;
4019 
  tmp_dregno = FLD (f_srcdst);
4020 
  tmp_temp = ADDSI (FLD (f_optdisp), * FLD (i_abase));
4021 
  {
4022 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4023 
    * FLD (i_dst) = opval;
4024 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4025 
  }
4026 
  {
4027 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4028 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4029 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
4030 
  }
4031 
  {
4032 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4033 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4034 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
4035 
  }
4036 
}
4037 
 
4038 
  return vpc;
4039 
#undef FLD
4040 
}
4041 
 
4042 
/* ldt-index-disp: ldt $optdisp[$index*S$scale], $dst */
4043 
 
4044 
static SEM_PC
4045 
SEM_FN_NAME (i960base,ldt_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4046 
{
4047 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
4048 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4049 
  int UNUSED written = 0;
4050 
  IADDR UNUSED pc = abuf->addr;
4051 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4052 
 
4053 
{
4054 
  SI tmp_temp;
4055 
  SI tmp_dregno;
4056 
  tmp_dregno = FLD (f_srcdst);
4057 
  tmp_temp = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
4058 
  {
4059 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4060 
    * FLD (i_dst) = opval;
4061 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4062 
  }
4063 
  {
4064 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4065 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4066 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
4067 
  }
4068 
  {
4069 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4070 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4071 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
4072 
  }
4073 
}
4074 
 
4075 
  return vpc;
4076 
#undef FLD
4077 
}
4078 
 
4079 
/* ldt-indirect-index-disp: ldt $optdisp($abase)[$index*S$scale], $dst */
4080 
 
4081 
static SEM_PC
4082 
SEM_FN_NAME (i960base,ldt_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4083 
{
4084 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
4085 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4086 
  int UNUSED written = 0;
4087 
  IADDR UNUSED pc = abuf->addr;
4088 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4089 
 
4090 
{
4091 
  SI tmp_temp;
4092 
  SI tmp_dregno;
4093 
  tmp_dregno = FLD (f_srcdst);
4094 
  tmp_temp = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
4095 
  {
4096 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4097 
    * FLD (i_dst) = opval;
4098 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4099 
  }
4100 
  {
4101 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4102 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4103 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
4104 
  }
4105 
  {
4106 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4107 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4108 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
4109 
  }
4110 
}
4111 
 
4112 
  return vpc;
4113 
#undef FLD
4114 
}
4115 
 
4116 
/* ldq-offset: ldq $offset, $dst */
4117 
 
4118 
static SEM_PC
4119 
SEM_FN_NAME (i960base,ldq_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4120 
{
4121 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
4122 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4123 
  int UNUSED written = 0;
4124 
  IADDR UNUSED pc = abuf->addr;
4125 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4126 
 
4127 
{
4128 
  SI tmp_temp;
4129 
  SI tmp_dregno;
4130 
  tmp_dregno = FLD (f_srcdst);
4131 
  tmp_temp = FLD (f_offset);
4132 
  {
4133 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4134 
    * FLD (i_dst) = opval;
4135 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4136 
  }
4137 
  {
4138 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4139 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4140 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
4141 
  }
4142 
  {
4143 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4144 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4145 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
4146 
  }
4147 
  {
4148 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4149 
    CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4150 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-3", 'x', opval);
4151 
  }
4152 
}
4153 
 
4154 
  return vpc;
4155 
#undef FLD
4156 
}
4157 
 
4158 
/* ldq-indirect-offset: ldq $offset($abase), $dst */
4159 
 
4160 
static SEM_PC
4161 
SEM_FN_NAME (i960base,ldq_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4162 
{
4163 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
4164 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4165 
  int UNUSED written = 0;
4166 
  IADDR UNUSED pc = abuf->addr;
4167 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4168 
 
4169 
{
4170 
  SI tmp_temp;
4171 
  SI tmp_dregno;
4172 
  tmp_dregno = FLD (f_srcdst);
4173 
  tmp_temp = ADDSI (FLD (f_offset), * FLD (i_abase));
4174 
  {
4175 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4176 
    * FLD (i_dst) = opval;
4177 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4178 
  }
4179 
  {
4180 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4181 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4182 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
4183 
  }
4184 
  {
4185 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4186 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4187 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
4188 
  }
4189 
  {
4190 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4191 
    CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4192 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-3", 'x', opval);
4193 
  }
4194 
}
4195 
 
4196 
  return vpc;
4197 
#undef FLD
4198 
}
4199 
 
4200 
/* ldq-indirect: ldq ($abase), $dst */
4201 
 
4202 
static SEM_PC
4203 
SEM_FN_NAME (i960base,ldq_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4204 
{
4205 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_offset.f
4206 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4207 
  int UNUSED written = 0;
4208 
  IADDR UNUSED pc = abuf->addr;
4209 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4210 
 
4211 
{
4212 
  SI tmp_temp;
4213 
  SI tmp_dregno;
4214 
  tmp_dregno = FLD (f_srcdst);
4215 
  tmp_temp = * FLD (i_abase);
4216 
  {
4217 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4218 
    * FLD (i_dst) = opval;
4219 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4220 
  }
4221 
  {
4222 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4223 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4224 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
4225 
  }
4226 
  {
4227 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4228 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4229 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
4230 
  }
4231 
  {
4232 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4233 
    CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4234 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-3", 'x', opval);
4235 
  }
4236 
}
4237 
 
4238 
  return vpc;
4239 
#undef FLD
4240 
}
4241 
 
4242 
/* ldq-indirect-index: ldq ($abase)[$index*S$scale], $dst */
4243 
 
4244 
static SEM_PC
4245 
SEM_FN_NAME (i960base,ldq_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4246 
{
4247 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
4248 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4249 
  int UNUSED written = 0;
4250 
  IADDR UNUSED pc = abuf->addr;
4251 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4252 
 
4253 
{
4254 
  SI tmp_temp;
4255 
  SI tmp_dregno;
4256 
  tmp_dregno = FLD (f_srcdst);
4257 
  tmp_temp = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
4258 
  {
4259 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4260 
    * FLD (i_dst) = opval;
4261 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4262 
  }
4263 
  {
4264 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4265 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4266 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
4267 
  }
4268 
  {
4269 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4270 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4271 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
4272 
  }
4273 
  {
4274 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4275 
    CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4276 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-3", 'x', opval);
4277 
  }
4278 
}
4279 
 
4280 
  return vpc;
4281 
#undef FLD
4282 
}
4283 
 
4284 
/* ldq-disp: ldq $optdisp, $dst */
4285 
 
4286 
static SEM_PC
4287 
SEM_FN_NAME (i960base,ldq_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4288 
{
4289 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
4290 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4291 
  int UNUSED written = 0;
4292 
  IADDR UNUSED pc = abuf->addr;
4293 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4294 
 
4295 
{
4296 
  SI tmp_temp;
4297 
  SI tmp_dregno;
4298 
  tmp_dregno = FLD (f_srcdst);
4299 
  tmp_temp = FLD (f_optdisp);
4300 
  {
4301 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4302 
    * FLD (i_dst) = opval;
4303 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4304 
  }
4305 
  {
4306 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4307 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4308 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
4309 
  }
4310 
  {
4311 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4312 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4313 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
4314 
  }
4315 
  {
4316 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4317 
    CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4318 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-3", 'x', opval);
4319 
  }
4320 
}
4321 
 
4322 
  return vpc;
4323 
#undef FLD
4324 
}
4325 
 
4326 
/* ldq-indirect-disp: ldq $optdisp($abase), $dst */
4327 
 
4328 
static SEM_PC
4329 
SEM_FN_NAME (i960base,ldq_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4330 
{
4331 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
4332 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4333 
  int UNUSED written = 0;
4334 
  IADDR UNUSED pc = abuf->addr;
4335 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4336 
 
4337 
{
4338 
  SI tmp_temp;
4339 
  SI tmp_dregno;
4340 
  tmp_dregno = FLD (f_srcdst);
4341 
  tmp_temp = ADDSI (FLD (f_optdisp), * FLD (i_abase));
4342 
  {
4343 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4344 
    * FLD (i_dst) = opval;
4345 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4346 
  }
4347 
  {
4348 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4349 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4350 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
4351 
  }
4352 
  {
4353 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4354 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4355 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
4356 
  }
4357 
  {
4358 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4359 
    CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4360 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-3", 'x', opval);
4361 
  }
4362 
}
4363 
 
4364 
  return vpc;
4365 
#undef FLD
4366 
}
4367 
 
4368 
/* ldq-index-disp: ldq $optdisp[$index*S$scale], $dst */
4369 
 
4370 
static SEM_PC
4371 
SEM_FN_NAME (i960base,ldq_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4372 
{
4373 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
4374 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4375 
  int UNUSED written = 0;
4376 
  IADDR UNUSED pc = abuf->addr;
4377 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4378 
 
4379 
{
4380 
  SI tmp_temp;
4381 
  SI tmp_dregno;
4382 
  tmp_dregno = FLD (f_srcdst);
4383 
  tmp_temp = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
4384 
  {
4385 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4386 
    * FLD (i_dst) = opval;
4387 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4388 
  }
4389 
  {
4390 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4391 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4392 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
4393 
  }
4394 
  {
4395 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4396 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4397 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
4398 
  }
4399 
  {
4400 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4401 
    CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4402 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-3", 'x', opval);
4403 
  }
4404 
}
4405 
 
4406 
  return vpc;
4407 
#undef FLD
4408 
}
4409 
 
4410 
/* ldq-indirect-index-disp: ldq $optdisp($abase)[$index*S$scale], $dst */
4411 
 
4412 
static SEM_PC
4413 
SEM_FN_NAME (i960base,ldq_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4414 
{
4415 
#define FLD(f) abuf->fields.sfmt_ldq_indirect_index_disp.f
4416 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4417 
  int UNUSED written = 0;
4418 
  IADDR UNUSED pc = abuf->addr;
4419 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4420 
 
4421 
{
4422 
  SI tmp_temp;
4423 
  SI tmp_dregno;
4424 
  tmp_dregno = FLD (f_srcdst);
4425 
  tmp_temp = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
4426 
  {
4427 
    SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4428 
    * FLD (i_dst) = opval;
4429 
    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4430 
  }
4431 
  {
4432 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4433 
    CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4434 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-1", 'x', opval);
4435 
  }
4436 
  {
4437 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4438 
    CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4439 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-2", 'x', opval);
4440 
  }
4441 
  {
4442 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4443 
    CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4444 
    TRACE_RESULT (current_cpu, abuf, "gr-add--DFLT-index-of--DFLT-dst-3", 'x', opval);
4445 
  }
4446 
}
4447 
 
4448 
  return vpc;
4449 
#undef FLD
4450 
}
4451 
 
4452 
/* st-offset: st $st_src, $offset */
4453 
 
4454 
static SEM_PC
4455 
SEM_FN_NAME (i960base,st_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4456 
{
4457 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
4458 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4459 
  int UNUSED written = 0;
4460 
  IADDR UNUSED pc = abuf->addr;
4461 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4462 
 
4463 
  {
4464 
    SI opval = * FLD (i_st_src);
4465 
    SETMEMSI (current_cpu, pc, FLD (f_offset), opval);
4466 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4467 
  }
4468 
 
4469 
  return vpc;
4470 
#undef FLD
4471 
}
4472 
 
4473 
/* st-indirect-offset: st $st_src, $offset($abase) */
4474 
 
4475 
static SEM_PC
4476 
SEM_FN_NAME (i960base,st_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4477 
{
4478 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
4479 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4480 
  int UNUSED written = 0;
4481 
  IADDR UNUSED pc = abuf->addr;
4482 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4483 
 
4484 
  {
4485 
    SI opval = * FLD (i_st_src);
4486 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)), opval);
4487 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4488 
  }
4489 
 
4490 
  return vpc;
4491 
#undef FLD
4492 
}
4493 
 
4494 
/* st-indirect: st $st_src, ($abase) */
4495 
 
4496 
static SEM_PC
4497 
SEM_FN_NAME (i960base,st_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4498 
{
4499 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
4500 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4501 
  int UNUSED written = 0;
4502 
  IADDR UNUSED pc = abuf->addr;
4503 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4504 
 
4505 
  {
4506 
    SI opval = * FLD (i_st_src);
4507 
    SETMEMSI (current_cpu, pc, * FLD (i_abase), opval);
4508 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4509 
  }
4510 
 
4511 
  return vpc;
4512 
#undef FLD
4513 
}
4514 
 
4515 
/* st-indirect-index: st $st_src, ($abase)[$index*S$scale] */
4516 
 
4517 
static SEM_PC
4518 
SEM_FN_NAME (i960base,st_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4519 
{
4520 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4521 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4522 
  int UNUSED written = 0;
4523 
  IADDR UNUSED pc = abuf->addr;
4524 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4525 
 
4526 
  {
4527 
    SI opval = * FLD (i_st_src);
4528 
    SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4529 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4530 
  }
4531 
 
4532 
  return vpc;
4533 
#undef FLD
4534 
}
4535 
 
4536 
/* st-disp: st $st_src, $optdisp */
4537 
 
4538 
static SEM_PC
4539 
SEM_FN_NAME (i960base,st_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4540 
{
4541 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4542 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4543 
  int UNUSED written = 0;
4544 
  IADDR UNUSED pc = abuf->addr;
4545 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4546 
 
4547 
  {
4548 
    SI opval = * FLD (i_st_src);
4549 
    SETMEMSI (current_cpu, pc, FLD (f_optdisp), opval);
4550 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4551 
  }
4552 
 
4553 
  return vpc;
4554 
#undef FLD
4555 
}
4556 
 
4557 
/* st-indirect-disp: st $st_src, $optdisp($abase) */
4558 
 
4559 
static SEM_PC
4560 
SEM_FN_NAME (i960base,st_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4561 
{
4562 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4563 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4564 
  int UNUSED written = 0;
4565 
  IADDR UNUSED pc = abuf->addr;
4566 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4567 
 
4568 
  {
4569 
    SI opval = * FLD (i_st_src);
4570 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)), opval);
4571 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4572 
  }
4573 
 
4574 
  return vpc;
4575 
#undef FLD
4576 
}
4577 
 
4578 
/* st-index-disp: st $st_src, $optdisp[$index*S$scale */
4579 
 
4580 
static SEM_PC
4581 
SEM_FN_NAME (i960base,st_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4582 
{
4583 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4584 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4585 
  int UNUSED written = 0;
4586 
  IADDR UNUSED pc = abuf->addr;
4587 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4588 
 
4589 
  {
4590 
    SI opval = * FLD (i_st_src);
4591 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4592 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4593 
  }
4594 
 
4595 
  return vpc;
4596 
#undef FLD
4597 
}
4598 
 
4599 
/* st-indirect-index-disp: st $st_src, $optdisp($abase)[$index*S$scale] */
4600 
 
4601 
static SEM_PC
4602 
SEM_FN_NAME (i960base,st_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4603 
{
4604 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4605 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4606 
  int UNUSED written = 0;
4607 
  IADDR UNUSED pc = abuf->addr;
4608 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4609 
 
4610 
  {
4611 
    SI opval = * FLD (i_st_src);
4612 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), opval);
4613 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4614 
  }
4615 
 
4616 
  return vpc;
4617 
#undef FLD
4618 
}
4619 
 
4620 
/* stob-offset: stob $st_src, $offset */
4621 
 
4622 
static SEM_PC
4623 
SEM_FN_NAME (i960base,stob_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4624 
{
4625 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
4626 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4627 
  int UNUSED written = 0;
4628 
  IADDR UNUSED pc = abuf->addr;
4629 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4630 
 
4631 
  {
4632 
    QI opval = * FLD (i_st_src);
4633 
    SETMEMQI (current_cpu, pc, FLD (f_offset), opval);
4634 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4635 
  }
4636 
 
4637 
  return vpc;
4638 
#undef FLD
4639 
}
4640 
 
4641 
/* stob-indirect-offset: stob $st_src, $offset($abase) */
4642 
 
4643 
static SEM_PC
4644 
SEM_FN_NAME (i960base,stob_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4645 
{
4646 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
4647 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4648 
  int UNUSED written = 0;
4649 
  IADDR UNUSED pc = abuf->addr;
4650 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4651 
 
4652 
  {
4653 
    QI opval = * FLD (i_st_src);
4654 
    SETMEMQI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)), opval);
4655 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4656 
  }
4657 
 
4658 
  return vpc;
4659 
#undef FLD
4660 
}
4661 
 
4662 
/* stob-indirect: stob $st_src, ($abase) */
4663 
 
4664 
static SEM_PC
4665 
SEM_FN_NAME (i960base,stob_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4666 
{
4667 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
4668 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4669 
  int UNUSED written = 0;
4670 
  IADDR UNUSED pc = abuf->addr;
4671 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4672 
 
4673 
  {
4674 
    QI opval = * FLD (i_st_src);
4675 
    SETMEMQI (current_cpu, pc, * FLD (i_abase), opval);
4676 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4677 
  }
4678 
 
4679 
  return vpc;
4680 
#undef FLD
4681 
}
4682 
 
4683 
/* stob-indirect-index: stob $st_src, ($abase)[$index*S$scale] */
4684 
 
4685 
static SEM_PC
4686 
SEM_FN_NAME (i960base,stob_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4687 
{
4688 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4689 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4690 
  int UNUSED written = 0;
4691 
  IADDR UNUSED pc = abuf->addr;
4692 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4693 
 
4694 
  {
4695 
    QI opval = * FLD (i_st_src);
4696 
    SETMEMQI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4697 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4698 
  }
4699 
 
4700 
  return vpc;
4701 
#undef FLD
4702 
}
4703 
 
4704 
/* stob-disp: stob $st_src, $optdisp */
4705 
 
4706 
static SEM_PC
4707 
SEM_FN_NAME (i960base,stob_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4708 
{
4709 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4710 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4711 
  int UNUSED written = 0;
4712 
  IADDR UNUSED pc = abuf->addr;
4713 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4714 
 
4715 
  {
4716 
    QI opval = * FLD (i_st_src);
4717 
    SETMEMQI (current_cpu, pc, FLD (f_optdisp), opval);
4718 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4719 
  }
4720 
 
4721 
  return vpc;
4722 
#undef FLD
4723 
}
4724 
 
4725 
/* stob-indirect-disp: stob $st_src, $optdisp($abase) */
4726 
 
4727 
static SEM_PC
4728 
SEM_FN_NAME (i960base,stob_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4729 
{
4730 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4731 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4732 
  int UNUSED written = 0;
4733 
  IADDR UNUSED pc = abuf->addr;
4734 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4735 
 
4736 
  {
4737 
    QI opval = * FLD (i_st_src);
4738 
    SETMEMQI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)), opval);
4739 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4740 
  }
4741 
 
4742 
  return vpc;
4743 
#undef FLD
4744 
}
4745 
 
4746 
/* stob-index-disp: stob $st_src, $optdisp[$index*S$scale */
4747 
 
4748 
static SEM_PC
4749 
SEM_FN_NAME (i960base,stob_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4750 
{
4751 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4752 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4753 
  int UNUSED written = 0;
4754 
  IADDR UNUSED pc = abuf->addr;
4755 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4756 
 
4757 
  {
4758 
    QI opval = * FLD (i_st_src);
4759 
    SETMEMQI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4760 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4761 
  }
4762 
 
4763 
  return vpc;
4764 
#undef FLD
4765 
}
4766 
 
4767 
/* stob-indirect-index-disp: stob $st_src, $optdisp($abase)[$index*S$scale] */
4768 
 
4769 
static SEM_PC
4770 
SEM_FN_NAME (i960base,stob_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4771 
{
4772 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4773 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4774 
  int UNUSED written = 0;
4775 
  IADDR UNUSED pc = abuf->addr;
4776 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4777 
 
4778 
  {
4779 
    QI opval = * FLD (i_st_src);
4780 
    SETMEMQI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), opval);
4781 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4782 
  }
4783 
 
4784 
  return vpc;
4785 
#undef FLD
4786 
}
4787 
 
4788 
/* stos-offset: stos $st_src, $offset */
4789 
 
4790 
static SEM_PC
4791 
SEM_FN_NAME (i960base,stos_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4792 
{
4793 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
4794 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4795 
  int UNUSED written = 0;
4796 
  IADDR UNUSED pc = abuf->addr;
4797 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4798 
 
4799 
  {
4800 
    HI opval = * FLD (i_st_src);
4801 
    SETMEMHI (current_cpu, pc, FLD (f_offset), opval);
4802 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4803 
  }
4804 
 
4805 
  return vpc;
4806 
#undef FLD
4807 
}
4808 
 
4809 
/* stos-indirect-offset: stos $st_src, $offset($abase) */
4810 
 
4811 
static SEM_PC
4812 
SEM_FN_NAME (i960base,stos_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4813 
{
4814 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
4815 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4816 
  int UNUSED written = 0;
4817 
  IADDR UNUSED pc = abuf->addr;
4818 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4819 
 
4820 
  {
4821 
    HI opval = * FLD (i_st_src);
4822 
    SETMEMHI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)), opval);
4823 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4824 
  }
4825 
 
4826 
  return vpc;
4827 
#undef FLD
4828 
}
4829 
 
4830 
/* stos-indirect: stos $st_src, ($abase) */
4831 
 
4832 
static SEM_PC
4833 
SEM_FN_NAME (i960base,stos_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4834 
{
4835 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
4836 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4837 
  int UNUSED written = 0;
4838 
  IADDR UNUSED pc = abuf->addr;
4839 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4840 
 
4841 
  {
4842 
    HI opval = * FLD (i_st_src);
4843 
    SETMEMHI (current_cpu, pc, * FLD (i_abase), opval);
4844 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4845 
  }
4846 
 
4847 
  return vpc;
4848 
#undef FLD
4849 
}
4850 
 
4851 
/* stos-indirect-index: stos $st_src, ($abase)[$index*S$scale] */
4852 
 
4853 
static SEM_PC
4854 
SEM_FN_NAME (i960base,stos_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4855 
{
4856 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4857 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4858 
  int UNUSED written = 0;
4859 
  IADDR UNUSED pc = abuf->addr;
4860 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4861 
 
4862 
  {
4863 
    HI opval = * FLD (i_st_src);
4864 
    SETMEMHI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4865 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4866 
  }
4867 
 
4868 
  return vpc;
4869 
#undef FLD
4870 
}
4871 
 
4872 
/* stos-disp: stos $st_src, $optdisp */
4873 
 
4874 
static SEM_PC
4875 
SEM_FN_NAME (i960base,stos_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4876 
{
4877 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4878 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4879 
  int UNUSED written = 0;
4880 
  IADDR UNUSED pc = abuf->addr;
4881 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4882 
 
4883 
  {
4884 
    HI opval = * FLD (i_st_src);
4885 
    SETMEMHI (current_cpu, pc, FLD (f_optdisp), opval);
4886 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4887 
  }
4888 
 
4889 
  return vpc;
4890 
#undef FLD
4891 
}
4892 
 
4893 
/* stos-indirect-disp: stos $st_src, $optdisp($abase) */
4894 
 
4895 
static SEM_PC
4896 
SEM_FN_NAME (i960base,stos_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4897 
{
4898 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4899 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4900 
  int UNUSED written = 0;
4901 
  IADDR UNUSED pc = abuf->addr;
4902 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4903 
 
4904 
  {
4905 
    HI opval = * FLD (i_st_src);
4906 
    SETMEMHI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)), opval);
4907 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4908 
  }
4909 
 
4910 
  return vpc;
4911 
#undef FLD
4912 
}
4913 
 
4914 
/* stos-index-disp: stos $st_src, $optdisp[$index*S$scale */
4915 
 
4916 
static SEM_PC
4917 
SEM_FN_NAME (i960base,stos_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4918 
{
4919 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4920 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4921 
  int UNUSED written = 0;
4922 
  IADDR UNUSED pc = abuf->addr;
4923 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4924 
 
4925 
  {
4926 
    HI opval = * FLD (i_st_src);
4927 
    SETMEMHI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4928 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4929 
  }
4930 
 
4931 
  return vpc;
4932 
#undef FLD
4933 
}
4934 
 
4935 
/* stos-indirect-index-disp: stos $st_src, $optdisp($abase)[$index*S$scale] */
4936 
 
4937 
static SEM_PC
4938 
SEM_FN_NAME (i960base,stos_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4939 
{
4940 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
4941 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4942 
  int UNUSED written = 0;
4943 
  IADDR UNUSED pc = abuf->addr;
4944 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4945 
 
4946 
  {
4947 
    HI opval = * FLD (i_st_src);
4948 
    SETMEMHI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), opval);
4949 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4950 
  }
4951 
 
4952 
  return vpc;
4953 
#undef FLD
4954 
}
4955 
 
4956 
/* stl-offset: stl $st_src, $offset */
4957 
 
4958 
static SEM_PC
4959 
SEM_FN_NAME (i960base,stl_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4960 
{
4961 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
4962 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4963 
  int UNUSED written = 0;
4964 
  IADDR UNUSED pc = abuf->addr;
4965 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4966 
 
4967 
{
4968 
  SI tmp_sregno;
4969 
  tmp_sregno = FLD (f_srcdst);
4970 
  {
4971 
    SI opval = * FLD (i_st_src);
4972 
    SETMEMSI (current_cpu, pc, FLD (f_offset), opval);
4973 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4974 
  }
4975 
  {
4976 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
4977 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 4), opval);
4978 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4979 
  }
4980 
}
4981 
 
4982 
  return vpc;
4983 
#undef FLD
4984 
}
4985 
 
4986 
/* stl-indirect-offset: stl $st_src, $offset($abase) */
4987 
 
4988 
static SEM_PC
4989 
SEM_FN_NAME (i960base,stl_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4990 
{
4991 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
4992 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4993 
  int UNUSED written = 0;
4994 
  IADDR UNUSED pc = abuf->addr;
4995 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4996 
 
4997 
{
4998 
  SI tmp_sregno;
4999 
  tmp_sregno = FLD (f_srcdst);
5000 
  {
5001 
    SI opval = * FLD (i_st_src);
5002 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)), opval);
5003 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5004 
  }
5005 
  {
5006 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5007 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 4), opval);
5008 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5009 
  }
5010 
}
5011 
 
5012 
  return vpc;
5013 
#undef FLD
5014 
}
5015 
 
5016 
/* stl-indirect: stl $st_src, ($abase) */
5017 
 
5018 
static SEM_PC
5019 
SEM_FN_NAME (i960base,stl_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5020 
{
5021 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
5022 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5023 
  int UNUSED written = 0;
5024 
  IADDR UNUSED pc = abuf->addr;
5025 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5026 
 
5027 
{
5028 
  SI tmp_sregno;
5029 
  tmp_sregno = FLD (f_srcdst);
5030 
  {
5031 
    SI opval = * FLD (i_st_src);
5032 
    SETMEMSI (current_cpu, pc, * FLD (i_abase), opval);
5033 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5034 
  }
5035 
  {
5036 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5037 
    SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 4), opval);
5038 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5039 
  }
5040 
}
5041 
 
5042 
  return vpc;
5043 
#undef FLD
5044 
}
5045 
 
5046 
/* stl-indirect-index: stl $st_src, ($abase)[$index*S$scale] */
5047 
 
5048 
static SEM_PC
5049 
SEM_FN_NAME (i960base,stl_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5050 
{
5051 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5052 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5053 
  int UNUSED written = 0;
5054 
  IADDR UNUSED pc = abuf->addr;
5055 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5056 
 
5057 
{
5058 
  SI tmp_sregno;
5059 
  tmp_sregno = FLD (f_srcdst);
5060 
  {
5061 
    SI opval = * FLD (i_st_src);
5062 
    SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
5063 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5064 
  }
5065 
  {
5066 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5067 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
5068 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5069 
  }
5070 
}
5071 
 
5072 
  return vpc;
5073 
#undef FLD
5074 
}
5075 
 
5076 
/* stl-disp: stl $st_src, $optdisp */
5077 
 
5078 
static SEM_PC
5079 
SEM_FN_NAME (i960base,stl_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5080 
{
5081 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5082 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5083 
  int UNUSED written = 0;
5084 
  IADDR UNUSED pc = abuf->addr;
5085 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5086 
 
5087 
{
5088 
  SI tmp_sregno;
5089 
  tmp_sregno = FLD (f_srcdst);
5090 
  {
5091 
    SI opval = * FLD (i_st_src);
5092 
    SETMEMSI (current_cpu, pc, FLD (f_optdisp), opval);
5093 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5094 
  }
5095 
  {
5096 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5097 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 4), opval);
5098 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5099 
  }
5100 
}
5101 
 
5102 
  return vpc;
5103 
#undef FLD
5104 
}
5105 
 
5106 
/* stl-indirect-disp: stl $st_src, $optdisp($abase) */
5107 
 
5108 
static SEM_PC
5109 
SEM_FN_NAME (i960base,stl_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5110 
{
5111 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5112 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5113 
  int UNUSED written = 0;
5114 
  IADDR UNUSED pc = abuf->addr;
5115 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5116 
 
5117 
{
5118 
  SI tmp_sregno;
5119 
  tmp_sregno = FLD (f_srcdst);
5120 
  {
5121 
    SI opval = * FLD (i_st_src);
5122 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)), opval);
5123 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5124 
  }
5125 
  {
5126 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5127 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 4), opval);
5128 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5129 
  }
5130 
}
5131 
 
5132 
  return vpc;
5133 
#undef FLD
5134 
}
5135 
 
5136 
/* stl-index-disp: stl $st_src, $optdisp[$index*S$scale */
5137 
 
5138 
static SEM_PC
5139 
SEM_FN_NAME (i960base,stl_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5140 
{
5141 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5142 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5143 
  int UNUSED written = 0;
5144 
  IADDR UNUSED pc = abuf->addr;
5145 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5146 
 
5147 
{
5148 
  SI tmp_sregno;
5149 
  tmp_sregno = FLD (f_srcdst);
5150 
  {
5151 
    SI opval = * FLD (i_st_src);
5152 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
5153 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5154 
  }
5155 
  {
5156 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5157 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
5158 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5159 
  }
5160 
}
5161 
 
5162 
  return vpc;
5163 
#undef FLD
5164 
}
5165 
 
5166 
/* stl-indirect-index-disp: stl $st_src, $optdisp($abase)[$index*S$scale] */
5167 
 
5168 
static SEM_PC
5169 
SEM_FN_NAME (i960base,stl_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5170 
{
5171 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5172 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5173 
  int UNUSED written = 0;
5174 
  IADDR UNUSED pc = abuf->addr;
5175 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5176 
 
5177 
{
5178 
  SI tmp_sregno;
5179 
  tmp_sregno = FLD (f_srcdst);
5180 
  {
5181 
    SI opval = * FLD (i_st_src);
5182 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), opval);
5183 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5184 
  }
5185 
  {
5186 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5187 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 4), opval);
5188 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5189 
  }
5190 
}
5191 
 
5192 
  return vpc;
5193 
#undef FLD
5194 
}
5195 
 
5196 
/* stt-offset: stt $st_src, $offset */
5197 
 
5198 
static SEM_PC
5199 
SEM_FN_NAME (i960base,stt_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5200 
{
5201 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
5202 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5203 
  int UNUSED written = 0;
5204 
  IADDR UNUSED pc = abuf->addr;
5205 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5206 
 
5207 
{
5208 
  SI tmp_sregno;
5209 
  tmp_sregno = FLD (f_srcdst);
5210 
  {
5211 
    SI opval = * FLD (i_st_src);
5212 
    SETMEMSI (current_cpu, pc, FLD (f_offset), opval);
5213 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5214 
  }
5215 
  {
5216 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5217 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 4), opval);
5218 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5219 
  }
5220 
  {
5221 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5222 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 8), opval);
5223 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5224 
  }
5225 
}
5226 
 
5227 
  return vpc;
5228 
#undef FLD
5229 
}
5230 
 
5231 
/* stt-indirect-offset: stt $st_src, $offset($abase) */
5232 
 
5233 
static SEM_PC
5234 
SEM_FN_NAME (i960base,stt_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5235 
{
5236 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
5237 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5238 
  int UNUSED written = 0;
5239 
  IADDR UNUSED pc = abuf->addr;
5240 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5241 
 
5242 
{
5243 
  SI tmp_sregno;
5244 
  tmp_sregno = FLD (f_srcdst);
5245 
  {
5246 
    SI opval = * FLD (i_st_src);
5247 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)), opval);
5248 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5249 
  }
5250 
  {
5251 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5252 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 4), opval);
5253 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5254 
  }
5255 
  {
5256 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5257 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 8), opval);
5258 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5259 
  }
5260 
}
5261 
 
5262 
  return vpc;
5263 
#undef FLD
5264 
}
5265 
 
5266 
/* stt-indirect: stt $st_src, ($abase) */
5267 
 
5268 
static SEM_PC
5269 
SEM_FN_NAME (i960base,stt_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5270 
{
5271 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
5272 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5273 
  int UNUSED written = 0;
5274 
  IADDR UNUSED pc = abuf->addr;
5275 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5276 
 
5277 
{
5278 
  SI tmp_sregno;
5279 
  tmp_sregno = FLD (f_srcdst);
5280 
  {
5281 
    SI opval = * FLD (i_st_src);
5282 
    SETMEMSI (current_cpu, pc, * FLD (i_abase), opval);
5283 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5284 
  }
5285 
  {
5286 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5287 
    SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 4), opval);
5288 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5289 
  }
5290 
  {
5291 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5292 
    SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 8), opval);
5293 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5294 
  }
5295 
}
5296 
 
5297 
  return vpc;
5298 
#undef FLD
5299 
}
5300 
 
5301 
/* stt-indirect-index: stt $st_src, ($abase)[$index*S$scale] */
5302 
 
5303 
static SEM_PC
5304 
SEM_FN_NAME (i960base,stt_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5305 
{
5306 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5307 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5308 
  int UNUSED written = 0;
5309 
  IADDR UNUSED pc = abuf->addr;
5310 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5311 
 
5312 
{
5313 
  SI tmp_sregno;
5314 
  tmp_sregno = FLD (f_srcdst);
5315 
  {
5316 
    SI opval = * FLD (i_st_src);
5317 
    SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
5318 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5319 
  }
5320 
  {
5321 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5322 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
5323 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5324 
  }
5325 
  {
5326 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5327 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 8), opval);
5328 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5329 
  }
5330 
}
5331 
 
5332 
  return vpc;
5333 
#undef FLD
5334 
}
5335 
 
5336 
/* stt-disp: stt $st_src, $optdisp */
5337 
 
5338 
static SEM_PC
5339 
SEM_FN_NAME (i960base,stt_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5340 
{
5341 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5342 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5343 
  int UNUSED written = 0;
5344 
  IADDR UNUSED pc = abuf->addr;
5345 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5346 
 
5347 
{
5348 
  SI tmp_sregno;
5349 
  tmp_sregno = FLD (f_srcdst);
5350 
  {
5351 
    SI opval = * FLD (i_st_src);
5352 
    SETMEMSI (current_cpu, pc, FLD (f_optdisp), opval);
5353 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5354 
  }
5355 
  {
5356 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5357 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 4), opval);
5358 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5359 
  }
5360 
  {
5361 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5362 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 8), opval);
5363 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5364 
  }
5365 
}
5366 
 
5367 
  return vpc;
5368 
#undef FLD
5369 
}
5370 
 
5371 
/* stt-indirect-disp: stt $st_src, $optdisp($abase) */
5372 
 
5373 
static SEM_PC
5374 
SEM_FN_NAME (i960base,stt_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5375 
{
5376 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5377 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5378 
  int UNUSED written = 0;
5379 
  IADDR UNUSED pc = abuf->addr;
5380 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5381 
 
5382 
{
5383 
  SI tmp_sregno;
5384 
  tmp_sregno = FLD (f_srcdst);
5385 
  {
5386 
    SI opval = * FLD (i_st_src);
5387 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)), opval);
5388 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5389 
  }
5390 
  {
5391 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5392 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 4), opval);
5393 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5394 
  }
5395 
  {
5396 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5397 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 8), opval);
5398 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5399 
  }
5400 
}
5401 
 
5402 
  return vpc;
5403 
#undef FLD
5404 
}
5405 
 
5406 
/* stt-index-disp: stt $st_src, $optdisp[$index*S$scale */
5407 
 
5408 
static SEM_PC
5409 
SEM_FN_NAME (i960base,stt_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5410 
{
5411 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5412 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5413 
  int UNUSED written = 0;
5414 
  IADDR UNUSED pc = abuf->addr;
5415 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5416 
 
5417 
{
5418 
  SI tmp_sregno;
5419 
  tmp_sregno = FLD (f_srcdst);
5420 
  {
5421 
    SI opval = * FLD (i_st_src);
5422 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
5423 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5424 
  }
5425 
  {
5426 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5427 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
5428 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5429 
  }
5430 
  {
5431 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5432 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 8), opval);
5433 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5434 
  }
5435 
}
5436 
 
5437 
  return vpc;
5438 
#undef FLD
5439 
}
5440 
 
5441 
/* stt-indirect-index-disp: stt $st_src, $optdisp($abase)[$index*S$scale] */
5442 
 
5443 
static SEM_PC
5444 
SEM_FN_NAME (i960base,stt_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5445 
{
5446 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5447 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5448 
  int UNUSED written = 0;
5449 
  IADDR UNUSED pc = abuf->addr;
5450 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5451 
 
5452 
{
5453 
  SI tmp_sregno;
5454 
  tmp_sregno = FLD (f_srcdst);
5455 
  {
5456 
    SI opval = * FLD (i_st_src);
5457 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), opval);
5458 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5459 
  }
5460 
  {
5461 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5462 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 4), opval);
5463 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5464 
  }
5465 
  {
5466 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5467 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 8), opval);
5468 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5469 
  }
5470 
}
5471 
 
5472 
  return vpc;
5473 
#undef FLD
5474 
}
5475 
 
5476 
/* stq-offset: stq $st_src, $offset */
5477 
 
5478 
static SEM_PC
5479 
SEM_FN_NAME (i960base,stq_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5480 
{
5481 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
5482 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5483 
  int UNUSED written = 0;
5484 
  IADDR UNUSED pc = abuf->addr;
5485 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5486 
 
5487 
{
5488 
  SI tmp_sregno;
5489 
  tmp_sregno = FLD (f_srcdst);
5490 
  {
5491 
    SI opval = * FLD (i_st_src);
5492 
    SETMEMSI (current_cpu, pc, FLD (f_offset), opval);
5493 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5494 
  }
5495 
  {
5496 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5497 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 4), opval);
5498 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5499 
  }
5500 
  {
5501 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5502 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 8), opval);
5503 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5504 
  }
5505 
  {
5506 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5507 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 12), opval);
5508 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5509 
  }
5510 
}
5511 
 
5512 
  return vpc;
5513 
#undef FLD
5514 
}
5515 
 
5516 
/* stq-indirect-offset: stq $st_src, $offset($abase) */
5517 
 
5518 
static SEM_PC
5519 
SEM_FN_NAME (i960base,stq_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5520 
{
5521 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
5522 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5523 
  int UNUSED written = 0;
5524 
  IADDR UNUSED pc = abuf->addr;
5525 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5526 
 
5527 
{
5528 
  SI tmp_sregno;
5529 
  tmp_sregno = FLD (f_srcdst);
5530 
  {
5531 
    SI opval = * FLD (i_st_src);
5532 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)), opval);
5533 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5534 
  }
5535 
  {
5536 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5537 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 4), opval);
5538 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5539 
  }
5540 
  {
5541 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5542 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 8), opval);
5543 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5544 
  }
5545 
  {
5546 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5547 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 12), opval);
5548 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5549 
  }
5550 
}
5551 
 
5552 
  return vpc;
5553 
#undef FLD
5554 
}
5555 
 
5556 
/* stq-indirect: stq $st_src, ($abase) */
5557 
 
5558 
static SEM_PC
5559 
SEM_FN_NAME (i960base,stq_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5560 
{
5561 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
5562 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5563 
  int UNUSED written = 0;
5564 
  IADDR UNUSED pc = abuf->addr;
5565 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5566 
 
5567 
{
5568 
  SI tmp_sregno;
5569 
  tmp_sregno = FLD (f_srcdst);
5570 
  {
5571 
    SI opval = * FLD (i_st_src);
5572 
    SETMEMSI (current_cpu, pc, * FLD (i_abase), opval);
5573 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5574 
  }
5575 
  {
5576 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5577 
    SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 4), opval);
5578 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5579 
  }
5580 
  {
5581 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5582 
    SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 8), opval);
5583 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5584 
  }
5585 
  {
5586 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5587 
    SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 12), opval);
5588 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5589 
  }
5590 
}
5591 
 
5592 
  return vpc;
5593 
#undef FLD
5594 
}
5595 
 
5596 
/* stq-indirect-index: stq $st_src, ($abase)[$index*S$scale] */
5597 
 
5598 
static SEM_PC
5599 
SEM_FN_NAME (i960base,stq_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5600 
{
5601 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5602 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5603 
  int UNUSED written = 0;
5604 
  IADDR UNUSED pc = abuf->addr;
5605 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5606 
 
5607 
{
5608 
  SI tmp_sregno;
5609 
  tmp_sregno = FLD (f_srcdst);
5610 
  {
5611 
    SI opval = * FLD (i_st_src);
5612 
    SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
5613 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5614 
  }
5615 
  {
5616 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5617 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
5618 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5619 
  }
5620 
  {
5621 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5622 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 8), opval);
5623 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5624 
  }
5625 
  {
5626 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5627 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 12), opval);
5628 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5629 
  }
5630 
}
5631 
 
5632 
  return vpc;
5633 
#undef FLD
5634 
}
5635 
 
5636 
/* stq-disp: stq $st_src, $optdisp */
5637 
 
5638 
static SEM_PC
5639 
SEM_FN_NAME (i960base,stq_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5640 
{
5641 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5642 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5643 
  int UNUSED written = 0;
5644 
  IADDR UNUSED pc = abuf->addr;
5645 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5646 
 
5647 
{
5648 
  SI tmp_sregno;
5649 
  tmp_sregno = FLD (f_srcdst);
5650 
  {
5651 
    SI opval = * FLD (i_st_src);
5652 
    SETMEMSI (current_cpu, pc, FLD (f_optdisp), opval);
5653 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5654 
  }
5655 
  {
5656 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5657 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 4), opval);
5658 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5659 
  }
5660 
  {
5661 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5662 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 8), opval);
5663 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5664 
  }
5665 
  {
5666 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5667 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 12), opval);
5668 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5669 
  }
5670 
}
5671 
 
5672 
  return vpc;
5673 
#undef FLD
5674 
}
5675 
 
5676 
/* stq-indirect-disp: stq $st_src, $optdisp($abase) */
5677 
 
5678 
static SEM_PC
5679 
SEM_FN_NAME (i960base,stq_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5680 
{
5681 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5682 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5683 
  int UNUSED written = 0;
5684 
  IADDR UNUSED pc = abuf->addr;
5685 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5686 
 
5687 
{
5688 
  SI tmp_sregno;
5689 
  tmp_sregno = FLD (f_srcdst);
5690 
  {
5691 
    SI opval = * FLD (i_st_src);
5692 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)), opval);
5693 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5694 
  }
5695 
  {
5696 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5697 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 4), opval);
5698 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5699 
  }
5700 
  {
5701 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5702 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 8), opval);
5703 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5704 
  }
5705 
  {
5706 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5707 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 12), opval);
5708 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5709 
  }
5710 
}
5711 
 
5712 
  return vpc;
5713 
#undef FLD
5714 
}
5715 
 
5716 
/* stq-index-disp: stq $st_src, $optdisp[$index*S$scale */
5717 
 
5718 
static SEM_PC
5719 
SEM_FN_NAME (i960base,stq_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5720 
{
5721 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5722 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5723 
  int UNUSED written = 0;
5724 
  IADDR UNUSED pc = abuf->addr;
5725 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5726 
 
5727 
{
5728 
  SI tmp_sregno;
5729 
  tmp_sregno = FLD (f_srcdst);
5730 
  {
5731 
    SI opval = * FLD (i_st_src);
5732 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
5733 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5734 
  }
5735 
  {
5736 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5737 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
5738 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5739 
  }
5740 
  {
5741 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5742 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 8), opval);
5743 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5744 
  }
5745 
  {
5746 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5747 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 12), opval);
5748 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5749 
  }
5750 
}
5751 
 
5752 
  return vpc;
5753 
#undef FLD
5754 
}
5755 
 
5756 
/* stq-indirect-index-disp: stq $st_src, $optdisp($abase)[$index*S$scale] */
5757 
 
5758 
static SEM_PC
5759 
SEM_FN_NAME (i960base,stq_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5760 
{
5761 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
5762 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5763 
  int UNUSED written = 0;
5764 
  IADDR UNUSED pc = abuf->addr;
5765 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5766 
 
5767 
{
5768 
  SI tmp_sregno;
5769 
  tmp_sregno = FLD (f_srcdst);
5770 
  {
5771 
    SI opval = * FLD (i_st_src);
5772 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), opval);
5773 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5774 
  }
5775 
  {
5776 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5777 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 4), opval);
5778 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5779 
  }
5780 
  {
5781 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5782 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 8), opval);
5783 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5784 
  }
5785 
  {
5786 
    SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5787 
    SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 12), opval);
5788 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5789 
  }
5790 
}
5791 
 
5792 
  return vpc;
5793 
#undef FLD
5794 
}
5795 
 
5796 
/* cmpobe-reg: cmpobe $br_src1, $br_src2, $br_disp */
5797 
 
5798 
static SEM_PC
5799 
SEM_FN_NAME (i960base,cmpobe_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5800 
{
5801 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
5802 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5803 
  int UNUSED written = 0;
5804 
  IADDR UNUSED pc = abuf->addr;
5805 
  SEM_BRANCH_INIT
5806 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5807 
 
5808 
if (EQSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5809 
  {
5810 
    USI opval = FLD (i_br_disp);
5811 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
5812 
    written |= (1 << 3);
5813 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5814 
  }
5815 
}
5816 
 
5817 
  abuf->written = written;
5818 
  SEM_BRANCH_FINI (vpc);
5819 
  return vpc;
5820 
#undef FLD
5821 
}
5822 
 
5823 
/* cmpobe-lit: cmpobe $br_lit1, $br_src2, $br_disp */
5824 
 
5825 
static SEM_PC
5826 
SEM_FN_NAME (i960base,cmpobe_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5827 
{
5828 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
5829 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5830 
  int UNUSED written = 0;
5831 
  IADDR UNUSED pc = abuf->addr;
5832 
  SEM_BRANCH_INIT
5833 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5834 
 
5835 
if (EQSI (FLD (f_br_src1), * FLD (i_br_src2))) {
5836 
  {
5837 
    USI opval = FLD (i_br_disp);
5838 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
5839 
    written |= (1 << 3);
5840 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5841 
  }
5842 
}
5843 
 
5844 
  abuf->written = written;
5845 
  SEM_BRANCH_FINI (vpc);
5846 
  return vpc;
5847 
#undef FLD
5848 
}
5849 
 
5850 
/* cmpobne-reg: cmpobne $br_src1, $br_src2, $br_disp */
5851 
 
5852 
static SEM_PC
5853 
SEM_FN_NAME (i960base,cmpobne_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5854 
{
5855 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
5856 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5857 
  int UNUSED written = 0;
5858 
  IADDR UNUSED pc = abuf->addr;
5859 
  SEM_BRANCH_INIT
5860 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5861 
 
5862 
if (NESI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5863 
  {
5864 
    USI opval = FLD (i_br_disp);
5865 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
5866 
    written |= (1 << 3);
5867 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5868 
  }
5869 
}
5870 
 
5871 
  abuf->written = written;
5872 
  SEM_BRANCH_FINI (vpc);
5873 
  return vpc;
5874 
#undef FLD
5875 
}
5876 
 
5877 
/* cmpobne-lit: cmpobne $br_lit1, $br_src2, $br_disp */
5878 
 
5879 
static SEM_PC
5880 
SEM_FN_NAME (i960base,cmpobne_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5881 
{
5882 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
5883 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5884 
  int UNUSED written = 0;
5885 
  IADDR UNUSED pc = abuf->addr;
5886 
  SEM_BRANCH_INIT
5887 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5888 
 
5889 
if (NESI (FLD (f_br_src1), * FLD (i_br_src2))) {
5890 
  {
5891 
    USI opval = FLD (i_br_disp);
5892 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
5893 
    written |= (1 << 3);
5894 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5895 
  }
5896 
}
5897 
 
5898 
  abuf->written = written;
5899 
  SEM_BRANCH_FINI (vpc);
5900 
  return vpc;
5901 
#undef FLD
5902 
}
5903 
 
5904 
/* cmpobl-reg: cmpobl $br_src1, $br_src2, $br_disp */
5905 
 
5906 
static SEM_PC
5907 
SEM_FN_NAME (i960base,cmpobl_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5908 
{
5909 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
5910 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5911 
  int UNUSED written = 0;
5912 
  IADDR UNUSED pc = abuf->addr;
5913 
  SEM_BRANCH_INIT
5914 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5915 
 
5916 
if (LTUSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5917 
  {
5918 
    USI opval = FLD (i_br_disp);
5919 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
5920 
    written |= (1 << 3);
5921 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5922 
  }
5923 
}
5924 
 
5925 
  abuf->written = written;
5926 
  SEM_BRANCH_FINI (vpc);
5927 
  return vpc;
5928 
#undef FLD
5929 
}
5930 
 
5931 
/* cmpobl-lit: cmpobl $br_lit1, $br_src2, $br_disp */
5932 
 
5933 
static SEM_PC
5934 
SEM_FN_NAME (i960base,cmpobl_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5935 
{
5936 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
5937 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5938 
  int UNUSED written = 0;
5939 
  IADDR UNUSED pc = abuf->addr;
5940 
  SEM_BRANCH_INIT
5941 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5942 
 
5943 
if (LTUSI (FLD (f_br_src1), * FLD (i_br_src2))) {
5944 
  {
5945 
    USI opval = FLD (i_br_disp);
5946 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
5947 
    written |= (1 << 3);
5948 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5949 
  }
5950 
}
5951 
 
5952 
  abuf->written = written;
5953 
  SEM_BRANCH_FINI (vpc);
5954 
  return vpc;
5955 
#undef FLD
5956 
}
5957 
 
5958 
/* cmpoble-reg: cmpoble $br_src1, $br_src2, $br_disp */
5959 
 
5960 
static SEM_PC
5961 
SEM_FN_NAME (i960base,cmpoble_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5962 
{
5963 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
5964 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5965 
  int UNUSED written = 0;
5966 
  IADDR UNUSED pc = abuf->addr;
5967 
  SEM_BRANCH_INIT
5968 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5969 
 
5970 
if (LEUSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5971 
  {
5972 
    USI opval = FLD (i_br_disp);
5973 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
5974 
    written |= (1 << 3);
5975 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5976 
  }
5977 
}
5978 
 
5979 
  abuf->written = written;
5980 
  SEM_BRANCH_FINI (vpc);
5981 
  return vpc;
5982 
#undef FLD
5983 
}
5984 
 
5985 
/* cmpoble-lit: cmpoble $br_lit1, $br_src2, $br_disp */
5986 
 
5987 
static SEM_PC
5988 
SEM_FN_NAME (i960base,cmpoble_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5989 
{
5990 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
5991 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5992 
  int UNUSED written = 0;
5993 
  IADDR UNUSED pc = abuf->addr;
5994 
  SEM_BRANCH_INIT
5995 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5996 
 
5997 
if (LEUSI (FLD (f_br_src1), * FLD (i_br_src2))) {
5998 
  {
5999 
    USI opval = FLD (i_br_disp);
6000 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6001 
    written |= (1 << 3);
6002 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6003 
  }
6004 
}
6005 
 
6006 
  abuf->written = written;
6007 
  SEM_BRANCH_FINI (vpc);
6008 
  return vpc;
6009 
#undef FLD
6010 
}
6011 
 
6012 
/* cmpobg-reg: cmpobg $br_src1, $br_src2, $br_disp */
6013 
 
6014 
static SEM_PC
6015 
SEM_FN_NAME (i960base,cmpobg_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6016 
{
6017 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
6018 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6019 
  int UNUSED written = 0;
6020 
  IADDR UNUSED pc = abuf->addr;
6021 
  SEM_BRANCH_INIT
6022 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6023 
 
6024 
if (GTUSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
6025 
  {
6026 
    USI opval = FLD (i_br_disp);
6027 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6028 
    written |= (1 << 3);
6029 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6030 
  }
6031 
}
6032 
 
6033 
  abuf->written = written;
6034 
  SEM_BRANCH_FINI (vpc);
6035 
  return vpc;
6036 
#undef FLD
6037 
}
6038 
 
6039 
/* cmpobg-lit: cmpobg $br_lit1, $br_src2, $br_disp */
6040 
 
6041 
static SEM_PC
6042 
SEM_FN_NAME (i960base,cmpobg_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6043 
{
6044 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
6045 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6046 
  int UNUSED written = 0;
6047 
  IADDR UNUSED pc = abuf->addr;
6048 
  SEM_BRANCH_INIT
6049 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6050 
 
6051 
if (GTUSI (FLD (f_br_src1), * FLD (i_br_src2))) {
6052 
  {
6053 
    USI opval = FLD (i_br_disp);
6054 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6055 
    written |= (1 << 3);
6056 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6057 
  }
6058 
}
6059 
 
6060 
  abuf->written = written;
6061 
  SEM_BRANCH_FINI (vpc);
6062 
  return vpc;
6063 
#undef FLD
6064 
}
6065 
 
6066 
/* cmpobge-reg: cmpobge $br_src1, $br_src2, $br_disp */
6067 
 
6068 
static SEM_PC
6069 
SEM_FN_NAME (i960base,cmpobge_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6070 
{
6071 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
6072 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6073 
  int UNUSED written = 0;
6074 
  IADDR UNUSED pc = abuf->addr;
6075 
  SEM_BRANCH_INIT
6076 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6077 
 
6078 
if (GEUSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
6079 
  {
6080 
    USI opval = FLD (i_br_disp);
6081 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6082 
    written |= (1 << 3);
6083 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6084 
  }
6085 
}
6086 
 
6087 
  abuf->written = written;
6088 
  SEM_BRANCH_FINI (vpc);
6089 
  return vpc;
6090 
#undef FLD
6091 
}
6092 
 
6093 
/* cmpobge-lit: cmpobge $br_lit1, $br_src2, $br_disp */
6094 
 
6095 
static SEM_PC
6096 
SEM_FN_NAME (i960base,cmpobge_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6097 
{
6098 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
6099 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6100 
  int UNUSED written = 0;
6101 
  IADDR UNUSED pc = abuf->addr;
6102 
  SEM_BRANCH_INIT
6103 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6104 
 
6105 
if (GEUSI (FLD (f_br_src1), * FLD (i_br_src2))) {
6106 
  {
6107 
    USI opval = FLD (i_br_disp);
6108 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6109 
    written |= (1 << 3);
6110 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6111 
  }
6112 
}
6113 
 
6114 
  abuf->written = written;
6115 
  SEM_BRANCH_FINI (vpc);
6116 
  return vpc;
6117 
#undef FLD
6118 
}
6119 
 
6120 
/* cmpibe-reg: cmpibe $br_src1, $br_src2, $br_disp */
6121 
 
6122 
static SEM_PC
6123 
SEM_FN_NAME (i960base,cmpibe_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6124 
{
6125 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
6126 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6127 
  int UNUSED written = 0;
6128 
  IADDR UNUSED pc = abuf->addr;
6129 
  SEM_BRANCH_INIT
6130 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6131 
 
6132 
if (EQSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
6133 
  {
6134 
    USI opval = FLD (i_br_disp);
6135 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6136 
    written |= (1 << 3);
6137 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6138 
  }
6139 
}
6140 
 
6141 
  abuf->written = written;
6142 
  SEM_BRANCH_FINI (vpc);
6143 
  return vpc;
6144 
#undef FLD
6145 
}
6146 
 
6147 
/* cmpibe-lit: cmpibe $br_lit1, $br_src2, $br_disp */
6148 
 
6149 
static SEM_PC
6150 
SEM_FN_NAME (i960base,cmpibe_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6151 
{
6152 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
6153 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6154 
  int UNUSED written = 0;
6155 
  IADDR UNUSED pc = abuf->addr;
6156 
  SEM_BRANCH_INIT
6157 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6158 
 
6159 
if (EQSI (FLD (f_br_src1), * FLD (i_br_src2))) {
6160 
  {
6161 
    USI opval = FLD (i_br_disp);
6162 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6163 
    written |= (1 << 3);
6164 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6165 
  }
6166 
}
6167 
 
6168 
  abuf->written = written;
6169 
  SEM_BRANCH_FINI (vpc);
6170 
  return vpc;
6171 
#undef FLD
6172 
}
6173 
 
6174 
/* cmpibne-reg: cmpibne $br_src1, $br_src2, $br_disp */
6175 
 
6176 
static SEM_PC
6177 
SEM_FN_NAME (i960base,cmpibne_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6178 
{
6179 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
6180 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6181 
  int UNUSED written = 0;
6182 
  IADDR UNUSED pc = abuf->addr;
6183 
  SEM_BRANCH_INIT
6184 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6185 
 
6186 
if (NESI (* FLD (i_br_src1), * FLD (i_br_src2))) {
6187 
  {
6188 
    USI opval = FLD (i_br_disp);
6189 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6190 
    written |= (1 << 3);
6191 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6192 
  }
6193 
}
6194 
 
6195 
  abuf->written = written;
6196 
  SEM_BRANCH_FINI (vpc);
6197 
  return vpc;
6198 
#undef FLD
6199 
}
6200 
 
6201 
/* cmpibne-lit: cmpibne $br_lit1, $br_src2, $br_disp */
6202 
 
6203 
static SEM_PC
6204 
SEM_FN_NAME (i960base,cmpibne_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6205 
{
6206 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
6207 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6208 
  int UNUSED written = 0;
6209 
  IADDR UNUSED pc = abuf->addr;
6210 
  SEM_BRANCH_INIT
6211 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6212 
 
6213 
if (NESI (FLD (f_br_src1), * FLD (i_br_src2))) {
6214 
  {
6215 
    USI opval = FLD (i_br_disp);
6216 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6217 
    written |= (1 << 3);
6218 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6219 
  }
6220 
}
6221 
 
6222 
  abuf->written = written;
6223 
  SEM_BRANCH_FINI (vpc);
6224 
  return vpc;
6225 
#undef FLD
6226 
}
6227 
 
6228 
/* cmpibl-reg: cmpibl $br_src1, $br_src2, $br_disp */
6229 
 
6230 
static SEM_PC
6231 
SEM_FN_NAME (i960base,cmpibl_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6232 
{
6233 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
6234 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6235 
  int UNUSED written = 0;
6236 
  IADDR UNUSED pc = abuf->addr;
6237 
  SEM_BRANCH_INIT
6238 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6239 
 
6240 
if (LTSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
6241 
  {
6242 
    USI opval = FLD (i_br_disp);
6243 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6244 
    written |= (1 << 3);
6245 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6246 
  }
6247 
}
6248 
 
6249 
  abuf->written = written;
6250 
  SEM_BRANCH_FINI (vpc);
6251 
  return vpc;
6252 
#undef FLD
6253 
}
6254 
 
6255 
/* cmpibl-lit: cmpibl $br_lit1, $br_src2, $br_disp */
6256 
 
6257 
static SEM_PC
6258 
SEM_FN_NAME (i960base,cmpibl_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6259 
{
6260 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
6261 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6262 
  int UNUSED written = 0;
6263 
  IADDR UNUSED pc = abuf->addr;
6264 
  SEM_BRANCH_INIT
6265 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6266 
 
6267 
if (LTSI (FLD (f_br_src1), * FLD (i_br_src2))) {
6268 
  {
6269 
    USI opval = FLD (i_br_disp);
6270 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6271 
    written |= (1 << 3);
6272 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6273 
  }
6274 
}
6275 
 
6276 
  abuf->written = written;
6277 
  SEM_BRANCH_FINI (vpc);
6278 
  return vpc;
6279 
#undef FLD
6280 
}
6281 
 
6282 
/* cmpible-reg: cmpible $br_src1, $br_src2, $br_disp */
6283 
 
6284 
static SEM_PC
6285 
SEM_FN_NAME (i960base,cmpible_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6286 
{
6287 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
6288 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6289 
  int UNUSED written = 0;
6290 
  IADDR UNUSED pc = abuf->addr;
6291 
  SEM_BRANCH_INIT
6292 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6293 
 
6294 
if (LESI (* FLD (i_br_src1), * FLD (i_br_src2))) {
6295 
  {
6296 
    USI opval = FLD (i_br_disp);
6297 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6298 
    written |= (1 << 3);
6299 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6300 
  }
6301 
}
6302 
 
6303 
  abuf->written = written;
6304 
  SEM_BRANCH_FINI (vpc);
6305 
  return vpc;
6306 
#undef FLD
6307 
}
6308 
 
6309 
/* cmpible-lit: cmpible $br_lit1, $br_src2, $br_disp */
6310 
 
6311 
static SEM_PC
6312 
SEM_FN_NAME (i960base,cmpible_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6313 
{
6314 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
6315 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6316 
  int UNUSED written = 0;
6317 
  IADDR UNUSED pc = abuf->addr;
6318 
  SEM_BRANCH_INIT
6319 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6320 
 
6321 
if (LESI (FLD (f_br_src1), * FLD (i_br_src2))) {
6322 
  {
6323 
    USI opval = FLD (i_br_disp);
6324 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6325 
    written |= (1 << 3);
6326 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6327 
  }
6328 
}
6329 
 
6330 
  abuf->written = written;
6331 
  SEM_BRANCH_FINI (vpc);
6332 
  return vpc;
6333 
#undef FLD
6334 
}
6335 
 
6336 
/* cmpibg-reg: cmpibg $br_src1, $br_src2, $br_disp */
6337 
 
6338 
static SEM_PC
6339 
SEM_FN_NAME (i960base,cmpibg_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6340 
{
6341 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
6342 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6343 
  int UNUSED written = 0;
6344 
  IADDR UNUSED pc = abuf->addr;
6345 
  SEM_BRANCH_INIT
6346 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6347 
 
6348 
if (GTSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
6349 
  {
6350 
    USI opval = FLD (i_br_disp);
6351 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6352 
    written |= (1 << 3);
6353 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6354 
  }
6355 
}
6356 
 
6357 
  abuf->written = written;
6358 
  SEM_BRANCH_FINI (vpc);
6359 
  return vpc;
6360 
#undef FLD
6361 
}
6362 
 
6363 
/* cmpibg-lit: cmpibg $br_lit1, $br_src2, $br_disp */
6364 
 
6365 
static SEM_PC
6366 
SEM_FN_NAME (i960base,cmpibg_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6367 
{
6368 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
6369 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6370 
  int UNUSED written = 0;
6371 
  IADDR UNUSED pc = abuf->addr;
6372 
  SEM_BRANCH_INIT
6373 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6374 
 
6375 
if (GTSI (FLD (f_br_src1), * FLD (i_br_src2))) {
6376 
  {
6377 
    USI opval = FLD (i_br_disp);
6378 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6379 
    written |= (1 << 3);
6380 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6381 
  }
6382 
}
6383 
 
6384 
  abuf->written = written;
6385 
  SEM_BRANCH_FINI (vpc);
6386 
  return vpc;
6387 
#undef FLD
6388 
}
6389 
 
6390 
/* cmpibge-reg: cmpibge $br_src1, $br_src2, $br_disp */
6391 
 
6392 
static SEM_PC
6393 
SEM_FN_NAME (i960base,cmpibge_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6394 
{
6395 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
6396 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6397 
  int UNUSED written = 0;
6398 
  IADDR UNUSED pc = abuf->addr;
6399 
  SEM_BRANCH_INIT
6400 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6401 
 
6402 
if (GESI (* FLD (i_br_src1), * FLD (i_br_src2))) {
6403 
  {
6404 
    USI opval = FLD (i_br_disp);
6405 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6406 
    written |= (1 << 3);
6407 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6408 
  }
6409 
}
6410 
 
6411 
  abuf->written = written;
6412 
  SEM_BRANCH_FINI (vpc);
6413 
  return vpc;
6414 
#undef FLD
6415 
}
6416 
 
6417 
/* cmpibge-lit: cmpibge $br_lit1, $br_src2, $br_disp */
6418 
 
6419 
static SEM_PC
6420 
SEM_FN_NAME (i960base,cmpibge_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6421 
{
6422 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
6423 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6424 
  int UNUSED written = 0;
6425 
  IADDR UNUSED pc = abuf->addr;
6426 
  SEM_BRANCH_INIT
6427 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6428 
 
6429 
if (GESI (FLD (f_br_src1), * FLD (i_br_src2))) {
6430 
  {
6431 
    USI opval = FLD (i_br_disp);
6432 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6433 
    written |= (1 << 3);
6434 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6435 
  }
6436 
}
6437 
 
6438 
  abuf->written = written;
6439 
  SEM_BRANCH_FINI (vpc);
6440 
  return vpc;
6441 
#undef FLD
6442 
}
6443 
 
6444 
/* bbc-reg: bbc $br_src1, $br_src2, $br_disp */
6445 
 
6446 
static SEM_PC
6447 
SEM_FN_NAME (i960base,bbc_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6448 
{
6449 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
6450 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6451 
  int UNUSED written = 0;
6452 
  IADDR UNUSED pc = abuf->addr;
6453 
  SEM_BRANCH_INIT
6454 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6455 
 
6456 
if (EQSI (ANDSI (SLLSI (1, * FLD (i_br_src1)), * FLD (i_br_src2)), 0)) {
6457 
  {
6458 
    USI opval = FLD (i_br_disp);
6459 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6460 
    written |= (1 << 3);
6461 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6462 
  }
6463 
}
6464 
 
6465 
  abuf->written = written;
6466 
  SEM_BRANCH_FINI (vpc);
6467 
  return vpc;
6468 
#undef FLD
6469 
}
6470 
 
6471 
/* bbc-lit: bbc $br_lit1, $br_src2, $br_disp */
6472 
 
6473 
static SEM_PC
6474 
SEM_FN_NAME (i960base,bbc_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6475 
{
6476 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
6477 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6478 
  int UNUSED written = 0;
6479 
  IADDR UNUSED pc = abuf->addr;
6480 
  SEM_BRANCH_INIT
6481 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6482 
 
6483 
if (EQSI (ANDSI (SLLSI (1, FLD (f_br_src1)), * FLD (i_br_src2)), 0)) {
6484 
  {
6485 
    USI opval = FLD (i_br_disp);
6486 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6487 
    written |= (1 << 3);
6488 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6489 
  }
6490 
}
6491 
 
6492 
  abuf->written = written;
6493 
  SEM_BRANCH_FINI (vpc);
6494 
  return vpc;
6495 
#undef FLD
6496 
}
6497 
 
6498 
/* bbs-reg: bbs $br_src1, $br_src2, $br_disp */
6499 
 
6500 
static SEM_PC
6501 
SEM_FN_NAME (i960base,bbs_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6502 
{
6503 
#define FLD(f) abuf->fields.sfmt_cmpobe_reg.f
6504 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6505 
  int UNUSED written = 0;
6506 
  IADDR UNUSED pc = abuf->addr;
6507 
  SEM_BRANCH_INIT
6508 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6509 
 
6510 
if (NESI (ANDSI (SLLSI (1, * FLD (i_br_src1)), * FLD (i_br_src2)), 0)) {
6511 
  {
6512 
    USI opval = FLD (i_br_disp);
6513 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6514 
    written |= (1 << 3);
6515 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6516 
  }
6517 
}
6518 
 
6519 
  abuf->written = written;
6520 
  SEM_BRANCH_FINI (vpc);
6521 
  return vpc;
6522 
#undef FLD
6523 
}
6524 
 
6525 
/* bbs-lit: bbs $br_lit1, $br_src2, $br_disp */
6526 
 
6527 
static SEM_PC
6528 
SEM_FN_NAME (i960base,bbs_lit) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6529 
{
6530 
#define FLD(f) abuf->fields.sfmt_cmpobe_lit.f
6531 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6532 
  int UNUSED written = 0;
6533 
  IADDR UNUSED pc = abuf->addr;
6534 
  SEM_BRANCH_INIT
6535 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6536 
 
6537 
if (NESI (ANDSI (SLLSI (1, FLD (f_br_src1)), * FLD (i_br_src2)), 0)) {
6538 
  {
6539 
    USI opval = FLD (i_br_disp);
6540 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6541 
    written |= (1 << 3);
6542 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6543 
  }
6544 
}
6545 
 
6546 
  abuf->written = written;
6547 
  SEM_BRANCH_FINI (vpc);
6548 
  return vpc;
6549 
#undef FLD
6550 
}
6551 
 
6552 
/* cmpi: cmpi $src1, $src2 */
6553 
 
6554 
static SEM_PC
6555 
SEM_FN_NAME (i960base,cmpi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6556 
{
6557 
#define FLD(f) abuf->fields.sfmt_emul.f
6558 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6559 
  int UNUSED written = 0;
6560 
  IADDR UNUSED pc = abuf->addr;
6561 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6562 
 
6563 
  {
6564 
    SI opval = (LTSI (* FLD (i_src1), * FLD (i_src2))) ? (4) : (EQSI (* FLD (i_src1), * FLD (i_src2))) ? (2) : (1);
6565 
    CPU (h_cc) = opval;
6566 
    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
6567 
  }
6568 
 
6569 
  return vpc;
6570 
#undef FLD
6571 
}
6572 
 
6573 
/* cmpi1: cmpi $lit1, $src2 */
6574 
 
6575 
static SEM_PC
6576 
SEM_FN_NAME (i960base,cmpi1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6577 
{
6578 
#define FLD(f) abuf->fields.sfmt_emul1.f
6579 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6580 
  int UNUSED written = 0;
6581 
  IADDR UNUSED pc = abuf->addr;
6582 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6583 
 
6584 
  {
6585 
    SI opval = (LTSI (FLD (f_src1), * FLD (i_src2))) ? (4) : (EQSI (FLD (f_src1), * FLD (i_src2))) ? (2) : (1);
6586 
    CPU (h_cc) = opval;
6587 
    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
6588 
  }
6589 
 
6590 
  return vpc;
6591 
#undef FLD
6592 
}
6593 
 
6594 
/* cmpi2: cmpi $src1, $lit2 */
6595 
 
6596 
static SEM_PC
6597 
SEM_FN_NAME (i960base,cmpi2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6598 
{
6599 
#define FLD(f) abuf->fields.sfmt_emul2.f
6600 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6601 
  int UNUSED written = 0;
6602 
  IADDR UNUSED pc = abuf->addr;
6603 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6604 
 
6605 
  {
6606 
    SI opval = (LTSI (* FLD (i_src1), FLD (f_src2))) ? (4) : (EQSI (* FLD (i_src1), FLD (f_src2))) ? (2) : (1);
6607 
    CPU (h_cc) = opval;
6608 
    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
6609 
  }
6610 
 
6611 
  return vpc;
6612 
#undef FLD
6613 
}
6614 
 
6615 
/* cmpi3: cmpi $lit1, $lit2 */
6616 
 
6617 
static SEM_PC
6618 
SEM_FN_NAME (i960base,cmpi3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6619 
{
6620 
#define FLD(f) abuf->fields.sfmt_emul3.f
6621 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6622 
  int UNUSED written = 0;
6623 
  IADDR UNUSED pc = abuf->addr;
6624 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6625 
 
6626 
  {
6627 
    SI opval = (LTSI (FLD (f_src1), FLD (f_src2))) ? (4) : (EQSI (FLD (f_src1), FLD (f_src2))) ? (2) : (1);
6628 
    CPU (h_cc) = opval;
6629 
    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
6630 
  }
6631 
 
6632 
  return vpc;
6633 
#undef FLD
6634 
}
6635 
 
6636 
/* cmpo: cmpo $src1, $src2 */
6637 
 
6638 
static SEM_PC
6639 
SEM_FN_NAME (i960base,cmpo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6640 
{
6641 
#define FLD(f) abuf->fields.sfmt_emul.f
6642 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6643 
  int UNUSED written = 0;
6644 
  IADDR UNUSED pc = abuf->addr;
6645 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6646 
 
6647 
  {
6648 
    SI opval = (LTUSI (* FLD (i_src1), * FLD (i_src2))) ? (4) : (EQSI (* FLD (i_src1), * FLD (i_src2))) ? (2) : (1);
6649 
    CPU (h_cc) = opval;
6650 
    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
6651 
  }
6652 
 
6653 
  return vpc;
6654 
#undef FLD
6655 
}
6656 
 
6657 
/* cmpo1: cmpo $lit1, $src2 */
6658 
 
6659 
static SEM_PC
6660 
SEM_FN_NAME (i960base,cmpo1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6661 
{
6662 
#define FLD(f) abuf->fields.sfmt_emul1.f
6663 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6664 
  int UNUSED written = 0;
6665 
  IADDR UNUSED pc = abuf->addr;
6666 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6667 
 
6668 
  {
6669 
    SI opval = (LTUSI (FLD (f_src1), * FLD (i_src2))) ? (4) : (EQSI (FLD (f_src1), * FLD (i_src2))) ? (2) : (1);
6670 
    CPU (h_cc) = opval;
6671 
    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
6672 
  }
6673 
 
6674 
  return vpc;
6675 
#undef FLD
6676 
}
6677 
 
6678 
/* cmpo2: cmpo $src1, $lit2 */
6679 
 
6680 
static SEM_PC
6681 
SEM_FN_NAME (i960base,cmpo2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6682 
{
6683 
#define FLD(f) abuf->fields.sfmt_emul2.f
6684 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6685 
  int UNUSED written = 0;
6686 
  IADDR UNUSED pc = abuf->addr;
6687 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6688 
 
6689 
  {
6690 
    SI opval = (LTUSI (* FLD (i_src1), FLD (f_src2))) ? (4) : (EQSI (* FLD (i_src1), FLD (f_src2))) ? (2) : (1);
6691 
    CPU (h_cc) = opval;
6692 
    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
6693 
  }
6694 
 
6695 
  return vpc;
6696 
#undef FLD
6697 
}
6698 
 
6699 
/* cmpo3: cmpo $lit1, $lit2 */
6700 
 
6701 
static SEM_PC
6702 
SEM_FN_NAME (i960base,cmpo3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6703 
{
6704 
#define FLD(f) abuf->fields.sfmt_emul3.f
6705 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6706 
  int UNUSED written = 0;
6707 
  IADDR UNUSED pc = abuf->addr;
6708 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6709 
 
6710 
  {
6711 
    SI opval = (LTUSI (FLD (f_src1), FLD (f_src2))) ? (4) : (EQSI (FLD (f_src1), FLD (f_src2))) ? (2) : (1);
6712 
    CPU (h_cc) = opval;
6713 
    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
6714 
  }
6715 
 
6716 
  return vpc;
6717 
#undef FLD
6718 
}
6719 
 
6720 
/* testno-reg: testno $br_src1 */
6721 
 
6722 
static SEM_PC
6723 
SEM_FN_NAME (i960base,testno_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6724 
{
6725 
#define FLD(f) abuf->fields.sfmt_testno_reg.f
6726 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6727 
  int UNUSED written = 0;
6728 
  IADDR UNUSED pc = abuf->addr;
6729 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6730 
 
6731 
  {
6732 
    SI opval = EQSI (CPU (h_cc), 0);
6733 
    * FLD (i_br_src1) = opval;
6734 
    TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6735 
  }
6736 
 
6737 
  return vpc;
6738 
#undef FLD
6739 
}
6740 
 
6741 
/* testg-reg: testg $br_src1 */
6742 
 
6743 
static SEM_PC
6744 
SEM_FN_NAME (i960base,testg_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6745 
{
6746 
#define FLD(f) abuf->fields.sfmt_testno_reg.f
6747 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6748 
  int UNUSED written = 0;
6749 
  IADDR UNUSED pc = abuf->addr;
6750 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6751 
 
6752 
  {
6753 
    SI opval = NESI (ANDSI (CPU (h_cc), 1), 0);
6754 
    * FLD (i_br_src1) = opval;
6755 
    TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6756 
  }
6757 
 
6758 
  return vpc;
6759 
#undef FLD
6760 
}
6761 
 
6762 
/* teste-reg: teste $br_src1 */
6763 
 
6764 
static SEM_PC
6765 
SEM_FN_NAME (i960base,teste_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6766 
{
6767 
#define FLD(f) abuf->fields.sfmt_testno_reg.f
6768 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6769 
  int UNUSED written = 0;
6770 
  IADDR UNUSED pc = abuf->addr;
6771 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6772 
 
6773 
  {
6774 
    SI opval = NESI (ANDSI (CPU (h_cc), 2), 0);
6775 
    * FLD (i_br_src1) = opval;
6776 
    TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6777 
  }
6778 
 
6779 
  return vpc;
6780 
#undef FLD
6781 
}
6782 
 
6783 
/* testge-reg: testge $br_src1 */
6784 
 
6785 
static SEM_PC
6786 
SEM_FN_NAME (i960base,testge_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6787 
{
6788 
#define FLD(f) abuf->fields.sfmt_testno_reg.f
6789 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6790 
  int UNUSED written = 0;
6791 
  IADDR UNUSED pc = abuf->addr;
6792 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6793 
 
6794 
  {
6795 
    SI opval = NESI (ANDSI (CPU (h_cc), 3), 0);
6796 
    * FLD (i_br_src1) = opval;
6797 
    TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6798 
  }
6799 
 
6800 
  return vpc;
6801 
#undef FLD
6802 
}
6803 
 
6804 
/* testl-reg: testl $br_src1 */
6805 
 
6806 
static SEM_PC
6807 
SEM_FN_NAME (i960base,testl_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6808 
{
6809 
#define FLD(f) abuf->fields.sfmt_testno_reg.f
6810 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6811 
  int UNUSED written = 0;
6812 
  IADDR UNUSED pc = abuf->addr;
6813 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6814 
 
6815 
  {
6816 
    SI opval = NESI (ANDSI (CPU (h_cc), 4), 0);
6817 
    * FLD (i_br_src1) = opval;
6818 
    TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6819 
  }
6820 
 
6821 
  return vpc;
6822 
#undef FLD
6823 
}
6824 
 
6825 
/* testne-reg: testne $br_src1 */
6826 
 
6827 
static SEM_PC
6828 
SEM_FN_NAME (i960base,testne_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6829 
{
6830 
#define FLD(f) abuf->fields.sfmt_testno_reg.f
6831 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6832 
  int UNUSED written = 0;
6833 
  IADDR UNUSED pc = abuf->addr;
6834 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6835 
 
6836 
  {
6837 
    SI opval = NESI (ANDSI (CPU (h_cc), 5), 0);
6838 
    * FLD (i_br_src1) = opval;
6839 
    TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6840 
  }
6841 
 
6842 
  return vpc;
6843 
#undef FLD
6844 
}
6845 
 
6846 
/* testle-reg: testle $br_src1 */
6847 
 
6848 
static SEM_PC
6849 
SEM_FN_NAME (i960base,testle_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6850 
{
6851 
#define FLD(f) abuf->fields.sfmt_testno_reg.f
6852 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6853 
  int UNUSED written = 0;
6854 
  IADDR UNUSED pc = abuf->addr;
6855 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6856 
 
6857 
  {
6858 
    SI opval = NESI (ANDSI (CPU (h_cc), 6), 0);
6859 
    * FLD (i_br_src1) = opval;
6860 
    TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6861 
  }
6862 
 
6863 
  return vpc;
6864 
#undef FLD
6865 
}
6866 
 
6867 
/* testo-reg: testo $br_src1 */
6868 
 
6869 
static SEM_PC
6870 
SEM_FN_NAME (i960base,testo_reg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6871 
{
6872 
#define FLD(f) abuf->fields.sfmt_testno_reg.f
6873 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6874 
  int UNUSED written = 0;
6875 
  IADDR UNUSED pc = abuf->addr;
6876 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6877 
 
6878 
  {
6879 
    SI opval = NESI (ANDSI (CPU (h_cc), 7), 0);
6880 
    * FLD (i_br_src1) = opval;
6881 
    TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6882 
  }
6883 
 
6884 
  return vpc;
6885 
#undef FLD
6886 
}
6887 
 
6888 
/* bno: bno $ctrl_disp */
6889 
 
6890 
static SEM_PC
6891 
SEM_FN_NAME (i960base,bno) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6892 
{
6893 
#define FLD(f) abuf->fields.sfmt_bno.f
6894 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6895 
  int UNUSED written = 0;
6896 
  IADDR UNUSED pc = abuf->addr;
6897 
  SEM_BRANCH_INIT
6898 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6899 
 
6900 
if (EQSI (CPU (h_cc), 0)) {
6901 
  {
6902 
    USI opval = FLD (i_ctrl_disp);
6903 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6904 
    written |= (1 << 2);
6905 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6906 
  }
6907 
}
6908 
 
6909 
  abuf->written = written;
6910 
  SEM_BRANCH_FINI (vpc);
6911 
  return vpc;
6912 
#undef FLD
6913 
}
6914 
 
6915 
/* bg: bg $ctrl_disp */
6916 
 
6917 
static SEM_PC
6918 
SEM_FN_NAME (i960base,bg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6919 
{
6920 
#define FLD(f) abuf->fields.sfmt_bno.f
6921 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6922 
  int UNUSED written = 0;
6923 
  IADDR UNUSED pc = abuf->addr;
6924 
  SEM_BRANCH_INIT
6925 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6926 
 
6927 
if (NESI (ANDSI (CPU (h_cc), 1), 0)) {
6928 
  {
6929 
    USI opval = FLD (i_ctrl_disp);
6930 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6931 
    written |= (1 << 2);
6932 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6933 
  }
6934 
}
6935 
 
6936 
  abuf->written = written;
6937 
  SEM_BRANCH_FINI (vpc);
6938 
  return vpc;
6939 
#undef FLD
6940 
}
6941 
 
6942 
/* be: be $ctrl_disp */
6943 
 
6944 
static SEM_PC
6945 
SEM_FN_NAME (i960base,be) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6946 
{
6947 
#define FLD(f) abuf->fields.sfmt_bno.f
6948 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6949 
  int UNUSED written = 0;
6950 
  IADDR UNUSED pc = abuf->addr;
6951 
  SEM_BRANCH_INIT
6952 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6953 
 
6954 
if (NESI (ANDSI (CPU (h_cc), 2), 0)) {
6955 
  {
6956 
    USI opval = FLD (i_ctrl_disp);
6957 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6958 
    written |= (1 << 2);
6959 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6960 
  }
6961 
}
6962 
 
6963 
  abuf->written = written;
6964 
  SEM_BRANCH_FINI (vpc);
6965 
  return vpc;
6966 
#undef FLD
6967 
}
6968 
 
6969 
/* bge: bge $ctrl_disp */
6970 
 
6971 
static SEM_PC
6972 
SEM_FN_NAME (i960base,bge) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
6973 
{
6974 
#define FLD(f) abuf->fields.sfmt_bno.f
6975 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6976 
  int UNUSED written = 0;
6977 
  IADDR UNUSED pc = abuf->addr;
6978 
  SEM_BRANCH_INIT
6979 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6980 
 
6981 
if (NESI (ANDSI (CPU (h_cc), 3), 0)) {
6982 
  {
6983 
    USI opval = FLD (i_ctrl_disp);
6984 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
6985 
    written |= (1 << 2);
6986 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6987 
  }
6988 
}
6989 
 
6990 
  abuf->written = written;
6991 
  SEM_BRANCH_FINI (vpc);
6992 
  return vpc;
6993 
#undef FLD
6994 
}
6995 
 
6996 
/* bl: bl $ctrl_disp */
6997 
 
6998 
static SEM_PC
6999 
SEM_FN_NAME (i960base,bl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7000 
{
7001 
#define FLD(f) abuf->fields.sfmt_bno.f
7002 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7003 
  int UNUSED written = 0;
7004 
  IADDR UNUSED pc = abuf->addr;
7005 
  SEM_BRANCH_INIT
7006 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7007 
 
7008 
if (NESI (ANDSI (CPU (h_cc), 4), 0)) {
7009 
  {
7010 
    USI opval = FLD (i_ctrl_disp);
7011 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
7012 
    written |= (1 << 2);
7013 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7014 
  }
7015 
}
7016 
 
7017 
  abuf->written = written;
7018 
  SEM_BRANCH_FINI (vpc);
7019 
  return vpc;
7020 
#undef FLD
7021 
}
7022 
 
7023 
/* bne: bne $ctrl_disp */
7024 
 
7025 
static SEM_PC
7026 
SEM_FN_NAME (i960base,bne) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7027 
{
7028 
#define FLD(f) abuf->fields.sfmt_bno.f
7029 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7030 
  int UNUSED written = 0;
7031 
  IADDR UNUSED pc = abuf->addr;
7032 
  SEM_BRANCH_INIT
7033 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7034 
 
7035 
if (NESI (ANDSI (CPU (h_cc), 5), 0)) {
7036 
  {
7037 
    USI opval = FLD (i_ctrl_disp);
7038 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
7039 
    written |= (1 << 2);
7040 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7041 
  }
7042 
}
7043 
 
7044 
  abuf->written = written;
7045 
  SEM_BRANCH_FINI (vpc);
7046 
  return vpc;
7047 
#undef FLD
7048 
}
7049 
 
7050 
/* ble: ble $ctrl_disp */
7051 
 
7052 
static SEM_PC
7053 
SEM_FN_NAME (i960base,ble) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7054 
{
7055 
#define FLD(f) abuf->fields.sfmt_bno.f
7056 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7057 
  int UNUSED written = 0;
7058 
  IADDR UNUSED pc = abuf->addr;
7059 
  SEM_BRANCH_INIT
7060 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7061 
 
7062 
if (NESI (ANDSI (CPU (h_cc), 6), 0)) {
7063 
  {
7064 
    USI opval = FLD (i_ctrl_disp);
7065 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
7066 
    written |= (1 << 2);
7067 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7068 
  }
7069 
}
7070 
 
7071 
  abuf->written = written;
7072 
  SEM_BRANCH_FINI (vpc);
7073 
  return vpc;
7074 
#undef FLD
7075 
}
7076 
 
7077 
/* bo: bo $ctrl_disp */
7078 
 
7079 
static SEM_PC
7080 
SEM_FN_NAME (i960base,bo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7081 
{
7082 
#define FLD(f) abuf->fields.sfmt_bno.f
7083 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7084 
  int UNUSED written = 0;
7085 
  IADDR UNUSED pc = abuf->addr;
7086 
  SEM_BRANCH_INIT
7087 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7088 
 
7089 
if (NESI (ANDSI (CPU (h_cc), 7), 0)) {
7090 
  {
7091 
    USI opval = FLD (i_ctrl_disp);
7092 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
7093 
    written |= (1 << 2);
7094 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7095 
  }
7096 
}
7097 
 
7098 
  abuf->written = written;
7099 
  SEM_BRANCH_FINI (vpc);
7100 
  return vpc;
7101 
#undef FLD
7102 
}
7103 
 
7104 
/* b: b $ctrl_disp */
7105 
 
7106 
static SEM_PC
7107 
SEM_FN_NAME (i960base,b) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7108 
{
7109 
#define FLD(f) abuf->fields.sfmt_bno.f
7110 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7111 
  int UNUSED written = 0;
7112 
  IADDR UNUSED pc = abuf->addr;
7113 
  SEM_BRANCH_INIT
7114 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7115 
 
7116 
  {
7117 
    USI opval = FLD (i_ctrl_disp);
7118 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
7119 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7120 
  }
7121 
 
7122 
  SEM_BRANCH_FINI (vpc);
7123 
  return vpc;
7124 
#undef FLD
7125 
}
7126 
 
7127 
/* bx-indirect-offset: bx $offset($abase) */
7128 
 
7129 
static SEM_PC
7130 
SEM_FN_NAME (i960base,bx_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7131 
{
7132 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
7133 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7134 
  int UNUSED written = 0;
7135 
  IADDR UNUSED pc = abuf->addr;
7136 
  SEM_BRANCH_INIT
7137 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7138 
 
7139 
  {
7140 
    USI opval = ADDSI (FLD (f_offset), * FLD (i_abase));
7141 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
7142 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7143 
  }
7144 
 
7145 
  SEM_BRANCH_FINI (vpc);
7146 
  return vpc;
7147 
#undef FLD
7148 
}
7149 
 
7150 
/* bx-indirect: bx ($abase) */
7151 
 
7152 
static SEM_PC
7153 
SEM_FN_NAME (i960base,bx_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7154 
{
7155 
#define FLD(f) abuf->fields.sfmt_stq_indirect_offset.f
7156 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7157 
  int UNUSED written = 0;
7158 
  IADDR UNUSED pc = abuf->addr;
7159 
  SEM_BRANCH_INIT
7160 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7161 
 
7162 
  {
7163 
    USI opval = * FLD (i_abase);
7164 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
7165 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7166 
  }
7167 
 
7168 
  SEM_BRANCH_FINI (vpc);
7169 
  return vpc;
7170 
#undef FLD
7171 
}
7172 
 
7173 
/* bx-indirect-index: bx ($abase)[$index*S$scale] */
7174 
 
7175 
static SEM_PC
7176 
SEM_FN_NAME (i960base,bx_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7177 
{
7178 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
7179 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7180 
  int UNUSED written = 0;
7181 
  IADDR UNUSED pc = abuf->addr;
7182 
  SEM_BRANCH_INIT
7183 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7184 
 
7185 
  {
7186 
    USI opval = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
7187 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
7188 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7189 
  }
7190 
 
7191 
  SEM_BRANCH_FINI (vpc);
7192 
  return vpc;
7193 
#undef FLD
7194 
}
7195 
 
7196 
/* bx-disp: bx $optdisp */
7197 
 
7198 
static SEM_PC
7199 
SEM_FN_NAME (i960base,bx_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7200 
{
7201 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
7202 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7203 
  int UNUSED written = 0;
7204 
  IADDR UNUSED pc = abuf->addr;
7205 
  SEM_BRANCH_INIT
7206 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
7207 
 
7208 
  {
7209 
    USI opval = FLD (f_optdisp);
7210 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
7211 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7212 
  }
7213 
 
7214 
  SEM_BRANCH_FINI (vpc);
7215 
  return vpc;
7216 
#undef FLD
7217 
}
7218 
 
7219 
/* bx-indirect-disp: bx $optdisp($abase) */
7220 
 
7221 
static SEM_PC
7222 
SEM_FN_NAME (i960base,bx_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7223 
{
7224 
#define FLD(f) abuf->fields.sfmt_stq_indirect_index_disp.f
7225 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7226 
  int UNUSED written = 0;
7227 
  IADDR UNUSED pc = abuf->addr;
7228 
  SEM_BRANCH_INIT
7229 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
7230 
 
7231 
  {
7232 
    USI opval = ADDSI (FLD (f_optdisp), * FLD (i_abase));
7233 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
7234 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7235 
  }
7236 
 
7237 
  SEM_BRANCH_FINI (vpc);
7238 
  return vpc;
7239 
#undef FLD
7240 
}
7241 
 
7242 
/* callx-disp: callx $optdisp */
7243 
 
7244 
static SEM_PC
7245 
SEM_FN_NAME (i960base,callx_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7246 
{
7247 
#define FLD(f) abuf->fields.sfmt_callx_disp.f
7248 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7249 
  int UNUSED written = 0;
7250 
  IADDR UNUSED pc = abuf->addr;
7251 
  SEM_BRANCH_INIT
7252 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
7253 
 
7254 
{
7255 
  SI tmp_temp;
7256 
  tmp_temp = ANDSI (ADDSI (CPU (h_gr[((UINT) 1)]), 63), INVSI (63));
7257 
  {
7258 
    SI opval = ADDSI (pc, 8);
7259 
    CPU (h_gr[((UINT) 2)]) = opval;
7260 
    TRACE_RESULT (current_cpu, abuf, "gr-2", 'x', opval);
7261 
  }
7262 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 0), CPU (h_gr[((UINT) 0)]));
7263 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 4), CPU (h_gr[((UINT) 1)]));
7264 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 8), CPU (h_gr[((UINT) 2)]));
7265 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 12), CPU (h_gr[((UINT) 3)]));
7266 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 16), CPU (h_gr[((UINT) 4)]));
7267 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 20), CPU (h_gr[((UINT) 5)]));
7268 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 24), CPU (h_gr[((UINT) 6)]));
7269 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 28), CPU (h_gr[((UINT) 7)]));
7270 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 32), CPU (h_gr[((UINT) 8)]));
7271 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 36), CPU (h_gr[((UINT) 9)]));
7272 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 40), CPU (h_gr[((UINT) 10)]));
7273 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 44), CPU (h_gr[((UINT) 11)]));
7274 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 48), CPU (h_gr[((UINT) 12)]));
7275 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 52), CPU (h_gr[((UINT) 13)]));
7276 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 56), CPU (h_gr[((UINT) 14)]));
7277 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 60), CPU (h_gr[((UINT) 15)]));
7278 
  {
7279 
    USI opval = FLD (f_optdisp);
7280 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
7281 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7282 
  }
7283 
CPU (h_gr[((UINT) 0)]) = 0xdeadbeef;
7284 
CPU (h_gr[((UINT) 1)]) = 0xdeadbeef;
7285 
CPU (h_gr[((UINT) 2)]) = 0xdeadbeef;
7286 
CPU (h_gr[((UINT) 3)]) = 0xdeadbeef;
7287 
CPU (h_gr[((UINT) 4)]) = 0xdeadbeef;
7288 
CPU (h_gr[((UINT) 5)]) = 0xdeadbeef;
7289 
CPU (h_gr[((UINT) 6)]) = 0xdeadbeef;
7290 
CPU (h_gr[((UINT) 7)]) = 0xdeadbeef;
7291 
CPU (h_gr[((UINT) 8)]) = 0xdeadbeef;
7292 
CPU (h_gr[((UINT) 9)]) = 0xdeadbeef;
7293 
CPU (h_gr[((UINT) 10)]) = 0xdeadbeef;
7294 
CPU (h_gr[((UINT) 11)]) = 0xdeadbeef;
7295 
CPU (h_gr[((UINT) 12)]) = 0xdeadbeef;
7296 
CPU (h_gr[((UINT) 13)]) = 0xdeadbeef;
7297 
CPU (h_gr[((UINT) 14)]) = 0xdeadbeef;
7298 
CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
7299 
  {
7300 
    SI opval = CPU (h_gr[((UINT) 31)]);
7301 
    CPU (h_gr[((UINT) 0)]) = opval;
7302 
    TRACE_RESULT (current_cpu, abuf, "gr-0", 'x', opval);
7303 
  }
7304 
  {
7305 
    SI opval = tmp_temp;
7306 
    CPU (h_gr[((UINT) 31)]) = opval;
7307 
    TRACE_RESULT (current_cpu, abuf, "gr-31", 'x', opval);
7308 
  }
7309 
  {
7310 
    SI opval = ADDSI (tmp_temp, 64);
7311 
    CPU (h_gr[((UINT) 1)]) = opval;
7312 
    TRACE_RESULT (current_cpu, abuf, "gr-1", 'x', opval);
7313 
  }
7314 
}
7315 
 
7316 
  SEM_BRANCH_FINI (vpc);
7317 
  return vpc;
7318 
#undef FLD
7319 
}
7320 
 
7321 
/* callx-indirect: callx ($abase) */
7322 
 
7323 
static SEM_PC
7324 
SEM_FN_NAME (i960base,callx_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7325 
{
7326 
#define FLD(f) abuf->fields.sfmt_callx_indirect_offset.f
7327 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7328 
  int UNUSED written = 0;
7329 
  IADDR UNUSED pc = abuf->addr;
7330 
  SEM_BRANCH_INIT
7331 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7332 
 
7333 
{
7334 
  SI tmp_temp;
7335 
  tmp_temp = ANDSI (ADDSI (CPU (h_gr[((UINT) 1)]), 63), INVSI (63));
7336 
  {
7337 
    SI opval = ADDSI (pc, 4);
7338 
    CPU (h_gr[((UINT) 2)]) = opval;
7339 
    TRACE_RESULT (current_cpu, abuf, "gr-2", 'x', opval);
7340 
  }
7341 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 0), CPU (h_gr[((UINT) 0)]));
7342 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 4), CPU (h_gr[((UINT) 1)]));
7343 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 8), CPU (h_gr[((UINT) 2)]));
7344 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 12), CPU (h_gr[((UINT) 3)]));
7345 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 16), CPU (h_gr[((UINT) 4)]));
7346 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 20), CPU (h_gr[((UINT) 5)]));
7347 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 24), CPU (h_gr[((UINT) 6)]));
7348 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 28), CPU (h_gr[((UINT) 7)]));
7349 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 32), CPU (h_gr[((UINT) 8)]));
7350 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 36), CPU (h_gr[((UINT) 9)]));
7351 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 40), CPU (h_gr[((UINT) 10)]));
7352 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 44), CPU (h_gr[((UINT) 11)]));
7353 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 48), CPU (h_gr[((UINT) 12)]));
7354 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 52), CPU (h_gr[((UINT) 13)]));
7355 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 56), CPU (h_gr[((UINT) 14)]));
7356 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 60), CPU (h_gr[((UINT) 15)]));
7357 
  {
7358 
    USI opval = * FLD (i_abase);
7359 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
7360 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7361 
  }
7362 
CPU (h_gr[((UINT) 0)]) = 0xdeadbeef;
7363 
CPU (h_gr[((UINT) 1)]) = 0xdeadbeef;
7364 
CPU (h_gr[((UINT) 2)]) = 0xdeadbeef;
7365 
CPU (h_gr[((UINT) 3)]) = 0xdeadbeef;
7366 
CPU (h_gr[((UINT) 4)]) = 0xdeadbeef;
7367 
CPU (h_gr[((UINT) 5)]) = 0xdeadbeef;
7368 
CPU (h_gr[((UINT) 6)]) = 0xdeadbeef;
7369 
CPU (h_gr[((UINT) 7)]) = 0xdeadbeef;
7370 
CPU (h_gr[((UINT) 8)]) = 0xdeadbeef;
7371 
CPU (h_gr[((UINT) 9)]) = 0xdeadbeef;
7372 
CPU (h_gr[((UINT) 10)]) = 0xdeadbeef;
7373 
CPU (h_gr[((UINT) 11)]) = 0xdeadbeef;
7374 
CPU (h_gr[((UINT) 12)]) = 0xdeadbeef;
7375 
CPU (h_gr[((UINT) 13)]) = 0xdeadbeef;
7376 
CPU (h_gr[((UINT) 14)]) = 0xdeadbeef;
7377 
CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
7378 
  {
7379 
    SI opval = CPU (h_gr[((UINT) 31)]);
7380 
    CPU (h_gr[((UINT) 0)]) = opval;
7381 
    TRACE_RESULT (current_cpu, abuf, "gr-0", 'x', opval);
7382 
  }
7383 
  {
7384 
    SI opval = tmp_temp;
7385 
    CPU (h_gr[((UINT) 31)]) = opval;
7386 
    TRACE_RESULT (current_cpu, abuf, "gr-31", 'x', opval);
7387 
  }
7388 
  {
7389 
    SI opval = ADDSI (tmp_temp, 64);
7390 
    CPU (h_gr[((UINT) 1)]) = opval;
7391 
    TRACE_RESULT (current_cpu, abuf, "gr-1", 'x', opval);
7392 
  }
7393 
}
7394 
 
7395 
  SEM_BRANCH_FINI (vpc);
7396 
  return vpc;
7397 
#undef FLD
7398 
}
7399 
 
7400 
/* callx-indirect-offset: callx $offset($abase) */
7401 
 
7402 
static SEM_PC
7403 
SEM_FN_NAME (i960base,callx_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7404 
{
7405 
#define FLD(f) abuf->fields.sfmt_callx_indirect_offset.f
7406 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7407 
  int UNUSED written = 0;
7408 
  IADDR UNUSED pc = abuf->addr;
7409 
  SEM_BRANCH_INIT
7410 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7411 
 
7412 
{
7413 
  SI tmp_temp;
7414 
  tmp_temp = ANDSI (ADDSI (CPU (h_gr[((UINT) 1)]), 63), INVSI (63));
7415 
  {
7416 
    SI opval = ADDSI (pc, 4);
7417 
    CPU (h_gr[((UINT) 2)]) = opval;
7418 
    TRACE_RESULT (current_cpu, abuf, "gr-2", 'x', opval);
7419 
  }
7420 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 0), CPU (h_gr[((UINT) 0)]));
7421 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 4), CPU (h_gr[((UINT) 1)]));
7422 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 8), CPU (h_gr[((UINT) 2)]));
7423 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 12), CPU (h_gr[((UINT) 3)]));
7424 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 16), CPU (h_gr[((UINT) 4)]));
7425 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 20), CPU (h_gr[((UINT) 5)]));
7426 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 24), CPU (h_gr[((UINT) 6)]));
7427 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 28), CPU (h_gr[((UINT) 7)]));
7428 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 32), CPU (h_gr[((UINT) 8)]));
7429 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 36), CPU (h_gr[((UINT) 9)]));
7430 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 40), CPU (h_gr[((UINT) 10)]));
7431 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 44), CPU (h_gr[((UINT) 11)]));
7432 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 48), CPU (h_gr[((UINT) 12)]));
7433 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 52), CPU (h_gr[((UINT) 13)]));
7434 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 56), CPU (h_gr[((UINT) 14)]));
7435 
SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 60), CPU (h_gr[((UINT) 15)]));
7436 
  {
7437 
    USI opval = ADDSI (FLD (f_offset), * FLD (i_abase));
7438 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
7439 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7440 
  }
7441 
CPU (h_gr[((UINT) 0)]) = 0xdeadbeef;
7442 
CPU (h_gr[((UINT) 1)]) = 0xdeadbeef;
7443 
CPU (h_gr[((UINT) 2)]) = 0xdeadbeef;
7444 
CPU (h_gr[((UINT) 3)]) = 0xdeadbeef;
7445 
CPU (h_gr[((UINT) 4)]) = 0xdeadbeef;
7446 
CPU (h_gr[((UINT) 5)]) = 0xdeadbeef;
7447 
CPU (h_gr[((UINT) 6)]) = 0xdeadbeef;
7448 
CPU (h_gr[((UINT) 7)]) = 0xdeadbeef;
7449 
CPU (h_gr[((UINT) 8)]) = 0xdeadbeef;
7450 
CPU (h_gr[((UINT) 9)]) = 0xdeadbeef;
7451 
CPU (h_gr[((UINT) 10)]) = 0xdeadbeef;
7452 
CPU (h_gr[((UINT) 11)]) = 0xdeadbeef;
7453 
CPU (h_gr[((UINT) 12)]) = 0xdeadbeef;
7454 
CPU (h_gr[((UINT) 13)]) = 0xdeadbeef;
7455 
CPU (h_gr[((UINT) 14)]) = 0xdeadbeef;
7456 
CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
7457 
  {
7458 
    SI opval = CPU (h_gr[((UINT) 31)]);
7459 
    CPU (h_gr[((UINT) 0)]) = opval;
7460 
    TRACE_RESULT (current_cpu, abuf, "gr-0", 'x', opval);
7461 
  }
7462 
  {
7463 
    SI opval = tmp_temp;
7464 
    CPU (h_gr[((UINT) 31)]) = opval;
7465 
    TRACE_RESULT (current_cpu, abuf, "gr-31", 'x', opval);
7466 
  }
7467 
  {
7468 
    SI opval = ADDSI (tmp_temp, 64);
7469 
    CPU (h_gr[((UINT) 1)]) = opval;
7470 
    TRACE_RESULT (current_cpu, abuf, "gr-1", 'x', opval);
7471 
  }
7472 
}
7473 
 
7474 
  SEM_BRANCH_FINI (vpc);
7475 
  return vpc;
7476 
#undef FLD
7477 
}
7478 
 
7479 
/* ret: ret */
7480 
 
7481 
static SEM_PC
7482 
SEM_FN_NAME (i960base,ret) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7483 
{
7484 
#define FLD(f) abuf->fields.sfmt_callx_disp.f
7485 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7486 
  int UNUSED written = 0;
7487 
  IADDR UNUSED pc = abuf->addr;
7488 
  SEM_BRANCH_INIT
7489 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7490 
 
7491 
{
7492 
  {
7493 
    SI opval = CPU (h_gr[((UINT) 0)]);
7494 
    CPU (h_gr[((UINT) 31)]) = opval;
7495 
    TRACE_RESULT (current_cpu, abuf, "gr-31", 'x', opval);
7496 
  }
7497 
CPU (h_gr[((UINT) 0)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 0));
7498 
CPU (h_gr[((UINT) 1)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 4));
7499 
CPU (h_gr[((UINT) 2)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 8));
7500 
CPU (h_gr[((UINT) 3)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 12));
7501 
CPU (h_gr[((UINT) 4)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 16));
7502 
CPU (h_gr[((UINT) 5)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 20));
7503 
CPU (h_gr[((UINT) 6)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 24));
7504 
CPU (h_gr[((UINT) 7)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 28));
7505 
CPU (h_gr[((UINT) 8)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 32));
7506 
CPU (h_gr[((UINT) 9)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 36));
7507 
CPU (h_gr[((UINT) 10)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 40));
7508 
CPU (h_gr[((UINT) 11)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 44));
7509 
CPU (h_gr[((UINT) 12)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 48));
7510 
CPU (h_gr[((UINT) 13)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 52));
7511 
CPU (h_gr[((UINT) 14)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 56));
7512 
CPU (h_gr[((UINT) 15)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 60));
7513 
  {
7514 
    USI opval = CPU (h_gr[((UINT) 2)]);
7515 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
7516 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7517 
  }
7518 
}
7519 
 
7520 
  SEM_BRANCH_FINI (vpc);
7521 
  return vpc;
7522 
#undef FLD
7523 
}
7524 
 
7525 
/* calls: calls $src1 */
7526 
 
7527 
static SEM_PC
7528 
SEM_FN_NAME (i960base,calls) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7529 
{
7530 
#define FLD(f) abuf->fields.sfmt_emul2.f
7531 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7532 
  int UNUSED written = 0;
7533 
  IADDR UNUSED pc = abuf->addr;
7534 
  SEM_BRANCH_INIT
7535 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7536 
 
7537 
  {
7538 
    SI opval = i960_trap (current_cpu, pc, * FLD (i_src1));
7539 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
7540 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7541 
  }
7542 
 
7543 
  SEM_BRANCH_FINI (vpc);
7544 
  return vpc;
7545 
#undef FLD
7546 
}
7547 
 
7548 
/* fmark: fmark */
7549 
 
7550 
static SEM_PC
7551 
SEM_FN_NAME (i960base,fmark) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7552 
{
7553 
#define FLD(f) abuf->fields.fmt_empty.f
7554 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7555 
  int UNUSED written = 0;
7556 
  IADDR UNUSED pc = abuf->addr;
7557 
  SEM_BRANCH_INIT
7558 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7559 
 
7560 
  {
7561 
    SI opval = i960_breakpoint (current_cpu, pc);
7562 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
7563 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7564 
  }
7565 
 
7566 
  SEM_BRANCH_FINI (vpc);
7567 
  return vpc;
7568 
#undef FLD
7569 
}
7570 
 
7571 
/* flushreg: flushreg */
7572 
 
7573 
static SEM_PC
7574 
SEM_FN_NAME (i960base,flushreg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
7575 
{
7576 
#define FLD(f) abuf->fields.fmt_empty.f
7577 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7578 
  int UNUSED written = 0;
7579 
  IADDR UNUSED pc = abuf->addr;
7580 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7581 
 
7582 
((void) 0); /*nop*/
7583 
 
7584 
  return vpc;
7585 
#undef FLD
7586 
}
7587 
 
7588 
/* Table of all semantic fns.  */
7589 
 
7590 
static const struct sem_fn_desc sem_fns[] = {
7591 
  { I960BASE_INSN_X_INVALID, SEM_FN_NAME (i960base,x_invalid) },
7592 
  { I960BASE_INSN_X_AFTER, SEM_FN_NAME (i960base,x_after) },
7593 
  { I960BASE_INSN_X_BEFORE, SEM_FN_NAME (i960base,x_before) },
7594 
  { I960BASE_INSN_X_CTI_CHAIN, SEM_FN_NAME (i960base,x_cti_chain) },
7595 
  { I960BASE_INSN_X_CHAIN, SEM_FN_NAME (i960base,x_chain) },
7596 
  { I960BASE_INSN_X_BEGIN, SEM_FN_NAME (i960base,x_begin) },
7597 
  { I960BASE_INSN_MULO, SEM_FN_NAME (i960base,mulo) },
7598 
  { I960BASE_INSN_MULO1, SEM_FN_NAME (i960base,mulo1) },
7599 
  { I960BASE_INSN_MULO2, SEM_FN_NAME (i960base,mulo2) },
7600 
  { I960BASE_INSN_MULO3, SEM_FN_NAME (i960base,mulo3) },
7601 
  { I960BASE_INSN_REMO, SEM_FN_NAME (i960base,remo) },
7602 
  { I960BASE_INSN_REMO1, SEM_FN_NAME (i960base,remo1) },
7603 
  { I960BASE_INSN_REMO2, SEM_FN_NAME (i960base,remo2) },
7604 
  { I960BASE_INSN_REMO3, SEM_FN_NAME (i960base,remo3) },
7605 
  { I960BASE_INSN_DIVO, SEM_FN_NAME (i960base,divo) },
7606 
  { I960BASE_INSN_DIVO1, SEM_FN_NAME (i960base,divo1) },
7607 
  { I960BASE_INSN_DIVO2, SEM_FN_NAME (i960base,divo2) },
7608 
  { I960BASE_INSN_DIVO3, SEM_FN_NAME (i960base,divo3) },
7609 
  { I960BASE_INSN_REMI, SEM_FN_NAME (i960base,remi) },
7610 
  { I960BASE_INSN_REMI1, SEM_FN_NAME (i960base,remi1) },
7611 
  { I960BASE_INSN_REMI2, SEM_FN_NAME (i960base,remi2) },
7612 
  { I960BASE_INSN_REMI3, SEM_FN_NAME (i960base,remi3) },
7613 
  { I960BASE_INSN_DIVI, SEM_FN_NAME (i960base,divi) },
7614 
  { I960BASE_INSN_DIVI1, SEM_FN_NAME (i960base,divi1) },
7615 
  { I960BASE_INSN_DIVI2, SEM_FN_NAME (i960base,divi2) },
7616 
  { I960BASE_INSN_DIVI3, SEM_FN_NAME (i960base,divi3) },
7617 
  { I960BASE_INSN_ADDO, SEM_FN_NAME (i960base,addo) },
7618 
  { I960BASE_INSN_ADDO1, SEM_FN_NAME (i960base,addo1) },
7619 
  { I960BASE_INSN_ADDO2, SEM_FN_NAME (i960base,addo2) },
7620 
  { I960BASE_INSN_ADDO3, SEM_FN_NAME (i960base,addo3) },
7621 
  { I960BASE_INSN_SUBO, SEM_FN_NAME (i960base,subo) },
7622 
  { I960BASE_INSN_SUBO1, SEM_FN_NAME (i960base,subo1) },
7623 
  { I960BASE_INSN_SUBO2, SEM_FN_NAME (i960base,subo2) },
7624 
  { I960BASE_INSN_SUBO3, SEM_FN_NAME (i960base,subo3) },
7625 
  { I960BASE_INSN_NOTBIT, SEM_FN_NAME (i960base,notbit) },
7626 
  { I960BASE_INSN_NOTBIT1, SEM_FN_NAME (i960base,notbit1) },
7627 
  { I960BASE_INSN_NOTBIT2, SEM_FN_NAME (i960base,notbit2) },
7628 
  { I960BASE_INSN_NOTBIT3, SEM_FN_NAME (i960base,notbit3) },
7629 
  { I960BASE_INSN_AND, SEM_FN_NAME (i960base,and) },
7630 
  { I960BASE_INSN_AND1, SEM_FN_NAME (i960base,and1) },
7631 
  { I960BASE_INSN_AND2, SEM_FN_NAME (i960base,and2) },
7632 
  { I960BASE_INSN_AND3, SEM_FN_NAME (i960base,and3) },
7633 
  { I960BASE_INSN_ANDNOT, SEM_FN_NAME (i960base,andnot) },
7634 
  { I960BASE_INSN_ANDNOT1, SEM_FN_NAME (i960base,andnot1) },
7635 
  { I960BASE_INSN_ANDNOT2, SEM_FN_NAME (i960base,andnot2) },
7636 
  { I960BASE_INSN_ANDNOT3, SEM_FN_NAME (i960base,andnot3) },
7637 
  { I960BASE_INSN_SETBIT, SEM_FN_NAME (i960base,setbit) },
7638 
  { I960BASE_INSN_SETBIT1, SEM_FN_NAME (i960base,setbit1) },
7639 
  { I960BASE_INSN_SETBIT2, SEM_FN_NAME (i960base,setbit2) },
7640 
  { I960BASE_INSN_SETBIT3, SEM_FN_NAME (i960base,setbit3) },
7641 
  { I960BASE_INSN_NOTAND, SEM_FN_NAME (i960base,notand) },
7642 
  { I960BASE_INSN_NOTAND1, SEM_FN_NAME (i960base,notand1) },
7643 
  { I960BASE_INSN_NOTAND2, SEM_FN_NAME (i960base,notand2) },
7644 
  { I960BASE_INSN_NOTAND3, SEM_FN_NAME (i960base,notand3) },
7645 
  { I960BASE_INSN_XOR, SEM_FN_NAME (i960base,xor) },
7646 
  { I960BASE_INSN_XOR1, SEM_FN_NAME (i960base,xor1) },
7647 
  { I960BASE_INSN_XOR2, SEM_FN_NAME (i960base,xor2) },
7648 
  { I960BASE_INSN_XOR3, SEM_FN_NAME (i960base,xor3) },
7649 
  { I960BASE_INSN_OR, SEM_FN_NAME (i960base,or) },
7650 
  { I960BASE_INSN_OR1, SEM_FN_NAME (i960base,or1) },
7651 
  { I960BASE_INSN_OR2, SEM_FN_NAME (i960base,or2) },
7652 
  { I960BASE_INSN_OR3, SEM_FN_NAME (i960base,or3) },
7653 
  { I960BASE_INSN_NOR, SEM_FN_NAME (i960base,nor) },
7654 
  { I960BASE_INSN_NOR1, SEM_FN_NAME (i960base,nor1) },
7655 
  { I960BASE_INSN_NOR2, SEM_FN_NAME (i960base,nor2) },
7656 
  { I960BASE_INSN_NOR3, SEM_FN_NAME (i960base,nor3) },
7657 
  { I960BASE_INSN_XNOR, SEM_FN_NAME (i960base,xnor) },
7658 
  { I960BASE_INSN_XNOR1, SEM_FN_NAME (i960base,xnor1) },
7659 
  { I960BASE_INSN_XNOR2, SEM_FN_NAME (i960base,xnor2) },
7660 
  { I960BASE_INSN_XNOR3, SEM_FN_NAME (i960base,xnor3) },
7661 
  { I960BASE_INSN_NOT, SEM_FN_NAME (i960base,not) },
7662 
  { I960BASE_INSN_NOT1, SEM_FN_NAME (i960base,not1) },
7663 
  { I960BASE_INSN_NOT2, SEM_FN_NAME (i960base,not2) },
7664 
  { I960BASE_INSN_NOT3, SEM_FN_NAME (i960base,not3) },
7665 
  { I960BASE_INSN_ORNOT, SEM_FN_NAME (i960base,ornot) },
7666 
  { I960BASE_INSN_ORNOT1, SEM_FN_NAME (i960base,ornot1) },
7667 
  { I960BASE_INSN_ORNOT2, SEM_FN_NAME (i960base,ornot2) },
7668 
  { I960BASE_INSN_ORNOT3, SEM_FN_NAME (i960base,ornot3) },
7669 
  { I960BASE_INSN_CLRBIT, SEM_FN_NAME (i960base,clrbit) },
7670 
  { I960BASE_INSN_CLRBIT1, SEM_FN_NAME (i960base,clrbit1) },
7671 
  { I960BASE_INSN_CLRBIT2, SEM_FN_NAME (i960base,clrbit2) },
7672 
  { I960BASE_INSN_CLRBIT3, SEM_FN_NAME (i960base,clrbit3) },
7673 
  { I960BASE_INSN_SHLO, SEM_FN_NAME (i960base,shlo) },
7674 
  { I960BASE_INSN_SHLO1, SEM_FN_NAME (i960base,shlo1) },
7675 
  { I960BASE_INSN_SHLO2, SEM_FN_NAME (i960base,shlo2) },
7676 
  { I960BASE_INSN_SHLO3, SEM_FN_NAME (i960base,shlo3) },
7677 
  { I960BASE_INSN_SHRO, SEM_FN_NAME (i960base,shro) },
7678 
  { I960BASE_INSN_SHRO1, SEM_FN_NAME (i960base,shro1) },
7679 
  { I960BASE_INSN_SHRO2, SEM_FN_NAME (i960base,shro2) },
7680 
  { I960BASE_INSN_SHRO3, SEM_FN_NAME (i960base,shro3) },
7681 
  { I960BASE_INSN_SHLI, SEM_FN_NAME (i960base,shli) },
7682 
  { I960BASE_INSN_SHLI1, SEM_FN_NAME (i960base,shli1) },
7683 
  { I960BASE_INSN_SHLI2, SEM_FN_NAME (i960base,shli2) },
7684 
  { I960BASE_INSN_SHLI3, SEM_FN_NAME (i960base,shli3) },
7685 
  { I960BASE_INSN_SHRI, SEM_FN_NAME (i960base,shri) },
7686 
  { I960BASE_INSN_SHRI1, SEM_FN_NAME (i960base,shri1) },
7687 
  { I960BASE_INSN_SHRI2, SEM_FN_NAME (i960base,shri2) },
7688 
  { I960BASE_INSN_SHRI3, SEM_FN_NAME (i960base,shri3) },
7689 
  { I960BASE_INSN_EMUL, SEM_FN_NAME (i960base,emul) },
7690 
  { I960BASE_INSN_EMUL1, SEM_FN_NAME (i960base,emul1) },
7691 
  { I960BASE_INSN_EMUL2, SEM_FN_NAME (i960base,emul2) },
7692 
  { I960BASE_INSN_EMUL3, SEM_FN_NAME (i960base,emul3) },
7693 
  { I960BASE_INSN_MOV, SEM_FN_NAME (i960base,mov) },
7694 
  { I960BASE_INSN_MOV1, SEM_FN_NAME (i960base,mov1) },
7695 
  { I960BASE_INSN_MOVL, SEM_FN_NAME (i960base,movl) },
7696 
  { I960BASE_INSN_MOVL1, SEM_FN_NAME (i960base,movl1) },
7697 
  { I960BASE_INSN_MOVT, SEM_FN_NAME (i960base,movt) },
7698 
  { I960BASE_INSN_MOVT1, SEM_FN_NAME (i960base,movt1) },
7699 
  { I960BASE_INSN_MOVQ, SEM_FN_NAME (i960base,movq) },
7700 
  { I960BASE_INSN_MOVQ1, SEM_FN_NAME (i960base,movq1) },
7701 
  { I960BASE_INSN_MODPC, SEM_FN_NAME (i960base,modpc) },
7702 
  { I960BASE_INSN_MODAC, SEM_FN_NAME (i960base,modac) },
7703 
  { I960BASE_INSN_LDA_OFFSET, SEM_FN_NAME (i960base,lda_offset) },
7704 
  { I960BASE_INSN_LDA_INDIRECT_OFFSET, SEM_FN_NAME (i960base,lda_indirect_offset) },
7705 
  { I960BASE_INSN_LDA_INDIRECT, SEM_FN_NAME (i960base,lda_indirect) },
7706 
  { I960BASE_INSN_LDA_INDIRECT_INDEX, SEM_FN_NAME (i960base,lda_indirect_index) },
7707 
  { I960BASE_INSN_LDA_DISP, SEM_FN_NAME (i960base,lda_disp) },
7708 
  { I960BASE_INSN_LDA_INDIRECT_DISP, SEM_FN_NAME (i960base,lda_indirect_disp) },
7709 
  { I960BASE_INSN_LDA_INDEX_DISP, SEM_FN_NAME (i960base,lda_index_disp) },
7710 
  { I960BASE_INSN_LDA_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,lda_indirect_index_disp) },
7711 
  { I960BASE_INSN_LD_OFFSET, SEM_FN_NAME (i960base,ld_offset) },
7712 
  { I960BASE_INSN_LD_INDIRECT_OFFSET, SEM_FN_NAME (i960base,ld_indirect_offset) },
7713 
  { I960BASE_INSN_LD_INDIRECT, SEM_FN_NAME (i960base,ld_indirect) },
7714 
  { I960BASE_INSN_LD_INDIRECT_INDEX, SEM_FN_NAME (i960base,ld_indirect_index) },
7715 
  { I960BASE_INSN_LD_DISP, SEM_FN_NAME (i960base,ld_disp) },
7716 
  { I960BASE_INSN_LD_INDIRECT_DISP, SEM_FN_NAME (i960base,ld_indirect_disp) },
7717 
  { I960BASE_INSN_LD_INDEX_DISP, SEM_FN_NAME (i960base,ld_index_disp) },
7718 
  { I960BASE_INSN_LD_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,ld_indirect_index_disp) },
7719 
  { I960BASE_INSN_LDOB_OFFSET, SEM_FN_NAME (i960base,ldob_offset) },
7720 
  { I960BASE_INSN_LDOB_INDIRECT_OFFSET, SEM_FN_NAME (i960base,ldob_indirect_offset) },
7721 
  { I960BASE_INSN_LDOB_INDIRECT, SEM_FN_NAME (i960base,ldob_indirect) },
7722 
  { I960BASE_INSN_LDOB_INDIRECT_INDEX, SEM_FN_NAME (i960base,ldob_indirect_index) },
7723 
  { I960BASE_INSN_LDOB_DISP, SEM_FN_NAME (i960base,ldob_disp) },
7724 
  { I960BASE_INSN_LDOB_INDIRECT_DISP, SEM_FN_NAME (i960base,ldob_indirect_disp) },
7725 
  { I960BASE_INSN_LDOB_INDEX_DISP, SEM_FN_NAME (i960base,ldob_index_disp) },
7726 
  { I960BASE_INSN_LDOB_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,ldob_indirect_index_disp) },
7727 
  { I960BASE_INSN_LDOS_OFFSET, SEM_FN_NAME (i960base,ldos_offset) },
7728 
  { I960BASE_INSN_LDOS_INDIRECT_OFFSET, SEM_FN_NAME (i960base,ldos_indirect_offset) },
7729 
  { I960BASE_INSN_LDOS_INDIRECT, SEM_FN_NAME (i960base,ldos_indirect) },
7730 
  { I960BASE_INSN_LDOS_INDIRECT_INDEX, SEM_FN_NAME (i960base,ldos_indirect_index) },
7731 
  { I960BASE_INSN_LDOS_DISP, SEM_FN_NAME (i960base,ldos_disp) },
7732 
  { I960BASE_INSN_LDOS_INDIRECT_DISP, SEM_FN_NAME (i960base,ldos_indirect_disp) },
7733 
  { I960BASE_INSN_LDOS_INDEX_DISP, SEM_FN_NAME (i960base,ldos_index_disp) },
7734 
  { I960BASE_INSN_LDOS_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,ldos_indirect_index_disp) },
7735 
  { I960BASE_INSN_LDIB_OFFSET, SEM_FN_NAME (i960base,ldib_offset) },
7736 
  { I960BASE_INSN_LDIB_INDIRECT_OFFSET, SEM_FN_NAME (i960base,ldib_indirect_offset) },
7737 
  { I960BASE_INSN_LDIB_INDIRECT, SEM_FN_NAME (i960base,ldib_indirect) },
7738 
  { I960BASE_INSN_LDIB_INDIRECT_INDEX, SEM_FN_NAME (i960base,ldib_indirect_index) },
7739 
  { I960BASE_INSN_LDIB_DISP, SEM_FN_NAME (i960base,ldib_disp) },
7740 
  { I960BASE_INSN_LDIB_INDIRECT_DISP, SEM_FN_NAME (i960base,ldib_indirect_disp) },
7741 
  { I960BASE_INSN_LDIB_INDEX_DISP, SEM_FN_NAME (i960base,ldib_index_disp) },
7742 
  { I960BASE_INSN_LDIB_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,ldib_indirect_index_disp) },
7743 
  { I960BASE_INSN_LDIS_OFFSET, SEM_FN_NAME (i960base,ldis_offset) },
7744 
  { I960BASE_INSN_LDIS_INDIRECT_OFFSET, SEM_FN_NAME (i960base,ldis_indirect_offset) },
7745 
  { I960BASE_INSN_LDIS_INDIRECT, SEM_FN_NAME (i960base,ldis_indirect) },
7746 
  { I960BASE_INSN_LDIS_INDIRECT_INDEX, SEM_FN_NAME (i960base,ldis_indirect_index) },
7747 
  { I960BASE_INSN_LDIS_DISP, SEM_FN_NAME (i960base,ldis_disp) },
7748 
  { I960BASE_INSN_LDIS_INDIRECT_DISP, SEM_FN_NAME (i960base,ldis_indirect_disp) },
7749 
  { I960BASE_INSN_LDIS_INDEX_DISP, SEM_FN_NAME (i960base,ldis_index_disp) },
7750 
  { I960BASE_INSN_LDIS_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,ldis_indirect_index_disp) },
7751 
  { I960BASE_INSN_LDL_OFFSET, SEM_FN_NAME (i960base,ldl_offset) },
7752 
  { I960BASE_INSN_LDL_INDIRECT_OFFSET, SEM_FN_NAME (i960base,ldl_indirect_offset) },
7753 
  { I960BASE_INSN_LDL_INDIRECT, SEM_FN_NAME (i960base,ldl_indirect) },
7754 
  { I960BASE_INSN_LDL_INDIRECT_INDEX, SEM_FN_NAME (i960base,ldl_indirect_index) },
7755 
  { I960BASE_INSN_LDL_DISP, SEM_FN_NAME (i960base,ldl_disp) },
7756 
  { I960BASE_INSN_LDL_INDIRECT_DISP, SEM_FN_NAME (i960base,ldl_indirect_disp) },
7757 
  { I960BASE_INSN_LDL_INDEX_DISP, SEM_FN_NAME (i960base,ldl_index_disp) },
7758 
  { I960BASE_INSN_LDL_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,ldl_indirect_index_disp) },
7759 
  { I960BASE_INSN_LDT_OFFSET, SEM_FN_NAME (i960base,ldt_offset) },
7760 
  { I960BASE_INSN_LDT_INDIRECT_OFFSET, SEM_FN_NAME (i960base,ldt_indirect_offset) },
7761 
  { I960BASE_INSN_LDT_INDIRECT, SEM_FN_NAME (i960base,ldt_indirect) },
7762 
  { I960BASE_INSN_LDT_INDIRECT_INDEX, SEM_FN_NAME (i960base,ldt_indirect_index) },
7763 
  { I960BASE_INSN_LDT_DISP, SEM_FN_NAME (i960base,ldt_disp) },
7764 
  { I960BASE_INSN_LDT_INDIRECT_DISP, SEM_FN_NAME (i960base,ldt_indirect_disp) },
7765 
  { I960BASE_INSN_LDT_INDEX_DISP, SEM_FN_NAME (i960base,ldt_index_disp) },
7766 
  { I960BASE_INSN_LDT_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,ldt_indirect_index_disp) },
7767 
  { I960BASE_INSN_LDQ_OFFSET, SEM_FN_NAME (i960base,ldq_offset) },
7768 
  { I960BASE_INSN_LDQ_INDIRECT_OFFSET, SEM_FN_NAME (i960base,ldq_indirect_offset) },
7769 
  { I960BASE_INSN_LDQ_INDIRECT, SEM_FN_NAME (i960base,ldq_indirect) },
7770 
  { I960BASE_INSN_LDQ_INDIRECT_INDEX, SEM_FN_NAME (i960base,ldq_indirect_index) },
7771 
  { I960BASE_INSN_LDQ_DISP, SEM_FN_NAME (i960base,ldq_disp) },
7772 
  { I960BASE_INSN_LDQ_INDIRECT_DISP, SEM_FN_NAME (i960base,ldq_indirect_disp) },
7773 
  { I960BASE_INSN_LDQ_INDEX_DISP, SEM_FN_NAME (i960base,ldq_index_disp) },
7774 
  { I960BASE_INSN_LDQ_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,ldq_indirect_index_disp) },
7775 
  { I960BASE_INSN_ST_OFFSET, SEM_FN_NAME (i960base,st_offset) },
7776 
  { I960BASE_INSN_ST_INDIRECT_OFFSET, SEM_FN_NAME (i960base,st_indirect_offset) },
7777 
  { I960BASE_INSN_ST_INDIRECT, SEM_FN_NAME (i960base,st_indirect) },
7778 
  { I960BASE_INSN_ST_INDIRECT_INDEX, SEM_FN_NAME (i960base,st_indirect_index) },
7779 
  { I960BASE_INSN_ST_DISP, SEM_FN_NAME (i960base,st_disp) },
7780 
  { I960BASE_INSN_ST_INDIRECT_DISP, SEM_FN_NAME (i960base,st_indirect_disp) },
7781 
  { I960BASE_INSN_ST_INDEX_DISP, SEM_FN_NAME (i960base,st_index_disp) },
7782 
  { I960BASE_INSN_ST_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,st_indirect_index_disp) },
7783 
  { I960BASE_INSN_STOB_OFFSET, SEM_FN_NAME (i960base,stob_offset) },
7784 
  { I960BASE_INSN_STOB_INDIRECT_OFFSET, SEM_FN_NAME (i960base,stob_indirect_offset) },
7785 
  { I960BASE_INSN_STOB_INDIRECT, SEM_FN_NAME (i960base,stob_indirect) },
7786 
  { I960BASE_INSN_STOB_INDIRECT_INDEX, SEM_FN_NAME (i960base,stob_indirect_index) },
7787 
  { I960BASE_INSN_STOB_DISP, SEM_FN_NAME (i960base,stob_disp) },
7788 
  { I960BASE_INSN_STOB_INDIRECT_DISP, SEM_FN_NAME (i960base,stob_indirect_disp) },
7789 
  { I960BASE_INSN_STOB_INDEX_DISP, SEM_FN_NAME (i960base,stob_index_disp) },
7790 
  { I960BASE_INSN_STOB_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,stob_indirect_index_disp) },
7791 
  { I960BASE_INSN_STOS_OFFSET, SEM_FN_NAME (i960base,stos_offset) },
7792 
  { I960BASE_INSN_STOS_INDIRECT_OFFSET, SEM_FN_NAME (i960base,stos_indirect_offset) },
7793 
  { I960BASE_INSN_STOS_INDIRECT, SEM_FN_NAME (i960base,stos_indirect) },
7794 
  { I960BASE_INSN_STOS_INDIRECT_INDEX, SEM_FN_NAME (i960base,stos_indirect_index) },
7795 
  { I960BASE_INSN_STOS_DISP, SEM_FN_NAME (i960base,stos_disp) },
7796 
  { I960BASE_INSN_STOS_INDIRECT_DISP, SEM_FN_NAME (i960base,stos_indirect_disp) },
7797 
  { I960BASE_INSN_STOS_INDEX_DISP, SEM_FN_NAME (i960base,stos_index_disp) },
7798 
  { I960BASE_INSN_STOS_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,stos_indirect_index_disp) },
7799 
  { I960BASE_INSN_STL_OFFSET, SEM_FN_NAME (i960base,stl_offset) },
7800 
  { I960BASE_INSN_STL_INDIRECT_OFFSET, SEM_FN_NAME (i960base,stl_indirect_offset) },
7801 
  { I960BASE_INSN_STL_INDIRECT, SEM_FN_NAME (i960base,stl_indirect) },
7802 
  { I960BASE_INSN_STL_INDIRECT_INDEX, SEM_FN_NAME (i960base,stl_indirect_index) },
7803 
  { I960BASE_INSN_STL_DISP, SEM_FN_NAME (i960base,stl_disp) },
7804 
  { I960BASE_INSN_STL_INDIRECT_DISP, SEM_FN_NAME (i960base,stl_indirect_disp) },
7805 
  { I960BASE_INSN_STL_INDEX_DISP, SEM_FN_NAME (i960base,stl_index_disp) },
7806 
  { I960BASE_INSN_STL_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,stl_indirect_index_disp) },
7807 
  { I960BASE_INSN_STT_OFFSET, SEM_FN_NAME (i960base,stt_offset) },
7808 
  { I960BASE_INSN_STT_INDIRECT_OFFSET, SEM_FN_NAME (i960base,stt_indirect_offset) },
7809 
  { I960BASE_INSN_STT_INDIRECT, SEM_FN_NAME (i960base,stt_indirect) },
7810 
  { I960BASE_INSN_STT_INDIRECT_INDEX, SEM_FN_NAME (i960base,stt_indirect_index) },
7811 
  { I960BASE_INSN_STT_DISP, SEM_FN_NAME (i960base,stt_disp) },
7812 
  { I960BASE_INSN_STT_INDIRECT_DISP, SEM_FN_NAME (i960base,stt_indirect_disp) },
7813 
  { I960BASE_INSN_STT_INDEX_DISP, SEM_FN_NAME (i960base,stt_index_disp) },
7814 
  { I960BASE_INSN_STT_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,stt_indirect_index_disp) },
7815 
  { I960BASE_INSN_STQ_OFFSET, SEM_FN_NAME (i960base,stq_offset) },
7816 
  { I960BASE_INSN_STQ_INDIRECT_OFFSET, SEM_FN_NAME (i960base,stq_indirect_offset) },
7817 
  { I960BASE_INSN_STQ_INDIRECT, SEM_FN_NAME (i960base,stq_indirect) },
7818 
  { I960BASE_INSN_STQ_INDIRECT_INDEX, SEM_FN_NAME (i960base,stq_indirect_index) },
7819 
  { I960BASE_INSN_STQ_DISP, SEM_FN_NAME (i960base,stq_disp) },
7820 
  { I960BASE_INSN_STQ_INDIRECT_DISP, SEM_FN_NAME (i960base,stq_indirect_disp) },
7821 
  { I960BASE_INSN_STQ_INDEX_DISP, SEM_FN_NAME (i960base,stq_index_disp) },
7822 
  { I960BASE_INSN_STQ_INDIRECT_INDEX_DISP, SEM_FN_NAME (i960base,stq_indirect_index_disp) },
7823 
  { I960BASE_INSN_CMPOBE_REG, SEM_FN_NAME (i960base,cmpobe_reg) },
7824 
  { I960BASE_INSN_CMPOBE_LIT, SEM_FN_NAME (i960base,cmpobe_lit) },
7825 
  { I960BASE_INSN_CMPOBNE_REG, SEM_FN_NAME (i960base,cmpobne_reg) },
7826 
  { I960BASE_INSN_CMPOBNE_LIT, SEM_FN_NAME (i960base,cmpobne_lit) },
7827 
  { I960BASE_INSN_CMPOBL_REG, SEM_FN_NAME (i960base,cmpobl_reg) },
7828 
  { I960BASE_INSN_CMPOBL_LIT, SEM_FN_NAME (i960base,cmpobl_lit) },
7829 
  { I960BASE_INSN_CMPOBLE_REG, SEM_FN_NAME (i960base,cmpoble_reg) },
7830 
  { I960BASE_INSN_CMPOBLE_LIT, SEM_FN_NAME (i960base,cmpoble_lit) },
7831 
  { I960BASE_INSN_CMPOBG_REG, SEM_FN_NAME (i960base,cmpobg_reg) },
7832 
  { I960BASE_INSN_CMPOBG_LIT, SEM_FN_NAME (i960base,cmpobg_lit) },
7833 
  { I960BASE_INSN_CMPOBGE_REG, SEM_FN_NAME (i960base,cmpobge_reg) },
7834 
  { I960BASE_INSN_CMPOBGE_LIT, SEM_FN_NAME (i960base,cmpobge_lit) },
7835 
  { I960BASE_INSN_CMPIBE_REG, SEM_FN_NAME (i960base,cmpibe_reg) },
7836 
  { I960BASE_INSN_CMPIBE_LIT, SEM_FN_NAME (i960base,cmpibe_lit) },
7837 
  { I960BASE_INSN_CMPIBNE_REG, SEM_FN_NAME (i960base,cmpibne_reg) },
7838 
  { I960BASE_INSN_CMPIBNE_LIT, SEM_FN_NAME (i960base,cmpibne_lit) },
7839 
  { I960BASE_INSN_CMPIBL_REG, SEM_FN_NAME (i960base,cmpibl_reg) },
7840 
  { I960BASE_INSN_CMPIBL_LIT, SEM_FN_NAME (i960base,cmpibl_lit) },
7841 
  { I960BASE_INSN_CMPIBLE_REG, SEM_FN_NAME (i960base,cmpible_reg) },
7842 
  { I960BASE_INSN_CMPIBLE_LIT, SEM_FN_NAME (i960base,cmpible_lit) },
7843 
  { I960BASE_INSN_CMPIBG_REG, SEM_FN_NAME (i960base,cmpibg_reg) },
7844 
  { I960BASE_INSN_CMPIBG_LIT, SEM_FN_NAME (i960base,cmpibg_lit) },
7845 
  { I960BASE_INSN_CMPIBGE_REG, SEM_FN_NAME (i960base,cmpibge_reg) },
7846 
  { I960BASE_INSN_CMPIBGE_LIT, SEM_FN_NAME (i960base,cmpibge_lit) },
7847 
  { I960BASE_INSN_BBC_REG, SEM_FN_NAME (i960base,bbc_reg) },
7848 
  { I960BASE_INSN_BBC_LIT, SEM_FN_NAME (i960base,bbc_lit) },
7849 
  { I960BASE_INSN_BBS_REG, SEM_FN_NAME (i960base,bbs_reg) },
7850 
  { I960BASE_INSN_BBS_LIT, SEM_FN_NAME (i960base,bbs_lit) },
7851 
  { I960BASE_INSN_CMPI, SEM_FN_NAME (i960base,cmpi) },
7852 
  { I960BASE_INSN_CMPI1, SEM_FN_NAME (i960base,cmpi1) },
7853 
  { I960BASE_INSN_CMPI2, SEM_FN_NAME (i960base,cmpi2) },
7854 
  { I960BASE_INSN_CMPI3, SEM_FN_NAME (i960base,cmpi3) },
7855 
  { I960BASE_INSN_CMPO, SEM_FN_NAME (i960base,cmpo) },
7856 
  { I960BASE_INSN_CMPO1, SEM_FN_NAME (i960base,cmpo1) },
7857 
  { I960BASE_INSN_CMPO2, SEM_FN_NAME (i960base,cmpo2) },
7858 
  { I960BASE_INSN_CMPO3, SEM_FN_NAME (i960base,cmpo3) },
7859 
  { I960BASE_INSN_TESTNO_REG, SEM_FN_NAME (i960base,testno_reg) },
7860 
  { I960BASE_INSN_TESTG_REG, SEM_FN_NAME (i960base,testg_reg) },
7861 
  { I960BASE_INSN_TESTE_REG, SEM_FN_NAME (i960base,teste_reg) },
7862 
  { I960BASE_INSN_TESTGE_REG, SEM_FN_NAME (i960base,testge_reg) },
7863 
  { I960BASE_INSN_TESTL_REG, SEM_FN_NAME (i960base,testl_reg) },
7864 
  { I960BASE_INSN_TESTNE_REG, SEM_FN_NAME (i960base,testne_reg) },
7865 
  { I960BASE_INSN_TESTLE_REG, SEM_FN_NAME (i960base,testle_reg) },
7866 
  { I960BASE_INSN_TESTO_REG, SEM_FN_NAME (i960base,testo_reg) },
7867 
  { I960BASE_INSN_BNO, SEM_FN_NAME (i960base,bno) },
7868 
  { I960BASE_INSN_BG, SEM_FN_NAME (i960base,bg) },
7869 
  { I960BASE_INSN_BE, SEM_FN_NAME (i960base,be) },
7870 
  { I960BASE_INSN_BGE, SEM_FN_NAME (i960base,bge) },
7871 
  { I960BASE_INSN_BL, SEM_FN_NAME (i960base,bl) },
7872 
  { I960BASE_INSN_BNE, SEM_FN_NAME (i960base,bne) },
7873 
  { I960BASE_INSN_BLE, SEM_FN_NAME (i960base,ble) },
7874 
  { I960BASE_INSN_BO, SEM_FN_NAME (i960base,bo) },
7875 
  { I960BASE_INSN_B, SEM_FN_NAME (i960base,b) },
7876 
  { I960BASE_INSN_BX_INDIRECT_OFFSET, SEM_FN_NAME (i960base,bx_indirect_offset) },
7877 
  { I960BASE_INSN_BX_INDIRECT, SEM_FN_NAME (i960base,bx_indirect) },
7878 
  { I960BASE_INSN_BX_INDIRECT_INDEX, SEM_FN_NAME (i960base,bx_indirect_index) },
7879 
  { I960BASE_INSN_BX_DISP, SEM_FN_NAME (i960base,bx_disp) },
7880 
  { I960BASE_INSN_BX_INDIRECT_DISP, SEM_FN_NAME (i960base,bx_indirect_disp) },
7881 
  { I960BASE_INSN_CALLX_DISP, SEM_FN_NAME (i960base,callx_disp) },
7882 
  { I960BASE_INSN_CALLX_INDIRECT, SEM_FN_NAME (i960base,callx_indirect) },
7883 
  { I960BASE_INSN_CALLX_INDIRECT_OFFSET, SEM_FN_NAME (i960base,callx_indirect_offset) },
7884 
  { I960BASE_INSN_RET, SEM_FN_NAME (i960base,ret) },
7885 
  { I960BASE_INSN_CALLS, SEM_FN_NAME (i960base,calls) },
7886 
  { I960BASE_INSN_FMARK, SEM_FN_NAME (i960base,fmark) },
7887 
  { I960BASE_INSN_FLUSHREG, SEM_FN_NAME (i960base,flushreg) },
7888 
  { 0, 0 }
7889 
};
7890 
 
7891 
/* Add the semantic fns to IDESC_TABLE.  */
7892 
 
7893 
void
7894 
SEM_FN_NAME (i960base,init_idesc_table) (SIM_CPU *current_cpu)
7895 
{
7896 
  IDESC *idesc_table = CPU_IDESC (current_cpu);
7897 
  const struct sem_fn_desc *sf;
7898 
  int mach_num = MACH_NUM (CPU_MACH (current_cpu));
7899 
 
7900 
  for (sf = &sem_fns[0]; sf->fn != 0; ++sf)
7901 
    {
7902 
      const CGEN_INSN *insn = idesc_table[sf->index].idata;
7903 
      int valid_p = (CGEN_INSN_VIRTUAL_P (insn)
7904 
                     || CGEN_INSN_MACH_HAS_P (insn, mach_num));
7905 
#if FAST_P
7906 
      if (valid_p)
7907 
        idesc_table[sf->index].sem_fast = sf->fn;
7908 
      else
7909 
        idesc_table[sf->index].sem_fast = SEM_FN_NAME (i960base,x_invalid);
7910 
#else
7911 
      if (valid_p)
7912 
        idesc_table[sf->index].sem_full = sf->fn;
7913 
      else
7914 
        idesc_table[sf->index].sem_full = SEM_FN_NAME (i960base,x_invalid);
7915 
#endif
7916 
    }
7917 
}
7918 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.