/[gxemul]/trunk/src/cpus/cpu_sparc_instr.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/src/cpus/cpu_sparc_instr.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 24 by dpavlin, Mon Oct 8 16:19:56 2007 UTC revision 32 by dpavlin, Mon Oct 8 16:20:58 2007 UTC
# Line 25  Line 25 
25   *  SUCH DAMAGE.   *  SUCH DAMAGE.
26   *   *
27   *   *
28   *  $Id: cpu_sparc_instr.c,v 1.18 2006/05/17 20:27:31 debug Exp $   *  $Id: cpu_sparc_instr.c,v 1.25 2006/09/04 15:35:55 debug Exp $
29   *   *
30   *  SPARC instructions.   *  SPARC instructions.
31   *   *
# Line 37  Line 37 
37    
38    
39  /*  /*
40     *  invalid:  For catching bugs.
41     */
42    X(invalid)
43    {
44            fatal("FATAL ERROR: An internal error occured in the SPARC"
45                " dyntrans code. Please contact the author with detailed"
46                " repro steps on how to trigger this bug.\n");
47            exit(1);
48    }
49    
50    
51    /*
52   *  nop:  Do nothing.   *  nop:  Do nothing.
53   */   */
54  X(nop)  X(nop)
# Line 94  X(call_trace) Line 106  X(call_trace)
106    
107    
108  /*  /*
109     *  bl
110     *
111     *  arg[0] = int32_t displacement compared to the start of the current page
112     */
113    X(bl)
114    {
115            MODE_uint_t old_pc = cpu->pc;
116            int n = (cpu->cd.sparc.ccr & SPARC_CCR_N) ? 1 : 0;
117            int v = (cpu->cd.sparc.ccr & SPARC_CCR_V) ? 1 : 0;
118            int cond = n ^ v;
119            cpu->delay_slot = TO_BE_DELAYED;
120            ic[1].f(cpu, ic+1);
121            cpu->n_translated_instrs ++;
122            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
123                    /*  Note: Must be non-delayed when jumping to the new pc:  */
124                    cpu->delay_slot = NOT_DELAYED;
125                    if (cond) {
126                            old_pc &= ~((SPARC_IC_ENTRIES_PER_PAGE - 1)
127                                << SPARC_INSTR_ALIGNMENT_SHIFT);
128                            cpu->pc = old_pc + (int32_t)ic->arg[0];
129                            quick_pc_to_pointers(cpu);
130                    }
131            } else
132                    cpu->delay_slot = NOT_DELAYED;
133    }
134    X(bl_xcc)
135    {
136            MODE_uint_t old_pc = cpu->pc;
137            int n = ((cpu->cd.sparc.ccr >> SPARC_CCR_XCC_SHIFT) & SPARC_CCR_N)? 1:0;
138            int v = ((cpu->cd.sparc.ccr >> SPARC_CCR_XCC_SHIFT) & SPARC_CCR_V)? 1:0;
139            int cond = n ^ v;
140            cpu->delay_slot = TO_BE_DELAYED;
141            ic[1].f(cpu, ic+1);
142            cpu->n_translated_instrs ++;
143            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
144                    /*  Note: Must be non-delayed when jumping to the new pc:  */
145                    cpu->delay_slot = NOT_DELAYED;
146                    if (cond) {
147                            old_pc &= ~((SPARC_IC_ENTRIES_PER_PAGE - 1)
148                                << SPARC_INSTR_ALIGNMENT_SHIFT);
149                            cpu->pc = old_pc + (int32_t)ic->arg[0];
150                            quick_pc_to_pointers(cpu);
151                    }
152            } else
153                    cpu->delay_slot = NOT_DELAYED;
154    }
155    
156    
157    /*
158     *  ble
159     *
160     *  arg[0] = int32_t displacement compared to the start of the current page
161     */
162    X(ble)
163    {
164            MODE_uint_t old_pc = cpu->pc;
165            int n = (cpu->cd.sparc.ccr & SPARC_CCR_N) ? 1 : 0;
166            int v = (cpu->cd.sparc.ccr & SPARC_CCR_V) ? 1 : 0;
167            int z = (cpu->cd.sparc.ccr & SPARC_CCR_Z) ? 1 : 0;
168            int cond = (n ^ v) || z;
169            cpu->delay_slot = TO_BE_DELAYED;
170            ic[1].f(cpu, ic+1);
171            cpu->n_translated_instrs ++;
172            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
173                    /*  Note: Must be non-delayed when jumping to the new pc:  */
174                    cpu->delay_slot = NOT_DELAYED;
175                    if (cond) {
176                            old_pc &= ~((SPARC_IC_ENTRIES_PER_PAGE - 1)
177                                << SPARC_INSTR_ALIGNMENT_SHIFT);
178                            cpu->pc = old_pc + (int32_t)ic->arg[0];
179                            quick_pc_to_pointers(cpu);
180                    }
181            } else
182                    cpu->delay_slot = NOT_DELAYED;
183    }
184    X(ble_xcc)
185    {
186            MODE_uint_t old_pc = cpu->pc;
187            int n = ((cpu->cd.sparc.ccr >> SPARC_CCR_XCC_SHIFT) & SPARC_CCR_N)? 1:0;
188            int v = ((cpu->cd.sparc.ccr >> SPARC_CCR_XCC_SHIFT) & SPARC_CCR_V)? 1:0;
189            int z = ((cpu->cd.sparc.ccr >> SPARC_CCR_XCC_SHIFT) & SPARC_CCR_Z)? 1:0;
190            int cond = (n ^ v) || z;
191            cpu->delay_slot = TO_BE_DELAYED;
192            ic[1].f(cpu, ic+1);
193            cpu->n_translated_instrs ++;
194            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
195                    /*  Note: Must be non-delayed when jumping to the new pc:  */
196                    cpu->delay_slot = NOT_DELAYED;
197                    if (cond) {
198                            old_pc &= ~((SPARC_IC_ENTRIES_PER_PAGE - 1)
199                                << SPARC_INSTR_ALIGNMENT_SHIFT);
200                            cpu->pc = old_pc + (int32_t)ic->arg[0];
201                            quick_pc_to_pointers(cpu);
202                    }
203            } else
204                    cpu->delay_slot = NOT_DELAYED;
205    }
206    
207    
208    /*
209     *  bne
210     *
211     *  arg[0] = int32_t displacement compared to the start of the current page
212     */
213    X(bne)
214    {
215            MODE_uint_t old_pc = cpu->pc;
216            int cond = (cpu->cd.sparc.ccr & SPARC_CCR_Z) ? 0 : 1;
217            cpu->delay_slot = TO_BE_DELAYED;
218            ic[1].f(cpu, ic+1);
219            cpu->n_translated_instrs ++;
220            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
221                    /*  Note: Must be non-delayed when jumping to the new pc:  */
222                    cpu->delay_slot = NOT_DELAYED;
223                    if (cond) {
224                            old_pc &= ~((SPARC_IC_ENTRIES_PER_PAGE - 1)
225                                << SPARC_INSTR_ALIGNMENT_SHIFT);
226                            cpu->pc = old_pc + (int32_t)ic->arg[0];
227                            quick_pc_to_pointers(cpu);
228                    }
229            } else
230                    cpu->delay_slot = NOT_DELAYED;
231    }
232    X(bne_a)
233    {
234            MODE_uint_t old_pc = cpu->pc;
235            int cond = (cpu->cd.sparc.ccr & SPARC_CCR_Z) ? 0 : 1;
236            cpu->delay_slot = TO_BE_DELAYED;
237            if (!cond) {
238                    /*  Nullify the delay slot:  */
239                    cpu->cd.sparc.next_ic ++;
240                    return;
241            }
242            ic[1].f(cpu, ic+1);
243            cpu->n_translated_instrs ++;
244            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
245                    /*  Note: Must be non-delayed when jumping to the new pc:  */
246                    cpu->delay_slot = NOT_DELAYED;
247                    old_pc &= ~((SPARC_IC_ENTRIES_PER_PAGE - 1)
248                        << SPARC_INSTR_ALIGNMENT_SHIFT);
249                    cpu->pc = old_pc + (int32_t)ic->arg[0];
250                    quick_pc_to_pointers(cpu);
251            } else
252                    cpu->delay_slot = NOT_DELAYED;
253    }
254    
255    
256    /*
257     *  bg
258     *
259     *  arg[0] = int32_t displacement compared to the start of the current page
260     */
261    X(bg)
262    {
263            MODE_uint_t old_pc = cpu->pc;
264            int n = (cpu->cd.sparc.ccr & SPARC_CCR_N) ? 1 : 0;
265            int v = (cpu->cd.sparc.ccr & SPARC_CCR_V) ? 1 : 0;
266            int z = (cpu->cd.sparc.ccr & SPARC_CCR_Z) ? 1 : 0;
267            int cond = !(z | (n ^ v));
268            cpu->delay_slot = TO_BE_DELAYED;
269            ic[1].f(cpu, ic+1);
270            cpu->n_translated_instrs ++;
271            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
272                    /*  Note: Must be non-delayed when jumping to the new pc:  */
273                    cpu->delay_slot = NOT_DELAYED;
274                    if (cond) {
275                            old_pc &= ~((SPARC_IC_ENTRIES_PER_PAGE - 1)
276                                << SPARC_INSTR_ALIGNMENT_SHIFT);
277                            cpu->pc = old_pc + (int32_t)ic->arg[0];
278                            quick_pc_to_pointers(cpu);
279                    }
280            } else
281                    cpu->delay_slot = NOT_DELAYED;
282    }
283    X(bg_xcc)
284    {
285            MODE_uint_t old_pc = cpu->pc;
286            int n = ((cpu->cd.sparc.ccr >> SPARC_CCR_XCC_SHIFT) & SPARC_CCR_N)? 1:0;
287            int v = ((cpu->cd.sparc.ccr >> SPARC_CCR_XCC_SHIFT) & SPARC_CCR_V)? 1:0;
288            int z = ((cpu->cd.sparc.ccr >> SPARC_CCR_XCC_SHIFT) & SPARC_CCR_Z)? 1:0;
289            int cond = !(z | (n ^ v));
290            cpu->delay_slot = TO_BE_DELAYED;
291            ic[1].f(cpu, ic+1);
292            cpu->n_translated_instrs ++;
293            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
294                    /*  Note: Must be non-delayed when jumping to the new pc:  */
295                    cpu->delay_slot = NOT_DELAYED;
296                    if (cond) {
297                            old_pc &= ~((SPARC_IC_ENTRIES_PER_PAGE - 1)
298                                << SPARC_INSTR_ALIGNMENT_SHIFT);
299                            cpu->pc = old_pc + (int32_t)ic->arg[0];
300                            quick_pc_to_pointers(cpu);
301                    }
302            } else
303                    cpu->delay_slot = NOT_DELAYED;
304    }
305    
306    
307    /*
308     *  bge
309     *
310     *  arg[0] = int32_t displacement compared to the start of the current page
311     */
312    X(bge)
313    {
314            MODE_uint_t old_pc = cpu->pc;
315            int n = (cpu->cd.sparc.ccr & SPARC_CCR_N) ? 1 : 0;
316            int v = (cpu->cd.sparc.ccr & SPARC_CCR_V) ? 1 : 0;
317            int cond = !(n ^ v);
318            cpu->delay_slot = TO_BE_DELAYED;
319            ic[1].f(cpu, ic+1);
320            cpu->n_translated_instrs ++;
321            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
322                    /*  Note: Must be non-delayed when jumping to the new pc:  */
323                    cpu->delay_slot = NOT_DELAYED;
324                    if (cond) {
325                            old_pc &= ~((SPARC_IC_ENTRIES_PER_PAGE - 1)
326                                << SPARC_INSTR_ALIGNMENT_SHIFT);
327                            cpu->pc = old_pc + (int32_t)ic->arg[0];
328                            quick_pc_to_pointers(cpu);
329                    }
330            } else
331                    cpu->delay_slot = NOT_DELAYED;
332    }
333    X(bge_xcc)
334    {
335            MODE_uint_t old_pc = cpu->pc;
336            int n = ((cpu->cd.sparc.ccr >> SPARC_CCR_XCC_SHIFT) & SPARC_CCR_N)? 1:0;
337            int v = ((cpu->cd.sparc.ccr >> SPARC_CCR_XCC_SHIFT) & SPARC_CCR_V)? 1:0;
338            int cond = !(n ^ v);
339            cpu->delay_slot = TO_BE_DELAYED;
340            ic[1].f(cpu, ic+1);
341            cpu->n_translated_instrs ++;
342            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
343                    /*  Note: Must be non-delayed when jumping to the new pc:  */
344                    cpu->delay_slot = NOT_DELAYED;
345                    if (cond) {
346                            old_pc &= ~((SPARC_IC_ENTRIES_PER_PAGE - 1)
347                                << SPARC_INSTR_ALIGNMENT_SHIFT);
348                            cpu->pc = old_pc + (int32_t)ic->arg[0];
349                            quick_pc_to_pointers(cpu);
350                    }
351            } else
352                    cpu->delay_slot = NOT_DELAYED;
353    }
354    
355    
356    /*
357     *  be
358     *
359     *  arg[0] = int32_t displacement compared to the start of the current page
360     */
361    X(be)
362    {
363            MODE_uint_t old_pc = cpu->pc;
364            int cond = cpu->cd.sparc.ccr & SPARC_CCR_Z;
365            cpu->delay_slot = TO_BE_DELAYED;
366            ic[1].f(cpu, ic+1);
367            cpu->n_translated_instrs ++;
368            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
369                    /*  Note: Must be non-delayed when jumping to the new pc:  */
370                    cpu->delay_slot = NOT_DELAYED;
371                    if (cond) {
372                            old_pc &= ~((SPARC_IC_ENTRIES_PER_PAGE - 1)
373                                << SPARC_INSTR_ALIGNMENT_SHIFT);
374                            cpu->pc = old_pc + (int32_t)ic->arg[0];
375                            quick_pc_to_pointers(cpu);
376                    }
377            } else
378                    cpu->delay_slot = NOT_DELAYED;
379    }
380    X(be_xcc)
381    {
382            MODE_uint_t old_pc = cpu->pc;
383            int cond = (cpu->cd.sparc.ccr >> SPARC_CCR_XCC_SHIFT) & SPARC_CCR_Z;
384            cpu->delay_slot = TO_BE_DELAYED;
385            ic[1].f(cpu, ic+1);
386            cpu->n_translated_instrs ++;
387            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
388                    /*  Note: Must be non-delayed when jumping to the new pc:  */
389                    cpu->delay_slot = NOT_DELAYED;
390                    if (cond) {
391                            old_pc &= ~((SPARC_IC_ENTRIES_PER_PAGE - 1)
392                                << SPARC_INSTR_ALIGNMENT_SHIFT);
393                            cpu->pc = old_pc + (int32_t)ic->arg[0];
394                            quick_pc_to_pointers(cpu);
395                    }
396            } else
397                    cpu->delay_slot = NOT_DELAYED;
398    }
399    
400    
401    /*
402   *  ba   *  ba
403   *   *
404   *  arg[0] = int32_t displacement compared to the start of the current page   *  arg[0] = int32_t displacement compared to the start of the current page
# Line 117  X(ba) Line 422  X(ba)
422    
423    
424  /*  /*
425     *  brnz
426     *
427     *  arg[0] = int32_t displacement compared to the start of the current page
428     *  arg[1] = ptr to rs1
429     */
430    X(brnz)
431    {
432            MODE_uint_t old_pc = cpu->pc;
433            int cond = reg(ic->arg[1]) != 0;
434            cpu->delay_slot = TO_BE_DELAYED;
435            ic[1].f(cpu, ic+1);
436            cpu->n_translated_instrs ++;
437            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
438                    /*  Note: Must be non-delayed when jumping to the new pc:  */
439                    cpu->delay_slot = NOT_DELAYED;
440                    if (cond) {
441                            old_pc &= ~((SPARC_IC_ENTRIES_PER_PAGE - 1)
442                                << SPARC_INSTR_ALIGNMENT_SHIFT);
443                            cpu->pc = old_pc + (int32_t)ic->arg[0];
444                            quick_pc_to_pointers(cpu);
445                    }
446            } else
447                    cpu->delay_slot = NOT_DELAYED;
448    }
449    
450    
451    /*
452     *  Save:
453     *
454     *  arg[0] = ptr to rs1
455     *  arg[1] = ptr to rs2 or an immediate value (int32_t)
456     *  arg[2] = ptr to rd (_after_ the register window change)
457     */
458    X(save_v9_imm)
459    {
460            MODE_uint_t rs = reg(ic->arg[0]) + (int32_t)ic->arg[1];
461            int cwp = cpu->cd.sparc.cwp;
462    
463            if (cpu->cd.sparc.cansave == 0) {
464                    fatal("save_v9_imm: spill trap. TODO\n");
465                    exit(1);
466            }
467    
468            if (cpu->cd.sparc.cleanwin - cpu->cd.sparc.canrestore == 0) {
469                    fatal("save_v9_imm: clean_window trap. TODO\n");
470                    exit(1);
471            }
472    
473            /*  Save away old in registers:  */
474            memcpy(&cpu->cd.sparc.r_inout[cwp][0], &cpu->cd.sparc.r[SPARC_REG_I0],
475                sizeof(cpu->cd.sparc.r[SPARC_REG_I0]) * N_SPARC_INOUT_REG);
476    
477            /*  Save away old local registers:  */
478            memcpy(&cpu->cd.sparc.r_local[cwp][0], &cpu->cd.sparc.r[SPARC_REG_L0],
479                sizeof(cpu->cd.sparc.r[SPARC_REG_L0]) * N_SPARC_INOUT_REG);
480    
481            cpu->cd.sparc.cwp = (cwp + 1) % cpu->cd.sparc.cpu_type.nwindows;
482            cpu->cd.sparc.cansave --;
483            cpu->cd.sparc.canrestore ++;    /*  TODO: modulo here too?  */
484            cwp = cpu->cd.sparc.cwp;
485    
486            /*  The out registers become the new in registers:  */
487            memcpy(&cpu->cd.sparc.r[SPARC_REG_I0], &cpu->cd.sparc.r[SPARC_REG_O0],
488                sizeof(cpu->cd.sparc.r[SPARC_REG_O0]) * N_SPARC_INOUT_REG);
489    
490            /*  Read new local registers:  */
491            memcpy(&cpu->cd.sparc.r[SPARC_REG_L0], &cpu->cd.sparc.r_local[cwp][0],
492                sizeof(cpu->cd.sparc.r[SPARC_REG_L0]) * N_SPARC_INOUT_REG);
493    
494            reg(ic->arg[2]) = rs;
495    }
496    
497    
498    /*
499     *  Restore:
500     */
501    X(restore)
502    {
503            int cwp = cpu->cd.sparc.cwp;
504    
505            if (cpu->cd.sparc.canrestore == 0) {
506                    fatal("restore: spill trap. TODO\n");
507                    exit(1);
508            }
509    
510            cpu->cd.sparc.cwp = cwp - 1;
511            if (cwp == 0)
512                    cpu->cd.sparc.cwp = cpu->cd.sparc.cpu_type.nwindows - 1;
513            cpu->cd.sparc.cansave ++;
514            cpu->cd.sparc.canrestore --;
515            cwp = cpu->cd.sparc.cwp;
516    
517            /*  The in registers become the new out registers:  */
518            memcpy(&cpu->cd.sparc.r[SPARC_REG_O0], &cpu->cd.sparc.r[SPARC_REG_I0],
519                sizeof(cpu->cd.sparc.r[SPARC_REG_O0]) * N_SPARC_INOUT_REG);
520    
521            /*  Read back the local registers:  */
522            memcpy(&cpu->cd.sparc.r[SPARC_REG_L0], &cpu->cd.sparc.r_local[cwp][0],
523                sizeof(cpu->cd.sparc.r[SPARC_REG_L0]) * N_SPARC_INOUT_REG);
524    
525            /*  Read back the in registers:  */
526            memcpy(&cpu->cd.sparc.r[SPARC_REG_I0], &cpu->cd.sparc.r_inout[cwp][0],
527                sizeof(cpu->cd.sparc.r[SPARC_REG_I0]) * N_SPARC_INOUT_REG);
528    }
529    
530    
531    /*
532   *  Jump and link   *  Jump and link
533   *   *
534   *  arg[0] = ptr to rs1   *  arg[0] = ptr to rs1
# Line 275  X(retl_trace) Line 687  X(retl_trace)
687    
688    
689  /*  /*
690     *  Return
691     *
692     *  arg[0] = ptr to rs1
693     *  arg[1] = ptr to rs2 or an immediate value (int32_t)
694     */
695    X(return_imm)
696    {
697            int low_pc = ((size_t)ic - (size_t)cpu->cd.sparc.cur_ic_page)
698                / sizeof(struct sparc_instr_call);
699            cpu->pc &= ~((SPARC_IC_ENTRIES_PER_PAGE-1)
700                << SPARC_INSTR_ALIGNMENT_SHIFT);
701            cpu->pc += (low_pc << SPARC_INSTR_ALIGNMENT_SHIFT);
702    
703            cpu->delay_slot = TO_BE_DELAYED;
704            ic[1].f(cpu, ic+1);
705            cpu->n_translated_instrs ++;
706    
707            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
708                    /*  Note: Must be non-delayed when jumping to the new pc:  */
709                    cpu->delay_slot = NOT_DELAYED;
710                    cpu->pc = reg(ic->arg[0]) + (int32_t)ic->arg[1];
711                    quick_pc_to_pointers(cpu);
712                    instr(restore)(cpu, ic);
713            } else
714                    cpu->delay_slot = NOT_DELAYED;
715    }
716    X(return_reg)
717    {
718            int low_pc = ((size_t)ic - (size_t)cpu->cd.sparc.cur_ic_page)
719                / sizeof(struct sparc_instr_call);
720            cpu->pc &= ~((SPARC_IC_ENTRIES_PER_PAGE-1)
721                << SPARC_INSTR_ALIGNMENT_SHIFT);
722            cpu->pc += (low_pc << SPARC_INSTR_ALIGNMENT_SHIFT);
723    
724            cpu->delay_slot = TO_BE_DELAYED;
725            ic[1].f(cpu, ic+1);
726            cpu->n_translated_instrs ++;
727    
728            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
729                    /*  Note: Must be non-delayed when jumping to the new pc:  */
730                    cpu->delay_slot = NOT_DELAYED;
731                    cpu->pc = reg(ic->arg[0]) + reg(ic->arg[1]);
732                    quick_pc_to_pointers(cpu);
733                    instr(restore)(cpu, ic);
734            } else
735                    cpu->delay_slot = NOT_DELAYED;
736    }
737    X(return_imm_trace)
738    {
739            int low_pc = ((size_t)ic - (size_t)cpu->cd.sparc.cur_ic_page)
740                / sizeof(struct sparc_instr_call);
741            cpu->pc &= ~((SPARC_IC_ENTRIES_PER_PAGE-1)
742                << SPARC_INSTR_ALIGNMENT_SHIFT);
743            cpu->pc += (low_pc << SPARC_INSTR_ALIGNMENT_SHIFT);
744    
745            cpu->delay_slot = TO_BE_DELAYED;
746            ic[1].f(cpu, ic+1);
747            cpu->n_translated_instrs ++;
748    
749            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
750                    /*  Note: Must be non-delayed when jumping to the new pc:  */
751                    cpu->delay_slot = NOT_DELAYED;
752                    cpu->pc = reg(ic->arg[0]) + (int32_t)ic->arg[1];
753                    cpu_functioncall_trace(cpu, cpu->pc);
754                    quick_pc_to_pointers(cpu);
755                    instr(restore)(cpu, ic);
756            } else
757                    cpu->delay_slot = NOT_DELAYED;
758    }
759    X(return_reg_trace)
760    {
761            int low_pc = ((size_t)ic - (size_t)cpu->cd.sparc.cur_ic_page)
762                / sizeof(struct sparc_instr_call);
763            cpu->pc &= ~((SPARC_IC_ENTRIES_PER_PAGE-1)
764                << SPARC_INSTR_ALIGNMENT_SHIFT);
765            cpu->pc += (low_pc << SPARC_INSTR_ALIGNMENT_SHIFT);
766    
767            cpu->delay_slot = TO_BE_DELAYED;
768            ic[1].f(cpu, ic+1);
769            cpu->n_translated_instrs ++;
770    
771            if (!(cpu->delay_slot & EXCEPTION_IN_DELAY_SLOT)) {
772                    /*  Note: Must be non-delayed when jumping to the new pc:  */
773                    cpu->delay_slot = NOT_DELAYED;
774                    cpu->pc = reg(ic->arg[0]) + reg(ic->arg[1]);
775                    cpu_functioncall_trace(cpu, cpu->pc);
776                    quick_pc_to_pointers(cpu);
777                    instr(restore)(cpu, ic);
778            } else
779                    cpu->delay_slot = NOT_DELAYED;
780    }
781    
782    
783    /*
784   *  set:  Set a register to a value (e.g. sethi).   *  set:  Set a register to a value (e.g. sethi).
785   *   *
786   *  arg[0] = ptr to rd   *  arg[0] = ptr to rd
# Line 297  X(add)      { reg(ic->arg[2]) = reg(ic-> Line 803  X(add)      { reg(ic->arg[2]) = reg(ic->
803  X(add_imm)  { reg(ic->arg[2]) = reg(ic->arg[0]) + (int32_t)ic->arg[1]; }  X(add_imm)  { reg(ic->arg[2]) = reg(ic->arg[0]) + (int32_t)ic->arg[1]; }
804  X(and)      { reg(ic->arg[2]) = reg(ic->arg[0]) & reg(ic->arg[1]); }  X(and)      { reg(ic->arg[2]) = reg(ic->arg[0]) & reg(ic->arg[1]); }
805  X(and_imm)  { reg(ic->arg[2]) = reg(ic->arg[0]) & (int32_t)ic->arg[1]; }  X(and_imm)  { reg(ic->arg[2]) = reg(ic->arg[0]) & (int32_t)ic->arg[1]; }
806    X(andn)     { reg(ic->arg[2]) = reg(ic->arg[0]) & ~reg(ic->arg[1]); }
807    X(andn_imm) { reg(ic->arg[2]) = reg(ic->arg[0]) & ~(int32_t)ic->arg[1]; }
808  X(or)       { reg(ic->arg[2]) = reg(ic->arg[0]) | reg(ic->arg[1]); }  X(or)       { reg(ic->arg[2]) = reg(ic->arg[0]) | reg(ic->arg[1]); }
809  X(or_imm)   { reg(ic->arg[2]) = reg(ic->arg[0]) | (int32_t)ic->arg[1]; }  X(or_imm)   { reg(ic->arg[2]) = reg(ic->arg[0]) | (int32_t)ic->arg[1]; }
810  X(xor)      { reg(ic->arg[2]) = reg(ic->arg[0]) ^ reg(ic->arg[1]); }  X(xor)      { reg(ic->arg[2]) = reg(ic->arg[0]) ^ reg(ic->arg[1]); }
# Line 325  X(srax)     { reg(ic->arg[2]) = (int64_t Line 833  X(srax)     { reg(ic->arg[2]) = (int64_t
833  X(sra_imm)  { reg(ic->arg[2]) = (int32_t)reg(ic->arg[0]) >> ic->arg[1]; }  X(sra_imm)  { reg(ic->arg[2]) = (int32_t)reg(ic->arg[0]) >> ic->arg[1]; }
834  X(srax_imm) { reg(ic->arg[2]) = (int64_t)reg(ic->arg[0]) >> ic->arg[1]; }  X(srax_imm) { reg(ic->arg[2]) = (int64_t)reg(ic->arg[0]) >> ic->arg[1]; }
835    
836    X(udiv)
837    {
838            uint64_t z = (cpu->cd.sparc.y << 32) | (uint32_t)reg(ic->arg[0]);
839            z /= (uint32_t)reg(ic->arg[1]);
840            if (z > 0xffffffff)
841                    z = 0xffffffff;
842            reg(ic->arg[2]) = z;
843    }
844    X(udiv_imm)
845    {
846            uint64_t z = (cpu->cd.sparc.y << 32) | (uint32_t)reg(ic->arg[0]);
847            z /= (uint32_t)ic->arg[1];
848            if (z > 0xffffffff)
849                    z = 0xffffffff;
850            reg(ic->arg[2]) = z;
851    }
852    
853    
854    /*
855     *  Add with ccr update:
856     *
857     *  arg[0] = ptr to rs1
858     *  arg[1] = ptr to rs2 or an immediate value (int32_t)
859     *  arg[2] = ptr to rd
860     */
861    int32_t sparc_addcc32(struct cpu *cpu, int32_t rs1, int32_t rs2);
862    #ifdef MODE32
863    int32_t sparc_addcc32(struct cpu *cpu, int32_t rs1, int32_t rs2)
864    #else
865    int64_t sparc_addcc64(struct cpu *cpu, int64_t rs1, int64_t rs2)
866    #endif
867    {
868            int cc = 0, sign1 = 0, sign2 = 0, signd = 0, mask = SPARC_CCR_ICC_MASK;
869            MODE_int_t rd = rs1 + rs2;
870            if (rd == 0)
871                    cc = SPARC_CCR_Z;
872            else if (rd < 0)
873                    cc = SPARC_CCR_N, signd = 1;
874            if (rs1 < 0)
875                    sign1 = 1;
876            if (rs2 < 0)
877                    sign2 = 1;
878            if (sign1 == sign2 && sign1 != signd)
879                    cc |= SPARC_CCR_V;
880            /*  TODO: SPARC_CCR_C  */
881    #ifndef MODE32
882            mask <<= SPARC_CCR_XCC_SHIFT;
883            cc <<= SPARC_CCR_XCC_SHIFT;
884    #endif
885            cpu->cd.sparc.ccr &= ~mask;
886            cpu->cd.sparc.ccr |= cc;
887            return rd;
888    }
889    X(addcc)
890    {
891            /*  Like add, but updates the ccr, and does both 32-bit and
892                64-bit comparison at the same time.  */
893            MODE_int_t rs1 = reg(ic->arg[0]), rs2 = reg(ic->arg[1]), rd;
894            rd = sparc_addcc32(cpu, rs1, rs2);
895    #ifndef MODE32
896            rd = sparc_addcc64(cpu, rs1, rs2);
897    #endif
898            reg(ic->arg[2]) = rd;
899    }
900    X(addcc_imm)
901    {
902            MODE_int_t rs1 = reg(ic->arg[0]), rs2 = (int32_t)ic->arg[1], rd;
903            rd = sparc_addcc32(cpu, rs1, rs2);
904    #ifndef MODE32
905            rd = sparc_addcc64(cpu, rs1, rs2);
906    #endif
907            reg(ic->arg[2]) = rd;
908    }
909    
910    
911    /*
912     *  And with ccr update:
913     *
914     *  arg[0] = ptr to rs1
915     *  arg[1] = ptr to rs2 or an immediate value (int32_t)
916     *  arg[2] = ptr to rd
917     */
918    int32_t sparc_andcc32(struct cpu *cpu, int32_t rs1, int32_t rs2);
919    #ifdef MODE32
920    int32_t sparc_andcc32(struct cpu *cpu, int32_t rs1, int32_t rs2)
921    #else
922    int64_t sparc_andcc64(struct cpu *cpu, int64_t rs1, int64_t rs2)
923    #endif
924    {
925            int cc = 0, mask = SPARC_CCR_ICC_MASK;
926            MODE_int_t rd = rs1 & rs2;
927            if (rd == 0)
928                    cc = SPARC_CCR_Z;
929            else if (rd < 0)
930                    cc = SPARC_CCR_N;
931            /*  Note: SPARC_CCR_C and SPARC_CCR_V are always zero.  */
932    #ifndef MODE32
933            mask <<= SPARC_CCR_XCC_SHIFT;
934            cc <<= SPARC_CCR_XCC_SHIFT;
935    #endif
936            cpu->cd.sparc.ccr &= ~mask;
937            cpu->cd.sparc.ccr |= cc;
938            return rd;
939    }
940    X(andcc)
941    {
942            /*  Like and, but updates the ccr, and does both 32-bit and
943                64-bit comparison at the same time.  */
944            MODE_int_t rs1 = reg(ic->arg[0]), rs2 = reg(ic->arg[1]), rd;
945            rd = sparc_andcc32(cpu, rs1, rs2);
946    #ifndef MODE32
947            rd = sparc_andcc64(cpu, rs1, rs2);
948    #endif
949            reg(ic->arg[2]) = rd;
950    }
951    X(andcc_imm)
952    {
953            MODE_int_t rs1 = reg(ic->arg[0]), rs2 = (int32_t)ic->arg[1], rd;
954            rd = sparc_andcc32(cpu, rs1, rs2);
955    #ifndef MODE32
956            rd = sparc_andcc64(cpu, rs1, rs2);
957    #endif
958            reg(ic->arg[2]) = rd;
959    }
960    
961    
962  /*  /*
963   *  Subtract with ccr update:   *  Subtract with ccr update:
# Line 383  X(subcc_imm) Line 1016  X(subcc_imm)
1016  }  }
1017    
1018    
1019    #include "tmp_sparc_loadstore.c"
1020    
1021    
1022  /*  /*
1023   *  rd:  Read special register:   *  rd:  Read special register
1024   *   *
1025   *  arg[2] = ptr to rd   *  arg[2] = ptr to rd
1026   */   */
# Line 395  X(rd_psr) Line 1031  X(rd_psr)
1031    
1032    
1033  /*  /*
1034     *  rdpr:  Read privileged register
1035     *
1036     *  arg[2] = ptr to rd
1037     */
1038    X(rdpr_tba)
1039    {
1040            reg(ic->arg[2]) = cpu->cd.sparc.tba;
1041    }
1042    X(rdpr_ver)
1043    {
1044            reg(ic->arg[2]) = cpu->cd.sparc.ver;
1045    }
1046    
1047    
1048    /*
1049   *  wrpr:  Write to privileged register   *  wrpr:  Write to privileged register
1050   *   *
1051   *  arg[0] = ptr to rs1   *  arg[0] = ptr to rs1
# Line 483  X(end_of_page2) Line 1134  X(end_of_page2)
1134  X(to_be_translated)  X(to_be_translated)
1135  {  {
1136          MODE_uint_t addr;          MODE_uint_t addr;
1137          int low_pc;          int low_pc, in_crosspage_delayslot = 0;
         int in_crosspage_delayslot = 0;  
1138          uint32_t iword;          uint32_t iword;
1139          unsigned char *page;          unsigned char *page;
1140          unsigned char ib[4];          unsigned char ib[4];
1141          int main_opcode, op2, rd, rs1, rs2, btype, asi, cc, p, use_imm, x64 = 0;          int main_opcode, op2, rd, rs1, rs2, btype, asi, cc, p, use_imm, x64 = 0;
1142            int store, signedness, size;
1143          int32_t tmpi32, siconst;          int32_t tmpi32, siconst;
1144          /* void (*samepage_function)(struct cpu *, struct sparc_instr_call *);*/          /* void (*samepage_function)(struct cpu *, struct sparc_instr_call *);*/
1145    
# Line 570  X(to_be_translated) Line 1221  X(to_be_translated)
1221    
1222          case 0: switch (op2) {          case 0: switch (op2) {
1223    
1224                    case 1: /*  branch (icc or xcc)  */
1225                            tmpi32 = (iword << 13);
1226                            tmpi32 >>= 11;
1227                            ic->arg[0] = (int32_t)tmpi32 + (addr & 0xffc);
1228                            /*  rd contains the annul bit concatenated with 4 bits
1229                                of condition code. cc=0 for icc, 2 for xcc:  */
1230                            /*  TODO: samepage  */
1231                            switch (rd + (cc << 5)) {
1232                            case 0x01:      ic->f = instr(be);  break;
1233                            case 0x02:      ic->f = instr(ble); break;
1234                            case 0x03:      ic->f = instr(bl);  break;
1235                            case 0x08:      ic->f = instr(ba);  break;
1236                            case 0x09:      ic->f = instr(bne); break;
1237                            case 0x0a:      ic->f = instr(bg);  break;
1238                            case 0x0b:      ic->f = instr(bge); break;
1239                            case 0x19:      ic->f = instr(bne_a);  break;
1240                            case 0x41:      ic->f = instr(be_xcc); break;
1241                            case 0x42:      ic->f = instr(ble_xcc);break;
1242                            case 0x43:      ic->f = instr(bl_xcc); break;
1243                            case 0x48:      ic->f = instr(ba);     break;
1244                            case 0x4a:      ic->f = instr(bg_xcc); break;
1245                            case 0x4b:      ic->f = instr(bge_xcc);break;
1246                            default:fatal("Unimplemented branch, 0x%x\n",
1247                                        rd + (cc<<5));
1248                                    goto bad;
1249                            }
1250                            break;
1251    
1252                  case 2: /*  branch (32-bit integer comparison)  */                  case 2: /*  branch (32-bit integer comparison)  */
1253                          tmpi32 = (iword << 10);                          tmpi32 = (iword << 10);
1254                          tmpi32 >>= 8;                          tmpi32 >>= 8;
# Line 578  X(to_be_translated) Line 1257  X(to_be_translated)
1257                              of condition code:  */                              of condition code:  */
1258                          /*  TODO: samepage  */                          /*  TODO: samepage  */
1259                          switch (rd) {                          switch (rd) {
1260                          case 0x08:/*  ba  */                          case 0x01:      ic->f = instr(be);  break;
1261                                  ic->f = instr(ba);                          case 0x03:      ic->f = instr(bl);  break;
1262                                  break;                          case 0x08:      ic->f = instr(ba);  break;
1263                          default:goto bad;                          case 0x09:      ic->f = instr(bne); break;
1264                            case 0x0b:      ic->f = instr(bge); break;
1265                            default:fatal("Unimplemented branch rd=%i\n", rd);
1266                                    goto bad;
1267                            }
1268                            break;
1269    
1270                    case 3: /*  branch on register, 64-bit integer comparison  */
1271                            tmpi32 = ((iword & 0x300000) >> 6) | (iword & 0x3fff);
1272                            tmpi32 <<= 16;
1273                            tmpi32 >>= 14;
1274                            ic->arg[0] = (int32_t)tmpi32 + (addr & 0xffc);
1275                            ic->arg[1] = (size_t)&cpu->cd.sparc.r[rs1];
1276                            /*  TODO: samepage  */
1277                            switch (btype) {
1278                            case 0x05:      ic->f = instr(brnz); break;
1279                            default:fatal("Unimplemented branch 0x%x\n", rd);
1280                                    goto bad;
1281                          }                          }
1282                          break;                          break;
1283    
# Line 617  X(to_be_translated) Line 1313  X(to_be_translated)
1313                  case 2: /*  or  */                  case 2: /*  or  */
1314                  case 3: /*  xor  */                  case 3: /*  xor  */
1315                  case 4: /*  sub  */                  case 4: /*  sub  */
1316                    case 5: /*  andn  */
1317                    case 14:/*  udiv  */
1318                    case 16:/*  addcc  */
1319                    case 17:/*  andcc  */
1320                  case 20:/*  subcc (cmp)  */                  case 20:/*  subcc (cmp)  */
1321                  case 37:/*  sll  */                  case 37:/*  sll  */
1322                  case 38:/*  srl  */                  case 38:/*  srl  */
1323                  case 39:/*  sra  */                  case 39:/*  sra  */
1324                    case 60:/*  save  */
1325                          ic->arg[0] = (size_t)&cpu->cd.sparc.r[rs1];                          ic->arg[0] = (size_t)&cpu->cd.sparc.r[rs1];
1326                          ic->f = NULL;                          ic->f = NULL;
1327                          if (use_imm) {                          if (use_imm) {
# Line 631  X(to_be_translated) Line 1332  X(to_be_translated)
1332                                  case 2: ic->f = instr(or_imm); break;                                  case 2: ic->f = instr(or_imm); break;
1333                                  case 3: ic->f = instr(xor_imm); break;                                  case 3: ic->f = instr(xor_imm); break;
1334                                  case 4: ic->f = instr(sub_imm); break;                                  case 4: ic->f = instr(sub_imm); break;
1335                                    case 5: ic->f = instr(andn_imm); break;
1336                                    case 14:ic->f = instr(udiv_imm); break;
1337                                    case 16:ic->f = instr(addcc_imm); break;
1338                                    case 17:ic->f = instr(andcc_imm); break;
1339                                  case 20:ic->f = instr(subcc_imm); break;                                  case 20:ic->f = instr(subcc_imm); break;
1340                                  case 37:if (siconst & 0x1000) {                                  case 37:if (siconst & 0x1000) {
1341                                                  ic->f = instr(sllx_imm);                                                  ic->f = instr(sllx_imm);
# Line 659  X(to_be_translated) Line 1364  X(to_be_translated)
1364                                                  ic->arg[1] &= 31;                                                  ic->arg[1] &= 31;
1365                                          }                                          }
1366                                          break;                                          break;
1367                                    case 60:switch (cpu->cd.sparc.cpu_type.v) {
1368                                            case 9: ic->f = instr(save_v9_imm);
1369                                                    break;
1370                                            default:fatal("only for v9 so far\n");
1371                                                    goto bad;
1372                                            }
1373                                  }                                  }
1374                          } else {                          } else {
1375                                  ic->arg[1] = (size_t)&cpu->cd.sparc.r[rs2];                                  ic->arg[1] = (size_t)&cpu->cd.sparc.r[rs2];
# Line 668  X(to_be_translated) Line 1379  X(to_be_translated)
1379                                  case 2: ic->f = instr(or); break;                                  case 2: ic->f = instr(or); break;
1380                                  case 3: ic->f = instr(xor); break;                                  case 3: ic->f = instr(xor); break;
1381                                  case 4: ic->f = instr(sub); break;                                  case 4: ic->f = instr(sub); break;
1382                                    case 5: ic->f = instr(andn); break;
1383                                    case 14:ic->f = instr(udiv); break;
1384                                    case 16:ic->f = instr(addcc); break;
1385                                    case 17:ic->f = instr(andcc); break;
1386                                  case 20:ic->f = instr(subcc); break;                                  case 20:ic->f = instr(subcc); break;
1387                                  case 37:if (siconst & 0x1000) {                                  case 37:if (siconst & 0x1000) {
1388                                                  ic->f = instr(sllx);                                                  ic->f = instr(sllx);
# Line 696  X(to_be_translated) Line 1411  X(to_be_translated)
1411                          }                          }
1412                          ic->arg[2] = (size_t)&cpu->cd.sparc.r[rd];                          ic->arg[2] = (size_t)&cpu->cd.sparc.r[rd];
1413                          if (rd == SPARC_ZEROREG) {                          if (rd == SPARC_ZEROREG) {
1414                                  /*  Opcodes which update the ccr should use                                  /*
1415                                      the scratch register instead of being                                   *  Some opcodes should write to the scratch
1416                                      turned into a nop, when the zero register                                   *  register instead of becoming NOPs, when
1417                                      is used as the destination:  */                                   *  rd is the zero register.
1418                                     *
1419                                     *  Any opcode which updates the condition
1420                                     *  codes, or anything which changes register
1421                                     *  windows.
1422                                     */
1423                                  switch (op2) {                                  switch (op2) {
1424                                    case 16:/*  addcc  */
1425                                    case 17:/*  andcc  */
1426                                  case 20:/*  subcc  */                                  case 20:/*  subcc  */
1427                                    case 60:/*  save  */
1428                                          ic->arg[2] = (size_t)                                          ic->arg[2] = (size_t)
1429                                              &cpu->cd.sparc.scratch;                                              &cpu->cd.sparc.scratch;
1430                                          break;                                          break;
# Line 723  X(to_be_translated) Line 1446  X(to_be_translated)
1446                          }                          }
1447                          break;                          break;
1448    
1449                    case 42:/*  rdpr on sparcv9  */
1450                            if (cpu->is_32bit) {
1451                                    fatal("opcode 2,42 not yet implemented"
1452                                        " for 32-bit cpus\n");
1453                                    goto bad;
1454                            }
1455                            ic->arg[2] = (size_t)&cpu->cd.sparc.r[rd];
1456                            if (rd == SPARC_ZEROREG)
1457                                    ic->f = instr(nop);
1458                            switch (rs1) {
1459                            case  5:  ic->f = instr(rdpr_tba); break;
1460                            case 31:  ic->f = instr(rdpr_ver); break;
1461                            default:fatal("Unimplemented rs1=%i\n", rs1);
1462                                    goto bad;
1463                            }
1464                            break;
1465    
1466                  case 48:/*  wr  (Note: works as xor)  */                  case 48:/*  wr  (Note: works as xor)  */
1467                          ic->arg[0] = (size_t)&cpu->cd.sparc.r[rs1];                          ic->arg[0] = (size_t)&cpu->cd.sparc.r[rs1];
1468                          if (use_imm) {                          if (use_imm) {
# Line 807  X(to_be_translated) Line 1547  X(to_be_translated)
1547                          }                          }
1548                          break;                          break;
1549    
1550                    case 57:/*  return  */
1551                            ic->arg[0] = (size_t)&cpu->cd.sparc.r[rs1];
1552    
1553                            if (use_imm) {
1554                                    ic->arg[1] = siconst;
1555                                    ic->f = instr(return_imm);
1556                            } else {
1557                                    ic->arg[1] = (size_t)&cpu->cd.sparc.r[rs2];
1558                                    ic->f = instr(return_reg);
1559                            }
1560    
1561                            /*  special trace case:  */
1562                            if (cpu->machine->show_trace_tree) {
1563                                    if (use_imm)
1564                                            ic->f = instr(return_imm_trace);
1565                                    else
1566                                            ic->f = instr(return_reg_trace);
1567                            }
1568                            break;
1569    
1570                    default:fatal("TODO: unimplemented op2=%i for main "
1571                                "opcode %i\n", op2, main_opcode);
1572                            goto bad;
1573                    }
1574                    break;
1575    
1576            case 3: switch (op2) {
1577    
1578                    case  0:/*  lduw  */
1579                    case  1:/*  ldub  */
1580                    case  2:/*  lduh  */
1581                    case  4:/*  st(w) */
1582                    case  5:/*  stb   */
1583                    case  6:/*  sth   */
1584                    case  8:/*  ldsw  */
1585                    case  9:/*  ldsb  */
1586                    case 10:/*  ldsh  */
1587                    case 11:/*  ldx  */
1588                    case 14:/*  stx   */
1589                            store = 1; signedness = 0; size = 3;
1590                            switch (op2) {
1591                            case  0: /*  lduw  */   store=0; size=2; break;
1592                            case  1: /*  ldub  */   store=0; size=0; break;
1593                            case  2: /*  lduh  */   store=0; size=1; break;
1594                            case  4: /*  st  */     size = 2; break;
1595                            case  5: /*  stb  */    size = 0; break;
1596                            case  6: /*  sth  */    size = 1; break;
1597                            case  8: /*  ldsw  */   store=0; size=2; signedness=1;
1598                                                    break;
1599                            case  9: /*  ldsb  */   store=0; size=0; signedness=1;
1600                                                    break;
1601                            case 10: /*  ldsh  */   store=0; size=1; signedness=1;
1602                                                    break;
1603                            case 11: /*  ldx  */    store=0; break;
1604                            case 14: /*  stx  */    break;
1605                            }
1606                            ic->f =
1607    #ifdef MODE32
1608                                sparc32_loadstore
1609    #else
1610                                sparc_loadstore
1611    #endif
1612                                [ use_imm*16 + store*8 + size*2 + signedness ];
1613    
1614                            ic->arg[0] = (size_t)&cpu->cd.sparc.r[rd];
1615                            ic->arg[1] = (size_t)&cpu->cd.sparc.r[rs1];
1616                            if (use_imm)
1617                                    ic->arg[2] = siconst;
1618                            else
1619                                    ic->arg[2] = (size_t)&cpu->cd.sparc.r[rs2];
1620    
1621                            if (!store && rd == SPARC_ZEROREG)
1622                                    ic->arg[0] = (size_t)&cpu->cd.sparc.scratch;
1623    
1624                            break;
1625    
1626                  default:fatal("TODO: unimplemented op2=%i for main "                  default:fatal("TODO: unimplemented op2=%i for main "
1627                              "opcode %i\n", op2, main_opcode);                              "opcode %i\n", op2, main_opcode);
1628                          goto bad;                          goto bad;
1629                  }                  }
1630                  break;                  break;
1631    
         default:fatal("TODO: unimplemented main opcode %i\n", main_opcode);  
                 goto bad;  
1632          }          }
1633    
1634    
Legend:
Removed from v.24  
changed lines
  Added in v.32
  ViewVC Help
Powered by ViewVC 1.1.26