* Merged with default branch at rev 16f3633aaa5a.
[cacao.git] / src / vm / jit / m68k / emit.c
1 /* src/vm/jit/m68k/emit.c
2
3    Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
4    C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
5    E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
6    J. Wenninger, Institut f. Computersprachen - TU Wien
7
8    This file is part of CACAO.
9
10    This program is free software; you can redistribute it and/or
11    modify it under the terms of the GNU General Public License as
12    published by the Free Software Foundation; either version 2, or (at
13    your option) any later version.
14
15    This program is distributed in the hope that it will be useful, but
16    WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18    General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23    02110-1301, USA.
24
25 */
26
27
28 #include "config.h"
29
30 #include <assert.h>
31
32 #include "emit.h"
33 #include "vm/jit/emit-common.h"
34 #include "vm/exceptions.h"
35 #include "vm/jit/asmpart.h"
36 #include "vm/builtin.h"
37
38 #include "mm/memory.h"
39
40 #include "threads/lock-common.h"
41
42 #include "codegen.h"
43 #include "md-os.h"
44
45 /* emit_mov_imm_reg **************************************************************************
46  *
47  *      Loads an immededat operand into an integer data register
48  *
49  ********************************************************************************************/
50 void emit_mov_imm_reg (codegendata *cd, s4 imm, s4 dreg)
51 {
52         /* FIXME: -1 can be used as byte form 0xff, but this ifs cascade is plain wrong it seems */
53
54         if ( (imm & 0x0000007F) == imm) {
55                 /* use byte form */
56                 *((s2*)cd->mcodeptr) = 0x7000 | (dreg << 9) | imm;      /* MOVEQ.L */
57                 cd->mcodeptr += 2;
58         } else if ((imm  & 0x00007FFF) == imm)  {
59                 /* use word form */
60                 OPWORD( ((7<<6) | (dreg << 3) | 5), 7, 4);                      /* MVS.W */
61                 *((s2*)cd->mcodeptr) = (s2)imm;
62                 cd->mcodeptr += 2;
63         } else {
64                 /* use long form */
65                 OPWORD( ((2<<6) | (dreg << 3) | 0), 7, 4);
66                 *((s4*)cd->mcodeptr) = (s4)imm;
67                 cd->mcodeptr += 4;
68
69         }
70 }
71
72 /* emit_copy *******************************************************************
73
74    Generates a register/memory to register/memory copy.
75
76 *******************************************************************************/
77
78 void emit_copy(jitdata *jd, instruction *iptr)
79 {
80         codegendata *cd;
81         varinfo     *src;
82         varinfo     *dst;
83         s4           s1, d;
84
85         /* get required compiler data */
86
87         cd = jd->cd;
88
89         /* get source and destination variables */
90
91         src = VAROP(iptr->s1);
92         dst = VAROP(iptr->dst);
93
94         if ((src->vv.regoff != dst->vv.regoff) ||
95                 (IS_INMEMORY(src->flags ^ dst->flags))) {
96
97                 if ((src->type == TYPE_RET) || (dst->type == TYPE_RET)) {
98                         /* emit nothing, as the value won't be used anyway */
99                         return;
100                 }
101
102                 /* If one of the variables resides in memory, we can eliminate
103                    the register move from/to the temporary register with the
104                    order of getting the destination register and the load. */
105
106                 if (IS_INMEMORY(src->flags)) {
107                         if (IS_LNG_TYPE(src->type))
108                                 d = codegen_reg_of_var(iptr->opc, dst, REG_ITMP12_PACKED);
109                         else
110                                 d = codegen_reg_of_var(iptr->opc, dst, REG_IFTMP);
111
112                         s1 = emit_load(jd, iptr, src, d);
113                 }
114                 else {
115                         if (IS_LNG_TYPE(src->type))
116                                 s1 = emit_load(jd, iptr, src, REG_ITMP12_PACKED);
117                         else
118                                 s1 = emit_load(jd, iptr, src, REG_IFTMP);
119
120                         d = codegen_reg_of_var(iptr->opc, dst, s1);
121                 }
122
123                 if (s1 != d) {
124                         switch(src->type)       {
125                         case TYPE_INT: M_INTMOVE(s1, d); break;
126                         case TYPE_ADR: M_ADRMOVE(s1, d); break;
127                         case TYPE_LNG: M_LNGMOVE(s1, d); break;
128 #if !defined(ENABLE_SOFTFLOAT)
129                         case TYPE_FLT: M_FLTMOVE(s1, d); break;
130                         case TYPE_DBL: M_DBLMOVE(s1, d); break;
131 #else
132                         case TYPE_FLT: M_INTMOVE(s1, d); break;
133                         case TYPE_DBL: M_LNGMOVE(s1, d); break;
134 #endif
135                         default:
136                                 vm_abort("emit_copy: unknown type %d", src->type);
137                         }
138                 }
139
140                 emit_store(jd, iptr, dst, d);
141         }
142 }
143
144
145 /* emit_store ******************************************************************
146
147    Emits a possible store of the destination operand.
148
149 *******************************************************************************/
150
151 inline void emit_store(jitdata *jd, instruction *iptr, varinfo *dst, s4 d)
152 {
153         codegendata  *cd;
154
155         /* get required compiler data */
156
157         cd = jd->cd;
158
159         if (IS_INMEMORY(dst->flags)) {
160                 COUNT_SPILLS;
161         
162                 switch(dst->type)       {
163 #if defined(ENABLE_SOFTFLOAT)
164                         case TYPE_DBL:
165 #endif
166                         case TYPE_LNG:
167                                 M_LST(d, REG_SP, dst->vv.regoff);
168                                 break;
169 #if defined(ENABLE_SOFTFLOAT)
170                         case TYPE_FLT:
171 #endif
172                         case TYPE_INT:
173                                 M_IST(d, REG_SP, dst->vv.regoff);
174                                 break;
175                         case TYPE_ADR:
176                                 M_AST(d, REG_SP, dst->vv.regoff);
177                                 break;
178 #if !defined(ENABLE_SOFTFLOAT)
179                         case TYPE_DBL:
180                                 M_DST(d, REG_SP, dst->vv.regoff);
181                                 break;
182                         case TYPE_FLT:
183                                 M_FST(d, REG_SP, dst->vv.regoff);
184                                 break;
185 #endif
186                         default:
187                                 vm_abort("emit_store: unknown type %d", dst->type);
188                 }
189         }
190 }
191
192
193 /* emit_load *******************************************************************
194
195    Emits a possible load of an operand.
196
197 *******************************************************************************/
198
199 s4 emit_load(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
200 {
201         codegendata *cd;
202         s4           disp;
203         s4           reg;
204
205         /* get required compiler data */
206
207         cd = jd->cd;
208
209         if (IS_INMEMORY(src->flags)) {
210                 COUNT_SPILLS;
211
212                 disp = src->vv.regoff;
213         
214                 switch (src->type)      {
215 #if defined(ENABLE_SOFTFLOAT)
216                         case TYPE_FLT:
217 #endif
218                         case TYPE_INT: 
219                                 M_ILD(tempreg, REG_SP, disp);
220                                 break;
221 #if defined(ENABLE_SOFTFLOAT)
222                         case TYPE_DBL:
223 #endif
224                         case TYPE_LNG:
225                                 M_LLD(tempreg, REG_SP, disp);
226                                 break;
227                         case TYPE_ADR:
228                                 M_ALD(tempreg, REG_SP, disp);
229                                 break;
230 #if !defined(ENABLE_SOFTFLOAT)
231                         case TYPE_FLT:
232                                 M_FLD(tempreg, REG_SP, disp);
233                                 break;
234                         case TYPE_DBL:
235                                 M_DLD(tempreg, REG_SP, disp);
236                                 break;
237 #endif
238                         default:
239                                 vm_abort("emit_load: unknown type %d", src->type);
240                 }
241                 #if 0
242                 if (IS_FLT_DBL_TYPE(src->type)) {
243                         if (IS_2_WORD_TYPE(src->type)) {
244                                 M_DLD(tempreg, REG_SP, disp);
245                          } else {
246                                 M_FLD(tempreg, REG_SP, disp);
247                         }
248                 } else {
249                         if (IS_2_WORD_TYPE(src->type)) {
250                                 M_LLD(tempreg, REG_SP, disp);
251                         } else {
252                                 M_ILD(tempreg, REG_SP, disp);
253                         }
254                 }
255                 #endif
256
257                 reg = tempreg;
258         }
259         else
260                 reg = src->vv.regoff;
261
262         return reg;
263 }
264
265
266 /* emit_patcher_stubs **********************************************************
267
268    Generates the code for the patcher stubs.
269
270 *******************************************************************************/
271 void emit_patcher_stubs(jitdata *jd)
272 {
273         codegendata *cd;
274         patchref    *pref;
275         u8           mcode;
276         u1          *savedmcodeptr;
277         u1          *tmpmcodeptr;
278         s4           targetdisp;
279         s4           disp;
280
281         /* get required compiler data */
282
283         cd = jd->cd;
284
285         /* generate code patching stub call code */
286
287         targetdisp = 0;
288
289         for (pref = cd->patchrefs; pref != NULL; pref = pref->next) {
290                 /* check code segment size */
291
292                 MCODECHECK(512);
293
294                 /* Get machine code which is patched back in later. A
295                    `bsr.l' is 6 bytes long. */
296
297                 savedmcodeptr = cd->mcodebase + pref->branchpos;
298                 mcode = *((u8 *) savedmcodeptr);
299
300                 /* patch in `bsr.l' to call the following code */
301
302                 tmpmcodeptr  = cd->mcodeptr;    /* save current mcodeptr              */
303                 cd->mcodeptr = savedmcodeptr;   /* set mcodeptr to patch position     */
304
305                 M_BSR_IMM(tmpmcodeptr - (savedmcodeptr + PATCHER_CALL_SIZE) + 4);
306
307                 cd->mcodeptr = tmpmcodeptr;     /* restore the current mcodeptr       */
308
309                 /* save REG_ITMP3, restored in asm_patcher_wrapper  */
310                 M_IPUSH(REG_ITMP3);             
311
312                 /* move pointer to java_objectheader onto stack */
313
314 #if defined(ENABLE_THREADS)
315                 (void) dseg_add_unique_address(cd, NULL);                  /* flcword */
316                 (void) dseg_add_unique_address(cd, lock_get_initial_lock_word());
317                 disp = dseg_add_unique_address(cd, NULL);                  /* vftbl   */
318
319                 M_IMOV_IMM32(0, REG_ITMP3);
320                 dseg_adddata(cd);
321                 M_IADD_IMM(disp, REG_ITMP3);
322                 M_IPUSH(REG_ITMP3);
323 #else
324                 M_IPUSH_IMM(0);
325 #endif
326
327                 /* push move machine code bytes and classinfo pointer */
328
329                 M_IPUSH_IMM(mcode >> 32);
330                 M_IPUSH_IMM(mcode);
331                 M_IPUSH_IMM(pref->ref);
332                 M_IPUSH_IMM(pref->patcher);
333
334                 M_JMP_IMM(asm_patcher_wrapper);
335         }
336 }
337 s4 emit_load_low(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg) 
338 {
339         codegendata  *cd;
340         s4            disp;
341         s4            reg;
342
343 #if !defined(ENABLE_SOFTFLOAT)
344         assert(src->type == TYPE_LNG);
345 #else
346         assert(src->type == TYPE_LNG || src->type == TYPE_DBL);
347 #endif
348
349         /* get required compiler data */
350         cd = jd->cd;
351
352         if (IS_INMEMORY(src->flags)) {
353                 COUNT_SPILLS;
354
355                 disp = src->vv.regoff;
356                 M_ILD(tempreg, REG_SP, disp + 4);
357                 reg = tempreg;
358         } else {
359                 reg = GET_LOW_REG(src->vv.regoff);
360         }
361         return reg;
362 }
363 s4 emit_load_high(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
364 {
365         codegendata  *cd;
366         s4            disp;
367         s4            reg;
368
369 #if !defined(ENABLE_SOFTFLOAT)
370         assert(src->type == TYPE_LNG);
371 #else
372         assert(src->type == TYPE_LNG || src->type == TYPE_DBL);
373 #endif
374         /* get required compiler data */
375         cd = jd->cd;
376
377         if (IS_INMEMORY(src->flags)) {
378                 COUNT_SPILLS;
379                 disp = src->vv.regoff;
380                 M_ILD(tempreg, REG_SP, disp);
381                 reg = tempreg;
382         } else {
383                 reg = GET_HIGH_REG(src->vv.regoff);
384         }
385         return reg;
386 }
387 /* emit_branch *****************************************************************
388
389    Emits the code for conditional and unconditional branchs.
390
391 *******************************************************************************/
392 void emit_branch(codegendata *cd, s4 disp, s4 condition, s4 reg, u4 opt) 
393
394         /* calculate the different displacements */
395         /* PC is a at branch instruction + 2 */
396         /* coditional and uncondition branching work the same way */
397         /* short branches have signed 16 bit offset */
398         /* long branches are signed 32 bit */
399         /* the 8 bit offset branching instructions are not used */
400
401         disp  =  disp - 2;
402
403         /* check displacement for overflow */
404         if ((disp & 0x0000FFFF) != disp)        {
405                 if (!CODEGENDATA_HAS_FLAG_LONGBRANCHES(cd)) {
406                         cd->flags |= (CODEGENDATA_FLAG_ERROR | CODEGENDATA_FLAG_LONGBRANCHES);
407                 }
408         }
409
410         /* check which branch to generate */
411
412         if (condition == BRANCH_UNCONDITIONAL) {
413                 if (CODEGENDATA_HAS_FLAG_LONGBRANCHES(cd))      {
414                         M_BR_32(disp);
415                 } else  {
416                         M_BR_16(disp);
417                 }
418         } else {
419                 if (CODEGENDATA_HAS_FLAG_LONGBRANCHES(cd)) {
420                         switch (condition) {
421                         case BRANCH_EQ:
422                                 M_BEQ_32(disp);
423                                 break;
424                         case BRANCH_NE:
425                                 M_BNE_32(disp);
426                                 break;
427                         case BRANCH_LT:
428                                 M_BLT_32(disp);
429                                 break;
430                         case BRANCH_GE:
431                                 M_BGE_32(disp);
432                                 break;
433                         case BRANCH_GT:
434                                 M_BGT_32(disp);
435                                 break;
436                         case BRANCH_LE:
437                                 M_BLE_32(disp);
438                                 break;
439                         case BRANCH_NAN:
440                                 M_BNAN_32(disp);
441                                 break;
442                         case BRANCH_UGT:
443                                 M_BHI_32(disp);
444                                 break;
445
446                         default:
447                                 vm_abort("emit_branch: unknown condition %d", condition);
448                         }
449                 } else {
450                         switch (condition) {
451                         case BRANCH_EQ:
452                                 M_BEQ_16(disp);
453                                 break;
454                         case BRANCH_NE:
455                                 M_BNE_16(disp);
456                                 break;
457                         case BRANCH_LT:
458                                 M_BLT_16(disp);
459                                 break;
460                         case BRANCH_GE:
461                                 M_BGE_16(disp);
462                                 break;
463                         case BRANCH_GT:
464                                 M_BGT_16(disp);
465                                 break;
466                         case BRANCH_LE:
467                                 M_BLE_16(disp);
468                                 break;
469                         case BRANCH_NAN:
470                                 M_BNAN_16(disp);
471                                 break;
472                         case BRANCH_UGT:
473                                 M_BHI_16(disp);
474                                 break;
475                         default:
476                                 vm_abort("emit_branch: unknown condition %d", condition);
477                         }
478                 }
479         }
480 }
481
482 /* emit_replacement_stubs ******************************************************
483
484    Generates the code for the replacement stubs.
485
486 *******************************************************************************/
487
488 #if defined(ENABLE_REPLACEMENT)
489 void emit_replacement_stubs(jitdata *jd)
490 {
491         codegendata *cd;
492         codeinfo    *code;
493         rplpoint    *rplp;
494         s4           i;
495         s4           branchmpc;
496         s4           outcode;
497
498         /* get required compiler data */
499
500         cd   = jd->cd;
501         code = jd->code;
502
503         rplp = code->rplpoints;
504
505         /* store beginning of replacement stubs */
506
507         code->replacementstubs = (u1*) (cd->mcodeptr - cd->mcodebase);
508
509         for (i = 0; i < code->rplpointcount; ++i, ++rplp) {
510                 /* do not generate stubs for non-trappable points */
511
512                 if (rplp->flags & RPLPOINT_FLAG_NOTRAP)
513                         continue;
514
515                 M_JSR_IMM(0);
516 #if 0
517                 /* check code segment size */
518
519                 MCODECHECK(512);
520
521                 /* note start of stub code */
522
523                 outcode = (s4) (cd->mcodeptr - cd->mcodebase);
524
525                 /* push address of `rplpoint` struct */
526                         
527                 M_PUSH_IMM(rplp);
528
529                 /* jump to replacement function */
530
531                 M_PUSH_IMM(asm_replacement_out);
532                 M_RET;
533
534                 /* add jump reference for COUNTDOWN points */
535
536                 if (rplp->flags & RPLPOINT_FLAG_COUNTDOWN) {
537
538                         branchmpc = (s4)rplp->pc + (7 + 6);
539
540                         md_codegen_patch_branch(cd, branchmpc, (s4) outcode);
541                 }
542
543                 assert(((cd->mcodeptr - cd->mcodebase) - outcode) == REPLACEMENT_STUB_SIZE);
544 #endif
545         }
546 }
547 #endif /* defined(ENABLE_REPLACEMENT) */
548         
549
550
551 #if !defined(NDEBUG)
552 /*
553  *      Trace functions. Implement -verbose:call flag
554  *      code marked by real NOP, but performance is no matter when using -verbose:call :)
555  */
556 void emit_verbosecall_enter(jitdata* jd) 
557
558         methodinfo   *m;
559         codegendata  *cd;
560         registerdata *rd;
561         methoddesc   *md;
562         s4      disp,i,t;
563
564
565         if (!JITDATA_HAS_FLAG_VERBOSECALL(jd))
566                 return;
567         
568         /* get required compiler data */
569         m  = jd->m;
570         cd = jd->cd;
571         rd = jd->rd;
572         md = m->parseddesc;
573
574         /* mark trace code */
575         M_NOP;
576
577         M_IPUSH(REG_D0);
578         M_IPUSH(REG_D1);
579         M_APUSH(REG_A0);
580         M_APUSH(REG_A1);
581
582 #if !defined(ENABLE_SOFTFLOAT)
583         M_AADD_IMM(-8*2, REG_SP);
584         M_FSTORE(REG_F0, REG_SP, 8);
585         M_FSTORE(REG_F1, REG_SP, 0);
586
587         disp = 4*4 + 8*2 + 4;   /* points to old argument stack initially */
588 #else
589         disp = 4*4 + 4;
590 #endif
591         /* builtin_verbosecall_enter takes all args as s8 type */
592         /* TRACE_ARGS_NUM is the number of args the builtin_verbosecall_enter expects */
593         M_IPUSH_IMM(m);
594         
595
596         /* travel up stack to the first argument of the function which needs to be copied */
597         for (i=0; (i < md->paramcount) && (i < TRACE_ARGS_NUM); i++)    {
598                 disp += 8;
599         }
600
601         /* disp now points to the first arg which gets copied to the trace stack, relative to REG_SP! */
602         for (i=TRACE_ARGS_NUM-1; i>=0; --i) {
603                 if (i < md->paramcount) {
604                         /* traced function has such an argument */
605                         t = md->paramtypes[i].type;
606                         
607                         /* copy from original argument stack */
608                         M_ILD(REG_ITMP1, REG_SP, disp);
609                         M_ILD(REG_ITMP2, REG_SP, disp-4);
610                         M_IPUSH(REG_ITMP2);
611                         M_IPUSH(REG_ITMP1);
612                 } else  {
613                         /* function has no arg here, push nothing and adapt displacement */
614                         M_IPUSH_IMM(0);
615                         M_IPUSH_IMM(0);
616                         disp += 8;
617                 }
618         }
619         M_JSR_IMM(builtin_verbosecall_enter);
620         /* pop arguments off stack */
621         M_AADD_IMM(TRACE_ARGS_NUM*8+4, REG_SP);
622
623 #if !defined(ENABLE_SOFTFLOAT)
624         M_FSTORE(REG_F1, REG_SP, 0);
625         M_FSTORE(REG_F0, REG_SP, 8);
626         M_AADD_IMM(8*2, REG_SP);
627 #endif
628
629         M_APOP(REG_A1);
630         M_APOP(REG_A0);
631         M_IPOP(REG_D1);
632         M_IPOP(REG_D0);
633
634         M_NOP;
635 }
636 void emit_verbosecall_exit(jitdata* jd) 
637
638         methodinfo   *m;
639         codegendata  *cd;
640         registerdata *rd;
641         methoddesc   *md;
642
643         if (!JITDATA_HAS_FLAG_VERBOSECALL(jd))
644                 return;
645
646         /* get required compiler data */
647         m  = jd->m;
648         cd = jd->cd;
649         rd = jd->rd;
650         md = m->parseddesc;
651
652         /* void builtin_verbosecall_exit(s8 l, double d, float f, methodinfo *m); */
653
654
655         /* mark trace code */
656         M_NOP;
657
658 #if !defined(ENABLE_SOFTFLOAT)
659         M_AADD_IMM(-8, REG_SP);
660         M_FSTORE(REG_D1, REG_SP, 0);
661 #endif
662
663         M_IPUSH_IMM(m);                                 /* push methodinfo */
664
665 #if !defined(ENABLE_SOFTFLOAT)
666         M_AADD_IMM(-3*4, REG_SP);
667         M_FST(REG_D0, REG_SP, 8);
668         M_DST(REG_D0, REG_SP, 0);
669 #else
670         M_IPUSH_IMM(0);
671
672         M_IPUSH_IMM(0);
673         M_IPUSH_IMM(0);
674 #endif
675
676         M_IPUSH(GET_HIGH_REG(REG_RESULT_PACKED))
677         M_IPUSH(GET_LOW_REG(REG_RESULT_PACKED))         /* push long result */
678
679         M_JSR_IMM(builtin_verbosecall_exit);
680
681         /* poping result registers from stack */
682         M_IPOP(GET_LOW_REG(REG_RESULT_PACKED))
683         M_IPOP(GET_HIGH_REG(REG_RESULT_PACKED))
684
685 #if !defined(ENABLE_SOFTFLOAT)
686         M_DLD(REG_D0, REG_SP, 0)
687         M_FLD(REG_D0, REG_SP, 8)
688 #endif
689         M_AADD_IMM(3*4 + 4, REG_SP);
690
691 #if !defined(ENABLE_SOFTFLOAT)
692         M_FLOAD(REG_D1, REG_SP, 0)
693         M_AADD_IMM(8, REG_SP);
694 #endif
695
696         M_NOP;
697 }
698 #endif
699
700 /* emit_classcast_check ********************************************************
701
702    Emit a ClassCastException check.
703
704 *******************************************************************************/
705
706 void emit_classcast_check(codegendata *cd, instruction *iptr, s4 condition, s4 reg, s4 s1)
707 {
708         if (INSTRUCTION_MUST_CHECK(iptr)) {
709                 switch (condition) {
710                 case BRANCH_LE:
711                         M_BGT(4);
712                         break;
713                 case BRANCH_EQ:
714                         M_BNE(4);
715                         break;
716                 case BRANCH_GT:
717                         M_BLE(4);
718                         break;
719                 case BRANCH_UGT:
720                         M_BLS(4);
721                         break;
722                 default:
723                         vm_abort("emit_classcast_check: unknown condition %d", condition);
724                 }
725                 M_TRAP_SETREGISTER(s1);
726                 M_TRAP(EXCEPTION_HARDWARE_CLASSCAST);
727         }
728 }
729
730 /* emit_arrayindexoutofbounds_check ********************************************
731
732    Emit a ArrayIndexOutOfBoundsException check.
733
734 *******************************************************************************/
735 void emit_arrayindexoutofbounds_check(codegendata *cd, instruction *iptr, s4 s1, s4 s2)
736 {
737         if (INSTRUCTION_MUST_CHECK(iptr)) {
738                 M_ILD(REG_ITMP3, s1, OFFSET(java_array_t, size));
739                 M_ICMP(s2, REG_ITMP3);
740                 M_BHI(4);
741                 M_TRAP_SETREGISTER(s2);
742                 M_TRAP(EXCEPTION_HARDWARE_ARRAYINDEXOUTOFBOUNDS);
743         }
744 }
745
746 /* emit_nullpointer_check ******************************************************
747
748    Emit a NullPointerException check.
749
750 *******************************************************************************/
751 void emit_nullpointer_check(codegendata *cd, instruction *iptr, s4 reg)
752 {
753         if (INSTRUCTION_MUST_CHECK(iptr)) {
754                 /* XXX: this check is copied to call monitor_enter 
755                  * invocation at the beginning of codegen.c */
756                 M_ATST(reg);
757                 M_BNE(2);
758                 M_TRAP(M68K_EXCEPTION_HARDWARE_NULLPOINTER);
759         }
760 }
761
762 /* emit_arithmetic_check *******************************************************
763
764    Emit an ArithmeticException check.
765
766 *******************************************************************************/
767
768 void emit_arithmetic_check(codegendata *cd, instruction *iptr, s4 reg)
769 {
770         if (INSTRUCTION_MUST_CHECK(iptr)) {
771                 M_ITST(reg);
772                 M_BNE(2);
773                 M_TRAP(EXCEPTION_HARDWARE_ARITHMETIC);
774         }
775 }
776
777 /* emit_exception_check_ireg **************************************************
778
779    Emit an Exception check. Teste register is integer REG_RESULT
780
781 *******************************************************************************/
782 void emit_exception_check(codegendata *cd, instruction *iptr)
783 {
784         if (INSTRUCTION_MUST_CHECK(iptr)) {
785                 M_ITST(REG_RESULT);
786                 M_BNE(2);
787                 /*M_ALD_INTERN(REG_ZERO, REG_ZERO, EXCEPTION_HARDWARE_EXCEPTION);*/
788                 M_TRAP(EXCEPTION_HARDWARE_EXCEPTION);
789         }
790 }
791
792
793 /*
794  * These are local overrides for various environment variables in Emacs.
795  * Please do not remove this and leave it at the end of the file, where
796  * Emacs will automagically detect them.
797  * ---------------------------------------------------------------------
798  * Local variables:
799  * mode: c
800  * indent-tabs-mode: t
801  * c-basic-offset: 4
802  * tab-width: 4
803  * End:
804  * vim:noexpandtab:sw=4:ts=4:
805  */