66   rIBASE   edx   base of instruction handler table
82 #define rIBASE   %edx
235      jmp     *(rIBASE,%eax,4)
244      jmp     *(rIBASE,\_reg,4)
621     SPILL(rIBASE)                       # preserve rIBASE (cltd trashes it)
622     cltd                                # rIBASE:eax<- ssssssssssssBBBB
623     SET_VREG_WORD rIBASE rINST 1        # store msw
625     UNSPILL(rIBASE)                     # restore rIBASE
635     SPILL(rIBASE)                       # save rIBASE (cltd trashes it)
636     cltd                                # rIBASE:eax<- ssssssssssssBBBB
637     SET_VREG_WORD rIBASE rINST,1        # store msw
639     UNSPILL(rIBASE)                     # restore rIBASE
698     SPILL(rIBASE)
700     UNSPILL(rIBASE)
735     SPILL(rIBASE)
737     UNSPILL(rIBASE)
773     SPILL(rIBASE)
775     UNSPILL(rIBASE)
798     SPILL(rIBASE)
800     UNSPILL(rIBASE)
823     SPILL(rIBASE)
825     UNSPILL(rIBASE)
871     SPILL(rIBASE)
873     UNSPILL(rIBASE)
901     SPILL(rIBASE)
903     UNSPILL(rIBASE)
925     SPILL(rIBASE)                       # preserve rIBASE
927     movzwl  2(rPC),rIBASE               # rIBASE<- CCCC
929     movl    (%ecx,rIBASE,4),%ecx        # ecx<- resolved class
953     UNSPILL(rIBASE)
965     UNSPILL(rIBASE)
975      *  rIBASE holds BBBB
979     movl    rIBASE,OUT_ARG1(%esp)         # arg1<- BBBB
1027     SPILL(rIBASE)
1059     UNSPILL(rIBASE)
1080     UNSPILL(rIBASE)
1134     SPILL(rIBASE)
1176     UNSPILL(rIBASE)
1197     SPILL(rIBASE)                             # preserve rIBASE
1272     UNSPILL_TMP1(rIBASE)      # restore "BA"
1273     andl   $0x0f,rIBASE      # rIBASE<- 0000000A
1274     sall   $16,rIBASE        # rIBASE<- 000A0000
1275     orl    %ecx,rIBASE        # rIBASE<- 000AFEDC
1278     andl   rIBASE,%ecx        # ecx<- next reg to load
1280     shrl   $4,rIBASE
1297     UNSPILL(rIBASE)                          # restore rIBASE
1328     SPILL(rIBASE)                             # preserve rIBASE
1403     UNSPILL_TMP1(rIBASE)      # restore "BA"
1404     andl   $0x0f,rIBASE      # rIBASE<- 0000000A
1405     sall   $16,rIBASE        # rIBASE<- 000A0000
1406     orl    %ecx,rIBASE        # rIBASE<- 000AFEDC
1409     andl   rIBASE,%ecx        # ecx<- next reg to load
1411     shrl   $4,rIBASE
1428     UNSPILL(rIBASE)                          # restore rIBASE
1455     SPILL(rIBASE)
1457     UNSPILL(rIBASE)
1491     movl    offThread_curHandlerTable(%ecx),rIBASE
1512     movl    offThread_curHandlerTable(%ecx),rIBASE
1533     movl    offThread_curHandlerTable(%ecx),rIBASE
1564     movl    offThread_curHandlerTable(%ecx),rIBASE
1595     movl    offThread_curHandlerTable(%ecx),rIBASE
1746     // TUNING: rework to avoid rIBASE spill
1749     SPILL(rIBASE)
1750     movzbl    3(rPC),rIBASE            # rIBASE- CC
1753     cmpl      4(rFP,rIBASE,4),%eax
1756     sub       (rFP,rIBASE,4),%ecx
1761     UNSPILL(rIBASE)
1769     UNSPILL(rIBASE)
1777     UNSPILL(rIBASE)
1803     movl     offThread_curHandlerTable(%ecx),rIBASE
1836     movl     offThread_curHandlerTable(%ecx),rIBASE
1869     movl     offThread_curHandlerTable(%ecx),rIBASE
1902     movl     offThread_curHandlerTable(%ecx),rIBASE
1935     movl     offThread_curHandlerTable(%ecx),rIBASE
1968     movl     offThread_curHandlerTable(%ecx),rIBASE
1996     movl     offThread_curHandlerTable(%ecx),rIBASE
2025     movl     offThread_curHandlerTable(%ecx),rIBASE
2054     movl     offThread_curHandlerTable(%ecx),rIBASE
2083     movl     offThread_curHandlerTable(%ecx),rIBASE
2112     movl     offThread_curHandlerTable(%ecx),rIBASE
2141     movl     offThread_curHandlerTable(%ecx),rIBASE
2478     SPILL(rIBASE)
2480     UNSPILL(rIBASE)
2637     SPILL(rIBASE)                               # preserve rIBASE
2638     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
2645     movl    (%eax,rIBASE,4),%eax                # resolved entry
2648     movl    rIBASE,OUT_ARG1(%esp)               # needed by dvmResolveInstField
2649     movl    rSELF,rIBASE
2651     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
2652     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
2654     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
2673     UNSPILL(rIBASE)
2687     SPILL(rIBASE)                               # preserve rIBASE
2688     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
2695     movl    (%eax,rIBASE,4),%eax                # resolved entry
2698     movl    rIBASE,OUT_ARG1(%esp)               # for dvmResolveInstField
2699     movl    rSELF,rIBASE
2701     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
2702     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
2726     UNSPILL(rIBASE)                             # restore rIBASE
2742     SPILL(rIBASE)                               # preserve rIBASE
2743     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
2750     movl    (%eax,rIBASE,4),%eax                # resolved entry
2753     movl    rIBASE,OUT_ARG1(%esp)               # needed by dvmResolveInstField
2754     movl    rSELF,rIBASE
2756     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
2757     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
2759     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
2778     UNSPILL(rIBASE)
2795     SPILL(rIBASE)                               # preserve rIBASE
2796     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
2803     movl    (%eax,rIBASE,4),%eax                # resolved entry
2806     movl    rIBASE,OUT_ARG1(%esp)               # needed by dvmResolveInstField
2807     movl    rSELF,rIBASE
2809     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
2810     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
2812     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
2831     UNSPILL(rIBASE)
2848     SPILL(rIBASE)                               # preserve rIBASE
2849     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
2856     movl    (%eax,rIBASE,4),%eax                # resolved entry
2859     movl    rIBASE,OUT_ARG1(%esp)               # needed by dvmResolveInstField
2860     movl    rSELF,rIBASE
2862     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
2863     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
2865     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
2884     UNSPILL(rIBASE)
2901     SPILL(rIBASE)                               # preserve rIBASE
2902     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
2909     movl    (%eax,rIBASE,4),%eax                # resolved entry
2912     movl    rIBASE,OUT_ARG1(%esp)               # needed by dvmResolveInstField
2913     movl    rSELF,rIBASE
2915     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
2916     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
2918     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
2937     UNSPILL(rIBASE)
2954     SPILL(rIBASE)                               # preserve rIBASE
2955     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
2962     movl    (%eax,rIBASE,4),%eax                # resolved entry
2965     movl    rIBASE,OUT_ARG1(%esp)               # needed by dvmResolveInstField
2966     movl    rSELF,rIBASE
2968     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
2969     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
2971     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
2990     UNSPILL(rIBASE)
3007     SPILL   (rIBASE)
3008     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
3015     movl    (%eax,rIBASE,4),%eax                # resolved entry
3018     movl    rIBASE,OUT_ARG1(%esp)
3019     movl    rSELF,rIBASE
3021     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
3022     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
3024     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
3044     UNSPILL(rIBASE)
3057     SPILL(rIBASE)
3058     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
3065     movl    (%eax,rIBASE,4),%eax                # resolved entry
3068     movl    rIBASE,OUT_ARG1(%esp)
3069     movl    rSELF,rIBASE
3071     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
3072     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
3074     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
3086      *   rIBASE is scratch, but needs to be unspilled
3098     UNSPILL(rIBASE)
3112     SPILL(rIBASE)
3113     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
3120     movl    (%eax,rIBASE,4),%eax                  # resolved entry
3123     movl    rIBASE,OUT_ARG1(%esp)
3124     movl    rSELF,rIBASE
3126     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
3127     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
3129     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
3141      *   rIBASE is scratch, but needs to be unspilled
3156     UNSPILL(rIBASE)
3173     SPILL   (rIBASE)
3174     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
3181     movl    (%eax,rIBASE,4),%eax                # resolved entry
3184     movl    rIBASE,OUT_ARG1(%esp)
3185     movl    rSELF,rIBASE
3187     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
3188     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
3190     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
3210     UNSPILL(rIBASE)
3227     SPILL   (rIBASE)
3228     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
3235     movl    (%eax,rIBASE,4),%eax                # resolved entry
3238     movl    rIBASE,OUT_ARG1(%esp)
3239     movl    rSELF,rIBASE
3241     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
3242     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
3244     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
3264     UNSPILL(rIBASE)
3281     SPILL   (rIBASE)
3282     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
3289     movl    (%eax,rIBASE,4),%eax                # resolved entry
3292     movl    rIBASE,OUT_ARG1(%esp)
3293     movl    rSELF,rIBASE
3295     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
3296     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
3298     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
3318     UNSPILL(rIBASE)
3335     SPILL   (rIBASE)
3336     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
3343     movl    (%eax,rIBASE,4),%eax                # resolved entry
3346     movl    rIBASE,OUT_ARG1(%esp)
3347     movl    rSELF,rIBASE
3349     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
3350     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
3352     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
3372     UNSPILL(rIBASE)
3417     SPILL(rIBASE)
3419     UNSPILL(rIBASE)
3424     SPILL(rIBASE)
3426     UNSPILL(rIBASE)
3471     SPILL(rIBASE)
3473     UNSPILL(rIBASE)
3478     SPILL(rIBASE)
3480     UNSPILL(rIBASE)
3525     SPILL(rIBASE)
3527     UNSPILL(rIBASE)
3532     SPILL(rIBASE)
3534     UNSPILL(rIBASE)
3580     SPILL(rIBASE)
3582     UNSPILL(rIBASE)
3587     SPILL(rIBASE)
3589     UNSPILL(rIBASE)
3635     SPILL(rIBASE)
3637     UNSPILL(rIBASE)
3642     SPILL(rIBASE)
3644     UNSPILL(rIBASE)
3690     SPILL(rIBASE)
3692     UNSPILL(rIBASE)
3697     SPILL(rIBASE)
3699     UNSPILL(rIBASE)
3745     SPILL(rIBASE)
3747     UNSPILL(rIBASE)
3752     SPILL(rIBASE)
3754     UNSPILL(rIBASE)
3799     SPILL(rIBASE)
3801     UNSPILL(rIBASE)
3806     SPILL(rIBASE)
3808     UNSPILL(rIBASE)
3853     SPILL(rIBASE)
3855     UNSPILL(rIBASE)
3860     SPILL(rIBASE)
3862     UNSPILL(rIBASE)
3910     SPILL(rIBASE)
3912     UNSPILL(rIBASE)
3917     SPILL(rIBASE)
3919     UNSPILL(rIBASE)
3964     SPILL(rIBASE)
3966     UNSPILL(rIBASE)
3971     SPILL(rIBASE)
3973     UNSPILL(rIBASE)
4018     SPILL(rIBASE)
4020     UNSPILL(rIBASE)
4025     SPILL(rIBASE)
4027     UNSPILL(rIBASE)
4072     SPILL(rIBASE)
4074     UNSPILL(rIBASE)
4079     SPILL(rIBASE)
4081     UNSPILL(rIBASE)
4126     SPILL(rIBASE)
4128     UNSPILL(rIBASE)
4133     SPILL(rIBASE)
4135     UNSPILL(rIBASE)
4277     movzwl    4(rPC),rIBASE            # rIBASE<- GFED or CCCC
4280     andl      $0xf,rIBASE             # rIBASE<- D (or stays CCCC)
4283     GET_VREG_R  %ecx rIBASE            # ecx<- "this" ptr
4345     SPILL(rIBASE)
4347     UNSPILL(rIBASE)
4366     SPILL(rIBASE)
4368     UNSPILL(rIBASE)
4564     movzwl    4(rPC),rIBASE            # rIBASE<- GFED or CCCC
4567     andl      $0xf,rIBASE             # rIBASE<- D (or stays CCCC)
4570     GET_VREG_R  %ecx rIBASE            # ecx<- "this" ptr
4634     SPILL(rIBASE)
4636     UNSPILL(rIBASE)
4655     SPILL(rIBASE)
4657     UNSPILL(rIBASE)
4845     SPILL(rIBASE)                       # cltd trashes rIBASE/edx
4847     SET_VREG_WORD rIBASE rINST 1        # v[A+1]<- rIBASE/rPC
4849     UNSPILL(rIBASE)
5361     SPILL(rIBASE)
5362     imull    (rFP,%ecx,4),%eax      # trashes rIBASE/edx
5363     UNSPILL(rIBASE)
5383     SPILL(rIBASE)
5392     UNSPILL(rIBASE)
5401     UNSPILL(rIBASE)
5421     SPILL(rIBASE)
5428     movl     $0,rIBASE
5429     SET_VREG rIBASE rINST
5430     UNSPILL(rIBASE)
5438     SET_VREG rIBASE rINST
5439     UNSPILL(rIBASE)
5588     SPILL(rIBASE)                       # save rIBASE
5589     GET_VREG_WORD rIBASE %eax 0         # rIBASE<- v[BB+0]
5591     addl (rFP,%ecx,4),rIBASE         # ex: addl   (rFP,%ecx,4),rIBASE
5593     SET_VREG_WORD rIBASE rINST 0        # v[AA+0] <- rIBASE
5595     UNSPILL(rIBASE)                     # restore rIBASE
5612     SPILL(rIBASE)                       # save rIBASE
5613     GET_VREG_WORD rIBASE %eax 0         # rIBASE<- v[BB+0]
5615     subl (rFP,%ecx,4),rIBASE         # ex: addl   (rFP,%ecx,4),rIBASE
5617     SET_VREG_WORD rIBASE rINST 0        # v[AA+0] <- rIBASE
5619     UNSPILL(rIBASE)                     # restore rIBASE
5644     SPILL(rIBASE)
5656     leal      (%ecx,rIBASE),rIBASE # full result now in rIBASE:%eax
5659     movl      rIBASE,4(rFP,rINST,4)# v[B+1]<- rIBASE
5660     UNSPILL(rIBASE)
5671     SPILL(rIBASE)                      # save rIBASE/%edx
5672     GET_VREG_WORD rIBASE %eax 0
5674     movl     rIBASE,OUT_ARG2(%esp)
5680     GET_VREG_WORD rIBASE %ecx 0
5684     movl     rIBASE,OUT_ARG0(%esp)
5688     SET_VREG_WORD rIBASE rINST 1
5689     UNSPILL(rIBASE)                 # restore rIBASE/%edx
5696     testl   rIBASE,rIBASE
5700     testl   rIBASE,%eax
5702     GET_VREG_WORD rIBASE %ecx 0
5704     testl    rIBASE,rIBASE
5710     movl     $0x80000000,rIBASE
5720     SPILL(rIBASE)                      # save rIBASE/%edx
5721     GET_VREG_WORD rIBASE %eax 0
5723     movl     rIBASE,OUT_ARG2(%esp)
5729     GET_VREG_WORD rIBASE %ecx 0
5733     movl     rIBASE,OUT_ARG0(%esp)
5737     SET_VREG_WORD rIBASE rINST 1
5738     UNSPILL(rIBASE)                 # restore rIBASE/%edx
5745     testl   rIBASE,rIBASE
5749     testl   rIBASE,%eax
5751     GET_VREG_WORD rIBASE %ecx 0
5753     testl    rIBASE,rIBASE
5759     movl     $0,rIBASE
5774     SPILL(rIBASE)                       # save rIBASE
5775     GET_VREG_WORD rIBASE %eax 0         # rIBASE<- v[BB+0]
5777     andl (rFP,%ecx,4),rIBASE         # ex: addl   (rFP,%ecx,4),rIBASE
5779     SET_VREG_WORD rIBASE rINST 0        # v[AA+0] <- rIBASE
5781     UNSPILL(rIBASE)                     # restore rIBASE
5798     SPILL(rIBASE)                       # save rIBASE
5799     GET_VREG_WORD rIBASE %eax 0         # rIBASE<- v[BB+0]
5801     orl (rFP,%ecx,4),rIBASE         # ex: addl   (rFP,%ecx,4),rIBASE
5803     SET_VREG_WORD rIBASE rINST 0        # v[AA+0] <- rIBASE
5805     UNSPILL(rIBASE)                     # restore rIBASE
5822     SPILL(rIBASE)                       # save rIBASE
5823     GET_VREG_WORD rIBASE %eax 0         # rIBASE<- v[BB+0]
5825     xorl (rFP,%ecx,4),rIBASE         # ex: addl   (rFP,%ecx,4),rIBASE
5827     SET_VREG_WORD rIBASE rINST 0        # v[AA+0] <- rIBASE
5829     UNSPILL(rIBASE)                     # restore rIBASE
5852     SPILL(rIBASE)
5853     GET_VREG_WORD rIBASE %eax 1         # ecx<- v[BB+1]
5856     shldl     %eax,rIBASE
5860     movl      %eax,rIBASE
5863     SET_VREG_WORD rIBASE rINST 1        # v[AA+1]<- rIBASE
5865     UNSPILL(rIBASE)
5883     /* Need to spill rIBASE */
5887     SPILL(rIBASE)
5888     GET_VREG_WORD rIBASE %eax 1         # rIBASE<- v[BB+1]
5891     shrdl     rIBASE,%eax
5892     sarl      %cl,rIBASE
5895     movl      rIBASE,%eax
5896     sarl      $31,rIBASE
5898     SET_VREG_WORD rIBASE rINST 1        # v[AA+1]<- rIBASE
5900     UNSPILL(rIBASE)
5918     /* Need to spill rIBASE */
5922     SPILL(rIBASE)
5923     GET_VREG_WORD rIBASE %eax 1         # rIBASE<- v[BB+1]
5926     shrdl     rIBASE,%eax
5927     shrl      %cl,rIBASE
5930     movl      rIBASE,%eax
5931     xorl      rIBASE,rIBASE
5933     SET_VREG_WORD rIBASE rINST 1          # v[AA+1]<- rIBASE
5935     UNSPILL(rIBASE)
6191     SPILL(rIBASE)
6192     imull   (rFP,%ecx,4),%eax         # trashes rIBASE/edx
6193     UNSPILL(rIBASE)
6209     SPILL(rIBASE)
6222     UNSPILL(rIBASE)
6231     UNSPILL(rIBASE)
6247     SPILL(rIBASE)
6258     movl     $0,rIBASE
6259     SET_VREG rIBASE rINST
6260     UNSPILL(rIBASE)
6268     SET_VREG rIBASE rINST
6269     UNSPILL(rIBASE)
6457      * this code.  We must spill %edx (rIBASE) because it
6459      * giving us eax, ebc, ecx and rIBASE as computational
6470     SPILL(rIBASE)
6480     leal      (%ecx,rIBASE),rIBASE     # full result now in %edx:%eax
6481     movl      rIBASE,4(%esi)           # v[A+1]<- rIBASE
6485     UNSPILL(rIBASE)
6497     SPILL(rIBASE)                       # save rIBASE/%edx
6498     GET_VREG_WORD rIBASE %eax 0
6500     movl     rIBASE,OUT_ARG2(%esp)
6506     GET_VREG_WORD rIBASE rINST 0
6510     movl     rIBASE,OUT_ARG0(%esp)
6514     SET_VREG_WORD rIBASE rINST 1
6515     UNSPILL(rIBASE)                    # restore rIBASE/%edx
6522     testl   rIBASE,rIBASE
6526     testl   rIBASE,%eax
6528     GET_VREG_WORD rIBASE rINST 0
6530     testl    rIBASE,rIBASE
6536     movl     $0x80000000,rIBASE
6547     SPILL(rIBASE)                       # save rIBASE/%edx
6548     GET_VREG_WORD rIBASE %eax 0
6550     movl     rIBASE,OUT_ARG2(%esp)
6556     GET_VREG_WORD rIBASE rINST 0
6560     movl     rIBASE,OUT_ARG0(%esp)
6564     SET_VREG_WORD rIBASE rINST 1
6565     UNSPILL(rIBASE)                    # restore rIBASE/%edx
6572     testl   rIBASE,rIBASE
6576     testl   rIBASE,%eax
6578     GET_VREG_WORD rIBASE rINST 0
6580     testl    rIBASE,rIBASE
6586     movl     $0,rIBASE
6659     /* Need to spill rIBASE */
6665     SPILL(rIBASE)
6666     GET_VREG_WORD rIBASE rINST 1       # rIBASE<- v[AA+1]
6668     shldl     %eax,rIBASE
6672     movl      %eax,rIBASE
6675     SET_VREG_WORD rIBASE rINST 1       # v[AA+1]<- rIBASE
6676     UNSPILL(rIBASE)
6691     /* Need to spill rIBASE */
6697     SPILL(rIBASE)
6698     GET_VREG_WORD rIBASE rINST 1   # rIBASE<- v[AA+1]
6700     shrdl     rIBASE,%eax
6701     sarl      %cl,rIBASE
6704     movl      rIBASE,%eax
6705     sarl      $31,rIBASE
6707     SET_VREG_WORD rIBASE rINST 1   # v[AA+1]<- rIBASE
6708     UNSPILL(rIBASE)
6723     /* Need to spill rIBASE */
6729     SPILL(rIBASE)
6730     GET_VREG_WORD rIBASE rINST 1       # rIBASE<- v[AA+1]
6732     shrdl     rIBASE,%eax
6733     shrl      %cl,rIBASE
6736     movl      rIBASE,%eax
6737     xorl      rIBASE,rIBASE
6739     SET_VREG_WORD rIBASE rINST 1       # v[AA+1]<- rIBASE
6741     UNSPILL(rIBASE)
7014     SPILL(rIBASE)
7015     imull     %ecx,%eax                 # trashes rIBASE/edx
7016     UNSPILL(rIBASE)
7033     SPILL(rIBASE)
7046     UNSPILL(rIBASE)
7055     UNSPILL(rIBASE)
7072     SPILL(rIBASE)
7083     movl     $0,rIBASE
7084     SET_VREG rIBASE rINST
7085     UNSPILL(rIBASE)
7093     SET_VREG rIBASE rINST
7094     UNSPILL(rIBASE)
7235     SPILL(rIBASE)
7236     imull     %ecx,%eax                # trashes rIBASE/edx
7237     UNSPILL(rIBASE)
7254     SPILL(rIBASE)
7264     UNSPILL(rIBASE)
7273     UNSPILL(rIBASE)
7290     SPILL(rIBASE)
7298     movl     $0,rIBASE
7299     SET_VREG rIBASE rINST
7300     UNSPILL(rIBASE)
7308     SET_VREG rIBASE rINST
7309     UNSPILL(rIBASE)
7476     SPILL(rIBASE)                               # preserve rIBASE
7477     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
7484     movl    (%eax,rIBASE,4),%eax                # resolved entry
7487     movl    rIBASE,OUT_ARG1(%esp)               # needed by dvmResolveInstField
7488     movl    rSELF,rIBASE
7490     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
7491     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
7493     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
7512     UNSPILL(rIBASE)
7530     SPILL   (rIBASE)
7531     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
7538     movl    (%eax,rIBASE,4),%eax                # resolved entry
7541     movl    rIBASE,OUT_ARG1(%esp)
7542     movl    rSELF,rIBASE
7544     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
7545     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
7547     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
7567     UNSPILL(rIBASE)
7613     SPILL(rIBASE)
7615     UNSPILL(rIBASE)
7620     SPILL(rIBASE)
7622     UNSPILL(rIBASE)
7668     SPILL(rIBASE)
7670     UNSPILL(rIBASE)
7675     SPILL(rIBASE)
7677     UNSPILL(rIBASE)
7692     SPILL(rIBASE)                               # preserve rIBASE
7693     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
7700     movl    (%eax,rIBASE,4),%eax                # resolved entry
7703     movl    rIBASE,OUT_ARG1(%esp)               # needed by dvmResolveInstField
7704     movl    rSELF,rIBASE
7706     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
7707     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
7709     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
7728     UNSPILL(rIBASE)
7742     movl      offThread_curHandlerTable(%ecx),rIBASE  # set up rIBASE
7753     movl      offThread_curHandlerTable(%ecx),rIBASE  # set up rIBASE
7764     movl      offThread_curHandlerTable(%ecx),rIBASE  # set up rIBASE
7775     movl      offThread_curHandlerTable(%ecx),rIBASE  # set up rIBASE
7790     SPILL(rIBASE)
7793     UNSPILL(rIBASE)
7836     SPILL(rIBASE)                       # preserve rIBASE
7844     UNSPILL(rIBASE)                     # restore rIBASE
7861     movzwl    4(rPC),rIBASE
7864     andl      rIBASE,%ecx
7866     sarl      $4,rIBASE
7870     andl      rIBASE,%ecx
7872     sarl      $4,rIBASE
7876     andl      rIBASE,%ecx
7878     sarl      $4,rIBASE
7882     andl      rIBASE,%ecx
7884     sarl      $4,rIBASE
7919     UNSPILL(rIBASE)                     # restore rIBASE
7935     movl      offThread_curHandlerTable(%ecx),rIBASE  # set up rIBASE
7946     movl      offThread_curHandlerTable(%ecx),rIBASE  # set up rIBASE
7957     movl      offThread_curHandlerTable(%ecx),rIBASE  # set up rIBASE
8204     SPILL(rIBASE)
8205     movzwl  2(rPC),rIBASE                       # rIBASE<- 0000CCCC
8212     movl    (%eax,rIBASE,4),%eax                  # resolved entry
8215     movl    rIBASE,OUT_ARG1(%esp)
8216     movl    rSELF,rIBASE
8218     movl    offThread_method(rIBASE),rIBASE     # rIBASE<- current method
8219     movl    offMethod_clazz(rIBASE),rIBASE      # rIBASE<- method->clazz
8221     movl    rIBASE,OUT_ARG0(%esp)               # pass in method->clazz
8233      *   rIBASE is scratch, but needs to be unspilled
8248     UNSPILL(rIBASE)
8295     SPILL(rIBASE)
8297     UNSPILL(rIBASE)
8302     SPILL(rIBASE)
8304     UNSPILL(rIBASE)
8354     SPILL(rIBASE)
8356     UNSPILL(rIBASE)
8361     SPILL(rIBASE)
8363     UNSPILL(rIBASE)
8391  * because rIBASE is caller save and we need to reload it.
8394  * here with a zero breakFlag because we always refresh rIBASE on
8402     je     1f                                # reload rIBASE & resume if not
8407     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8417  * because rIBASE is caller save and we need to reload it.
8420  * here with a zero breakFlag because we always refresh rIBASE on
8428     je     1f                                # reload rIBASE & resume if not
8433     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8443  * because rIBASE is caller save and we need to reload it.
8446  * here with a zero breakFlag because we always refresh rIBASE on
8454     je     1f                                # reload rIBASE & resume if not
8459     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8469  * because rIBASE is caller save and we need to reload it.
8472  * here with a zero breakFlag because we always refresh rIBASE on
8480     je     1f                                # reload rIBASE & resume if not
8485     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8495  * because rIBASE is caller save and we need to reload it.
8498  * here with a zero breakFlag because we always refresh rIBASE on
8506     je     1f                                # reload rIBASE & resume if not
8511     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8521  * because rIBASE is caller save and we need to reload it.
8524  * here with a zero breakFlag because we always refresh rIBASE on
8532     je     1f                                # reload rIBASE & resume if not
8537     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8547  * because rIBASE is caller save and we need to reload it.
8550  * here with a zero breakFlag because we always refresh rIBASE on
8558     je     1f                                # reload rIBASE & resume if not
8563     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8573  * because rIBASE is caller save and we need to reload it.
8576  * here with a zero breakFlag because we always refresh rIBASE on
8584     je     1f                                # reload rIBASE & resume if not
8589     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8599  * because rIBASE is caller save and we need to reload it.
8602  * here with a zero breakFlag because we always refresh rIBASE on
8610     je     1f                                # reload rIBASE & resume if not
8615     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8625  * because rIBASE is caller save and we need to reload it.
8628  * here with a zero breakFlag because we always refresh rIBASE on
8636     je     1f                                # reload rIBASE & resume if not
8641     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8651  * because rIBASE is caller save and we need to reload it.
8654  * here with a zero breakFlag because we always refresh rIBASE on
8662     je     1f                                # reload rIBASE & resume if not
8667     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8677  * because rIBASE is caller save and we need to reload it.
8680  * here with a zero breakFlag because we always refresh rIBASE on
8688     je     1f                                # reload rIBASE & resume if not
8693     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8703  * because rIBASE is caller save and we need to reload it.
8706  * here with a zero breakFlag because we always refresh rIBASE on
8714     je     1f                                # reload rIBASE & resume if not
8719     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8729  * because rIBASE is caller save and we need to reload it.
8732  * here with a zero breakFlag because we always refresh rIBASE on
8740     je     1f                                # reload rIBASE & resume if not
8745     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8755  * because rIBASE is caller save and we need to reload it.
8758  * here with a zero breakFlag because we always refresh rIBASE on
8766     je     1f                                # reload rIBASE & resume if not
8771     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8781  * because rIBASE is caller save and we need to reload it.
8784  * here with a zero breakFlag because we always refresh rIBASE on
8792     je     1f                                # reload rIBASE & resume if not
8797     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8807  * because rIBASE is caller save and we need to reload it.
8810  * here with a zero breakFlag because we always refresh rIBASE on
8818     je     1f                                # reload rIBASE & resume if not
8823     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8833  * because rIBASE is caller save and we need to reload it.
8836  * here with a zero breakFlag because we always refresh rIBASE on
8844     je     1f                                # reload rIBASE & resume if not
8849     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8859  * because rIBASE is caller save and we need to reload it.
8862  * here with a zero breakFlag because we always refresh rIBASE on
8870     je     1f                                # reload rIBASE & resume if not
8875     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8885  * because rIBASE is caller save and we need to reload it.
8888  * here with a zero breakFlag because we always refresh rIBASE on
8896     je     1f                                # reload rIBASE & resume if not
8901     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8911  * because rIBASE is caller save and we need to reload it.
8914  * here with a zero breakFlag because we always refresh rIBASE on
8922     je     1f                                # reload rIBASE & resume if not
8927     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8937  * because rIBASE is caller save and we need to reload it.
8940  * here with a zero breakFlag because we always refresh rIBASE on
8948     je     1f                                # reload rIBASE & resume if not
8953     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8963  * because rIBASE is caller save and we need to reload it.
8966  * here with a zero breakFlag because we always refresh rIBASE on
8974     je     1f                                # reload rIBASE & resume if not
8979     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
8989  * because rIBASE is caller save and we need to reload it.
8992  * here with a zero breakFlag because we always refresh rIBASE on
9000     je     1f                                # reload rIBASE & resume if not
9005     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9015  * because rIBASE is caller save and we need to reload it.
9018  * here with a zero breakFlag because we always refresh rIBASE on
9026     je     1f                                # reload rIBASE & resume if not
9031     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9041  * because rIBASE is caller save and we need to reload it.
9044  * here with a zero breakFlag because we always refresh rIBASE on
9052     je     1f                                # reload rIBASE & resume if not
9057     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9067  * because rIBASE is caller save and we need to reload it.
9070  * here with a zero breakFlag because we always refresh rIBASE on
9078     je     1f                                # reload rIBASE & resume if not
9083     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9093  * because rIBASE is caller save and we need to reload it.
9096  * here with a zero breakFlag because we always refresh rIBASE on
9104     je     1f                                # reload rIBASE & resume if not
9109     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9119  * because rIBASE is caller save and we need to reload it.
9122  * here with a zero breakFlag because we always refresh rIBASE on
9130     je     1f                                # reload rIBASE & resume if not
9135     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9145  * because rIBASE is caller save and we need to reload it.
9148  * here with a zero breakFlag because we always refresh rIBASE on
9156     je     1f                                # reload rIBASE & resume if not
9161     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9171  * because rIBASE is caller save and we need to reload it.
9174  * here with a zero breakFlag because we always refresh rIBASE on
9182     je     1f                                # reload rIBASE & resume if not
9187     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9197  * because rIBASE is caller save and we need to reload it.
9200  * here with a zero breakFlag because we always refresh rIBASE on
9208     je     1f                                # reload rIBASE & resume if not
9213     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9223  * because rIBASE is caller save and we need to reload it.
9226  * here with a zero breakFlag because we always refresh rIBASE on
9234     je     1f                                # reload rIBASE & resume if not
9239     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9249  * because rIBASE is caller save and we need to reload it.
9252  * here with a zero breakFlag because we always refresh rIBASE on
9260     je     1f                                # reload rIBASE & resume if not
9265     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9275  * because rIBASE is caller save and we need to reload it.
9278  * here with a zero breakFlag because we always refresh rIBASE on
9286     je     1f                                # reload rIBASE & resume if not
9291     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9301  * because rIBASE is caller save and we need to reload it.
9304  * here with a zero breakFlag because we always refresh rIBASE on
9312     je     1f                                # reload rIBASE & resume if not
9317     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9327  * because rIBASE is caller save and we need to reload it.
9330  * here with a zero breakFlag because we always refresh rIBASE on
9338     je     1f                                # reload rIBASE & resume if not
9343     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9353  * because rIBASE is caller save and we need to reload it.
9356  * here with a zero breakFlag because we always refresh rIBASE on
9364     je     1f                                # reload rIBASE & resume if not
9369     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9379  * because rIBASE is caller save and we need to reload it.
9382  * here with a zero breakFlag because we always refresh rIBASE on
9390     je     1f                                # reload rIBASE & resume if not
9395     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9405  * because rIBASE is caller save and we need to reload it.
9408  * here with a zero breakFlag because we always refresh rIBASE on
9416     je     1f                                # reload rIBASE & resume if not
9421     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9431  * because rIBASE is caller save and we need to reload it.
9434  * here with a zero breakFlag because we always refresh rIBASE on
9442     je     1f                                # reload rIBASE & resume if not
9447     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9457  * because rIBASE is caller save and we need to reload it.
9460  * here with a zero breakFlag because we always refresh rIBASE on
9468     je     1f                                # reload rIBASE & resume if not
9473     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9483  * because rIBASE is caller save and we need to reload it.
9486  * here with a zero breakFlag because we always refresh rIBASE on
9494     je     1f                                # reload rIBASE & resume if not
9499     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9509  * because rIBASE is caller save and we need to reload it.
9512  * here with a zero breakFlag because we always refresh rIBASE on
9520     je     1f                                # reload rIBASE & resume if not
9525     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9535  * because rIBASE is caller save and we need to reload it.
9538  * here with a zero breakFlag because we always refresh rIBASE on
9546     je     1f                                # reload rIBASE & resume if not
9551     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9561  * because rIBASE is caller save and we need to reload it.
9564  * here with a zero breakFlag because we always refresh rIBASE on
9572     je     1f                                # reload rIBASE & resume if not
9577     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9587  * because rIBASE is caller save and we need to reload it.
9590  * here with a zero breakFlag because we always refresh rIBASE on
9598     je     1f                                # reload rIBASE & resume if not
9603     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9613  * because rIBASE is caller save and we need to reload it.
9616  * here with a zero breakFlag because we always refresh rIBASE on
9624     je     1f                                # reload rIBASE & resume if not
9629     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9639  * because rIBASE is caller save and we need to reload it.
9642  * here with a zero breakFlag because we always refresh rIBASE on
9650     je     1f                                # reload rIBASE & resume if not
9655     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9665  * because rIBASE is caller save and we need to reload it.
9668  * here with a zero breakFlag because we always refresh rIBASE on
9676     je     1f                                # reload rIBASE & resume if not
9681     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9691  * because rIBASE is caller save and we need to reload it.
9694  * here with a zero breakFlag because we always refresh rIBASE on
9702     je     1f                                # reload rIBASE & resume if not
9707     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9717  * because rIBASE is caller save and we need to reload it.
9720  * here with a zero breakFlag because we always refresh rIBASE on
9728     je     1f                                # reload rIBASE & resume if not
9733     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9743  * because rIBASE is caller save and we need to reload it.
9746  * here with a zero breakFlag because we always refresh rIBASE on
9754     je     1f                                # reload rIBASE & resume if not
9759     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9769  * because rIBASE is caller save and we need to reload it.
9772  * here with a zero breakFlag because we always refresh rIBASE on
9780     je     1f                                # reload rIBASE & resume if not
9785     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9795  * because rIBASE is caller save and we need to reload it.
9798  * here with a zero breakFlag because we always refresh rIBASE on
9806     je     1f                                # reload rIBASE & resume if not
9811     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9821  * because rIBASE is caller save and we need to reload it.
9824  * here with a zero breakFlag because we always refresh rIBASE on
9832     je     1f                                # reload rIBASE & resume if not
9837     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9847  * because rIBASE is caller save and we need to reload it.
9850  * here with a zero breakFlag because we always refresh rIBASE on
9858     je     1f                                # reload rIBASE & resume if not
9863     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9873  * because rIBASE is caller save and we need to reload it.
9876  * here with a zero breakFlag because we always refresh rIBASE on
9884     je     1f                                # reload rIBASE & resume if not
9889     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9899  * because rIBASE is caller save and we need to reload it.
9902  * here with a zero breakFlag because we always refresh rIBASE on
9910     je     1f                                # reload rIBASE & resume if not
9915     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9925  * because rIBASE is caller save and we need to reload it.
9928  * here with a zero breakFlag because we always refresh rIBASE on
9936     je     1f                                # reload rIBASE & resume if not
9941     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9951  * because rIBASE is caller save and we need to reload it.
9954  * here with a zero breakFlag because we always refresh rIBASE on
9962     je     1f                                # reload rIBASE & resume if not
9967     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
9977  * because rIBASE is caller save and we need to reload it.
9980  * here with a zero breakFlag because we always refresh rIBASE on
9988     je     1f                                # reload rIBASE & resume if not
9993     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10003  * because rIBASE is caller save and we need to reload it.
10006  * here with a zero breakFlag because we always refresh rIBASE on
10014     je     1f                                # reload rIBASE & resume if not
10019     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10029  * because rIBASE is caller save and we need to reload it.
10032  * here with a zero breakFlag because we always refresh rIBASE on
10040     je     1f                                # reload rIBASE & resume if not
10045     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10055  * because rIBASE is caller save and we need to reload it.
10058  * here with a zero breakFlag because we always refresh rIBASE on
10066     je     1f                                # reload rIBASE & resume if not
10071     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10081  * because rIBASE is caller save and we need to reload it.
10084  * here with a zero breakFlag because we always refresh rIBASE on
10092     je     1f                                # reload rIBASE & resume if not
10097     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10107  * because rIBASE is caller save and we need to reload it.
10110  * here with a zero breakFlag because we always refresh rIBASE on
10118     je     1f                                # reload rIBASE & resume if not
10123     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10133  * because rIBASE is caller save and we need to reload it.
10136  * here with a zero breakFlag because we always refresh rIBASE on
10144     je     1f                                # reload rIBASE & resume if not
10149     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10159  * because rIBASE is caller save and we need to reload it.
10162  * here with a zero breakFlag because we always refresh rIBASE on
10170     je     1f                                # reload rIBASE & resume if not
10175     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10185  * because rIBASE is caller save and we need to reload it.
10188  * here with a zero breakFlag because we always refresh rIBASE on
10196     je     1f                                # reload rIBASE & resume if not
10201     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10211  * because rIBASE is caller save and we need to reload it.
10214  * here with a zero breakFlag because we always refresh rIBASE on
10222     je     1f                                # reload rIBASE & resume if not
10227     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10237  * because rIBASE is caller save and we need to reload it.
10240  * here with a zero breakFlag because we always refresh rIBASE on
10248     je     1f                                # reload rIBASE & resume if not
10253     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10263  * because rIBASE is caller save and we need to reload it.
10266  * here with a zero breakFlag because we always refresh rIBASE on
10274     je     1f                                # reload rIBASE & resume if not
10279     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10289  * because rIBASE is caller save and we need to reload it.
10292  * here with a zero breakFlag because we always refresh rIBASE on
10300     je     1f                                # reload rIBASE & resume if not
10305     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10315  * because rIBASE is caller save and we need to reload it.
10318  * here with a zero breakFlag because we always refresh rIBASE on
10326     je     1f                                # reload rIBASE & resume if not
10331     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10341  * because rIBASE is caller save and we need to reload it.
10344  * here with a zero breakFlag because we always refresh rIBASE on
10352     je     1f                                # reload rIBASE & resume if not
10357     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10367  * because rIBASE is caller save and we need to reload it.
10370  * here with a zero breakFlag because we always refresh rIBASE on
10378     je     1f                                # reload rIBASE & resume if not
10383     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10393  * because rIBASE is caller save and we need to reload it.
10396  * here with a zero breakFlag because we always refresh rIBASE on
10404     je     1f                                # reload rIBASE & resume if not
10409     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10419  * because rIBASE is caller save and we need to reload it.
10422  * here with a zero breakFlag because we always refresh rIBASE on
10430     je     1f                                # reload rIBASE & resume if not
10435     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10445  * because rIBASE is caller save and we need to reload it.
10448  * here with a zero breakFlag because we always refresh rIBASE on
10456     je     1f                                # reload rIBASE & resume if not
10461     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10471  * because rIBASE is caller save and we need to reload it.
10474  * here with a zero breakFlag because we always refresh rIBASE on
10482     je     1f                                # reload rIBASE & resume if not
10487     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10497  * because rIBASE is caller save and we need to reload it.
10500  * here with a zero breakFlag because we always refresh rIBASE on
10508     je     1f                                # reload rIBASE & resume if not
10513     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10523  * because rIBASE is caller save and we need to reload it.
10526  * here with a zero breakFlag because we always refresh rIBASE on
10534     je     1f                                # reload rIBASE & resume if not
10539     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10549  * because rIBASE is caller save and we need to reload it.
10552  * here with a zero breakFlag because we always refresh rIBASE on
10560     je     1f                                # reload rIBASE & resume if not
10565     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10575  * because rIBASE is caller save and we need to reload it.
10578  * here with a zero breakFlag because we always refresh rIBASE on
10586     je     1f                                # reload rIBASE & resume if not
10591     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10601  * because rIBASE is caller save and we need to reload it.
10604  * here with a zero breakFlag because we always refresh rIBASE on
10612     je     1f                                # reload rIBASE & resume if not
10617     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10627  * because rIBASE is caller save and we need to reload it.
10630  * here with a zero breakFlag because we always refresh rIBASE on
10638     je     1f                                # reload rIBASE & resume if not
10643     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10653  * because rIBASE is caller save and we need to reload it.
10656  * here with a zero breakFlag because we always refresh rIBASE on
10664     je     1f                                # reload rIBASE & resume if not
10669     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10679  * because rIBASE is caller save and we need to reload it.
10682  * here with a zero breakFlag because we always refresh rIBASE on
10690     je     1f                                # reload rIBASE & resume if not
10695     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10705  * because rIBASE is caller save and we need to reload it.
10708  * here with a zero breakFlag because we always refresh rIBASE on
10716     je     1f                                # reload rIBASE & resume if not
10721     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10731  * because rIBASE is caller save and we need to reload it.
10734  * here with a zero breakFlag because we always refresh rIBASE on
10742     je     1f                                # reload rIBASE & resume if not
10747     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10757  * because rIBASE is caller save and we need to reload it.
10760  * here with a zero breakFlag because we always refresh rIBASE on
10768     je     1f                                # reload rIBASE & resume if not
10773     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10783  * because rIBASE is caller save and we need to reload it.
10786  * here with a zero breakFlag because we always refresh rIBASE on
10794     je     1f                                # reload rIBASE & resume if not
10799     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10809  * because rIBASE is caller save and we need to reload it.
10812  * here with a zero breakFlag because we always refresh rIBASE on
10820     je     1f                                # reload rIBASE & resume if not
10825     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10835  * because rIBASE is caller save and we need to reload it.
10838  * here with a zero breakFlag because we always refresh rIBASE on
10846     je     1f                                # reload rIBASE & resume if not
10851     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10861  * because rIBASE is caller save and we need to reload it.
10864  * here with a zero breakFlag because we always refresh rIBASE on
10872     je     1f                                # reload rIBASE & resume if not
10877     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10887  * because rIBASE is caller save and we need to reload it.
10890  * here with a zero breakFlag because we always refresh rIBASE on
10898     je     1f                                # reload rIBASE & resume if not
10903     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10913  * because rIBASE is caller save and we need to reload it.
10916  * here with a zero breakFlag because we always refresh rIBASE on
10924     je     1f                                # reload rIBASE & resume if not
10929     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10939  * because rIBASE is caller save and we need to reload it.
10942  * here with a zero breakFlag because we always refresh rIBASE on
10950     je     1f                                # reload rIBASE & resume if not
10955     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10965  * because rIBASE is caller save and we need to reload it.
10968  * here with a zero breakFlag because we always refresh rIBASE on
10976     je     1f                                # reload rIBASE & resume if not
10981     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
10991  * because rIBASE is caller save and we need to reload it.
10994  * here with a zero breakFlag because we always refresh rIBASE on
11002     je     1f                                # reload rIBASE & resume if not
11007     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11017  * because rIBASE is caller save and we need to reload it.
11020  * here with a zero breakFlag because we always refresh rIBASE on
11028     je     1f                                # reload rIBASE & resume if not
11033     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11043  * because rIBASE is caller save and we need to reload it.
11046  * here with a zero breakFlag because we always refresh rIBASE on
11054     je     1f                                # reload rIBASE & resume if not
11059     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11069  * because rIBASE is caller save and we need to reload it.
11072  * here with a zero breakFlag because we always refresh rIBASE on
11080     je     1f                                # reload rIBASE & resume if not
11085     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11095  * because rIBASE is caller save and we need to reload it.
11098  * here with a zero breakFlag because we always refresh rIBASE on
11106     je     1f                                # reload rIBASE & resume if not
11111     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11121  * because rIBASE is caller save and we need to reload it.
11124  * here with a zero breakFlag because we always refresh rIBASE on
11132     je     1f                                # reload rIBASE & resume if not
11137     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11147  * because rIBASE is caller save and we need to reload it.
11150  * here with a zero breakFlag because we always refresh rIBASE on
11158     je     1f                                # reload rIBASE & resume if not
11163     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11173  * because rIBASE is caller save and we need to reload it.
11176  * here with a zero breakFlag because we always refresh rIBASE on
11184     je     1f                                # reload rIBASE & resume if not
11189     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11199  * because rIBASE is caller save and we need to reload it.
11202  * here with a zero breakFlag because we always refresh rIBASE on
11210     je     1f                                # reload rIBASE & resume if not
11215     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11225  * because rIBASE is caller save and we need to reload it.
11228  * here with a zero breakFlag because we always refresh rIBASE on
11236     je     1f                                # reload rIBASE & resume if not
11241     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11251  * because rIBASE is caller save and we need to reload it.
11254  * here with a zero breakFlag because we always refresh rIBASE on
11262     je     1f                                # reload rIBASE & resume if not
11267     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11277  * because rIBASE is caller save and we need to reload it.
11280  * here with a zero breakFlag because we always refresh rIBASE on
11288     je     1f                                # reload rIBASE & resume if not
11293     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11303  * because rIBASE is caller save and we need to reload it.
11306  * here with a zero breakFlag because we always refresh rIBASE on
11314     je     1f                                # reload rIBASE & resume if not
11319     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11329  * because rIBASE is caller save and we need to reload it.
11332  * here with a zero breakFlag because we always refresh rIBASE on
11340     je     1f                                # reload rIBASE & resume if not
11345     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11355  * because rIBASE is caller save and we need to reload it.
11358  * here with a zero breakFlag because we always refresh rIBASE on
11366     je     1f                                # reload rIBASE & resume if not
11371     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11381  * because rIBASE is caller save and we need to reload it.
11384  * here with a zero breakFlag because we always refresh rIBASE on
11392     je     1f                                # reload rIBASE & resume if not
11397     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11407  * because rIBASE is caller save and we need to reload it.
11410  * here with a zero breakFlag because we always refresh rIBASE on
11418     je     1f                                # reload rIBASE & resume if not
11423     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11433  * because rIBASE is caller save and we need to reload it.
11436  * here with a zero breakFlag because we always refresh rIBASE on
11444     je     1f                                # reload rIBASE & resume if not
11449     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11459  * because rIBASE is caller save and we need to reload it.
11462  * here with a zero breakFlag because we always refresh rIBASE on
11470     je     1f                                # reload rIBASE & resume if not
11475     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11485  * because rIBASE is caller save and we need to reload it.
11488  * here with a zero breakFlag because we always refresh rIBASE on
11496     je     1f                                # reload rIBASE & resume if not
11501     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11511  * because rIBASE is caller save and we need to reload it.
11514  * here with a zero breakFlag because we always refresh rIBASE on
11522     je     1f                                # reload rIBASE & resume if not
11527     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11537  * because rIBASE is caller save and we need to reload it.
11540  * here with a zero breakFlag because we always refresh rIBASE on
11548     je     1f                                # reload rIBASE & resume if not
11553     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11563  * because rIBASE is caller save and we need to reload it.
11566  * here with a zero breakFlag because we always refresh rIBASE on
11574     je     1f                                # reload rIBASE & resume if not
11579     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11589  * because rIBASE is caller save and we need to reload it.
11592  * here with a zero breakFlag because we always refresh rIBASE on
11600     je     1f                                # reload rIBASE & resume if not
11605     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11615  * because rIBASE is caller save and we need to reload it.
11618  * here with a zero breakFlag because we always refresh rIBASE on
11626     je     1f                                # reload rIBASE & resume if not
11631     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11641  * because rIBASE is caller save and we need to reload it.
11644  * here with a zero breakFlag because we always refresh rIBASE on
11652     je     1f                                # reload rIBASE & resume if not
11657     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11667  * because rIBASE is caller save and we need to reload it.
11670  * here with a zero breakFlag because we always refresh rIBASE on
11678     je     1f                                # reload rIBASE & resume if not
11683     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11693  * because rIBASE is caller save and we need to reload it.
11696  * here with a zero breakFlag because we always refresh rIBASE on
11704     je     1f                                # reload rIBASE & resume if not
11709     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11719  * because rIBASE is caller save and we need to reload it.
11722  * here with a zero breakFlag because we always refresh rIBASE on
11730     je     1f                                # reload rIBASE & resume if not
11735     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11745  * because rIBASE is caller save and we need to reload it.
11748  * here with a zero breakFlag because we always refresh rIBASE on
11756     je     1f                                # reload rIBASE & resume if not
11761     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11771  * because rIBASE is caller save and we need to reload it.
11774  * here with a zero breakFlag because we always refresh rIBASE on
11782     je     1f                                # reload rIBASE & resume if not
11787     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11797  * because rIBASE is caller save and we need to reload it.
11800  * here with a zero breakFlag because we always refresh rIBASE on
11808     je     1f                                # reload rIBASE & resume if not
11813     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11823  * because rIBASE is caller save and we need to reload it.
11826  * here with a zero breakFlag because we always refresh rIBASE on
11834     je     1f                                # reload rIBASE & resume if not
11839     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11849  * because rIBASE is caller save and we need to reload it.
11852  * here with a zero breakFlag because we always refresh rIBASE on
11860     je     1f                                # reload rIBASE & resume if not
11865     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11875  * because rIBASE is caller save and we need to reload it.
11878  * here with a zero breakFlag because we always refresh rIBASE on
11886     je     1f                                # reload rIBASE & resume if not
11891     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11901  * because rIBASE is caller save and we need to reload it.
11904  * here with a zero breakFlag because we always refresh rIBASE on
11912     je     1f                                # reload rIBASE & resume if not
11917     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11927  * because rIBASE is caller save and we need to reload it.
11930  * here with a zero breakFlag because we always refresh rIBASE on
11938     je     1f                                # reload rIBASE & resume if not
11943     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11953  * because rIBASE is caller save and we need to reload it.
11956  * here with a zero breakFlag because we always refresh rIBASE on
11964     je     1f                                # reload rIBASE & resume if not
11969     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
11979  * because rIBASE is caller save and we need to reload it.
11982  * here with a zero breakFlag because we always refresh rIBASE on
11990     je     1f                                # reload rIBASE & resume if not
11995     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12005  * because rIBASE is caller save and we need to reload it.
12008  * here with a zero breakFlag because we always refresh rIBASE on
12016     je     1f                                # reload rIBASE & resume if not
12021     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12031  * because rIBASE is caller save and we need to reload it.
12034  * here with a zero breakFlag because we always refresh rIBASE on
12042     je     1f                                # reload rIBASE & resume if not
12047     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12057  * because rIBASE is caller save and we need to reload it.
12060  * here with a zero breakFlag because we always refresh rIBASE on
12068     je     1f                                # reload rIBASE & resume if not
12073     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12083  * because rIBASE is caller save and we need to reload it.
12086  * here with a zero breakFlag because we always refresh rIBASE on
12094     je     1f                                # reload rIBASE & resume if not
12099     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12109  * because rIBASE is caller save and we need to reload it.
12112  * here with a zero breakFlag because we always refresh rIBASE on
12120     je     1f                                # reload rIBASE & resume if not
12125     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12135  * because rIBASE is caller save and we need to reload it.
12138  * here with a zero breakFlag because we always refresh rIBASE on
12146     je     1f                                # reload rIBASE & resume if not
12151     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12161  * because rIBASE is caller save and we need to reload it.
12164  * here with a zero breakFlag because we always refresh rIBASE on
12172     je     1f                                # reload rIBASE & resume if not
12177     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12187  * because rIBASE is caller save and we need to reload it.
12190  * here with a zero breakFlag because we always refresh rIBASE on
12198     je     1f                                # reload rIBASE & resume if not
12203     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12213  * because rIBASE is caller save and we need to reload it.
12216  * here with a zero breakFlag because we always refresh rIBASE on
12224     je     1f                                # reload rIBASE & resume if not
12229     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12239  * because rIBASE is caller save and we need to reload it.
12242  * here with a zero breakFlag because we always refresh rIBASE on
12250     je     1f                                # reload rIBASE & resume if not
12255     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12265  * because rIBASE is caller save and we need to reload it.
12268  * here with a zero breakFlag because we always refresh rIBASE on
12276     je     1f                                # reload rIBASE & resume if not
12281     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12291  * because rIBASE is caller save and we need to reload it.
12294  * here with a zero breakFlag because we always refresh rIBASE on
12302     je     1f                                # reload rIBASE & resume if not
12307     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12317  * because rIBASE is caller save and we need to reload it.
12320  * here with a zero breakFlag because we always refresh rIBASE on
12328     je     1f                                # reload rIBASE & resume if not
12333     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12343  * because rIBASE is caller save and we need to reload it.
12346  * here with a zero breakFlag because we always refresh rIBASE on
12354     je     1f                                # reload rIBASE & resume if not
12359     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12369  * because rIBASE is caller save and we need to reload it.
12372  * here with a zero breakFlag because we always refresh rIBASE on
12380     je     1f                                # reload rIBASE & resume if not
12385     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12395  * because rIBASE is caller save and we need to reload it.
12398  * here with a zero breakFlag because we always refresh rIBASE on
12406     je     1f                                # reload rIBASE & resume if not
12411     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12421  * because rIBASE is caller save and we need to reload it.
12424  * here with a zero breakFlag because we always refresh rIBASE on
12432     je     1f                                # reload rIBASE & resume if not
12437     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12447  * because rIBASE is caller save and we need to reload it.
12450  * here with a zero breakFlag because we always refresh rIBASE on
12458     je     1f                                # reload rIBASE & resume if not
12463     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12473  * because rIBASE is caller save and we need to reload it.
12476  * here with a zero breakFlag because we always refresh rIBASE on
12484     je     1f                                # reload rIBASE & resume if not
12489     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12499  * because rIBASE is caller save and we need to reload it.
12502  * here with a zero breakFlag because we always refresh rIBASE on
12510     je     1f                                # reload rIBASE & resume if not
12515     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12525  * because rIBASE is caller save and we need to reload it.
12528  * here with a zero breakFlag because we always refresh rIBASE on
12536     je     1f                                # reload rIBASE & resume if not
12541     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12551  * because rIBASE is caller save and we need to reload it.
12554  * here with a zero breakFlag because we always refresh rIBASE on
12562     je     1f                                # reload rIBASE & resume if not
12567     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12577  * because rIBASE is caller save and we need to reload it.
12580  * here with a zero breakFlag because we always refresh rIBASE on
12588     je     1f                                # reload rIBASE & resume if not
12593     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12603  * because rIBASE is caller save and we need to reload it.
12606  * here with a zero breakFlag because we always refresh rIBASE on
12614     je     1f                                # reload rIBASE & resume if not
12619     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12629  * because rIBASE is caller save and we need to reload it.
12632  * here with a zero breakFlag because we always refresh rIBASE on
12640     je     1f                                # reload rIBASE & resume if not
12645     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12655  * because rIBASE is caller save and we need to reload it.
12658  * here with a zero breakFlag because we always refresh rIBASE on
12666     je     1f                                # reload rIBASE & resume if not
12671     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12681  * because rIBASE is caller save and we need to reload it.
12684  * here with a zero breakFlag because we always refresh rIBASE on
12692     je     1f                                # reload rIBASE & resume if not
12697     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12707  * because rIBASE is caller save and we need to reload it.
12710  * here with a zero breakFlag because we always refresh rIBASE on
12718     je     1f                                # reload rIBASE & resume if not
12723     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12733  * because rIBASE is caller save and we need to reload it.
12736  * here with a zero breakFlag because we always refresh rIBASE on
12744     je     1f                                # reload rIBASE & resume if not
12749     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12759  * because rIBASE is caller save and we need to reload it.
12762  * here with a zero breakFlag because we always refresh rIBASE on
12770     je     1f                                # reload rIBASE & resume if not
12775     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12785  * because rIBASE is caller save and we need to reload it.
12788  * here with a zero breakFlag because we always refresh rIBASE on
12796     je     1f                                # reload rIBASE & resume if not
12801     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12811  * because rIBASE is caller save and we need to reload it.
12814  * here with a zero breakFlag because we always refresh rIBASE on
12822     je     1f                                # reload rIBASE & resume if not
12827     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12837  * because rIBASE is caller save and we need to reload it.
12840  * here with a zero breakFlag because we always refresh rIBASE on
12848     je     1f                                # reload rIBASE & resume if not
12853     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12863  * because rIBASE is caller save and we need to reload it.
12866  * here with a zero breakFlag because we always refresh rIBASE on
12874     je     1f                                # reload rIBASE & resume if not
12879     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12889  * because rIBASE is caller save and we need to reload it.
12892  * here with a zero breakFlag because we always refresh rIBASE on
12900     je     1f                                # reload rIBASE & resume if not
12905     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12915  * because rIBASE is caller save and we need to reload it.
12918  * here with a zero breakFlag because we always refresh rIBASE on
12926     je     1f                                # reload rIBASE & resume if not
12931     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12941  * because rIBASE is caller save and we need to reload it.
12944  * here with a zero breakFlag because we always refresh rIBASE on
12952     je     1f                                # reload rIBASE & resume if not
12957     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12967  * because rIBASE is caller save and we need to reload it.
12970  * here with a zero breakFlag because we always refresh rIBASE on
12978     je     1f                                # reload rIBASE & resume if not
12983     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
12993  * because rIBASE is caller save and we need to reload it.
12996  * here with a zero breakFlag because we always refresh rIBASE on
13004     je     1f                                # reload rIBASE & resume if not
13009     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13019  * because rIBASE is caller save and we need to reload it.
13022  * here with a zero breakFlag because we always refresh rIBASE on
13030     je     1f                                # reload rIBASE & resume if not
13035     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13045  * because rIBASE is caller save and we need to reload it.
13048  * here with a zero breakFlag because we always refresh rIBASE on
13056     je     1f                                # reload rIBASE & resume if not
13061     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13071  * because rIBASE is caller save and we need to reload it.
13074  * here with a zero breakFlag because we always refresh rIBASE on
13082     je     1f                                # reload rIBASE & resume if not
13087     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13097  * because rIBASE is caller save and we need to reload it.
13100  * here with a zero breakFlag because we always refresh rIBASE on
13108     je     1f                                # reload rIBASE & resume if not
13113     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13123  * because rIBASE is caller save and we need to reload it.
13126  * here with a zero breakFlag because we always refresh rIBASE on
13134     je     1f                                # reload rIBASE & resume if not
13139     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13149  * because rIBASE is caller save and we need to reload it.
13152  * here with a zero breakFlag because we always refresh rIBASE on
13160     je     1f                                # reload rIBASE & resume if not
13165     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13175  * because rIBASE is caller save and we need to reload it.
13178  * here with a zero breakFlag because we always refresh rIBASE on
13186     je     1f                                # reload rIBASE & resume if not
13191     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13201  * because rIBASE is caller save and we need to reload it.
13204  * here with a zero breakFlag because we always refresh rIBASE on
13212     je     1f                                # reload rIBASE & resume if not
13217     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13227  * because rIBASE is caller save and we need to reload it.
13230  * here with a zero breakFlag because we always refresh rIBASE on
13238     je     1f                                # reload rIBASE & resume if not
13243     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13253  * because rIBASE is caller save and we need to reload it.
13256  * here with a zero breakFlag because we always refresh rIBASE on
13264     je     1f                                # reload rIBASE & resume if not
13269     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13279  * because rIBASE is caller save and we need to reload it.
13282  * here with a zero breakFlag because we always refresh rIBASE on
13290     je     1f                                # reload rIBASE & resume if not
13295     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13305  * because rIBASE is caller save and we need to reload it.
13308  * here with a zero breakFlag because we always refresh rIBASE on
13316     je     1f                                # reload rIBASE & resume if not
13321     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13331  * because rIBASE is caller save and we need to reload it.
13334  * here with a zero breakFlag because we always refresh rIBASE on
13342     je     1f                                # reload rIBASE & resume if not
13347     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13357  * because rIBASE is caller save and we need to reload it.
13360  * here with a zero breakFlag because we always refresh rIBASE on
13368     je     1f                                # reload rIBASE & resume if not
13373     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13383  * because rIBASE is caller save and we need to reload it.
13386  * here with a zero breakFlag because we always refresh rIBASE on
13394     je     1f                                # reload rIBASE & resume if not
13399     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13409  * because rIBASE is caller save and we need to reload it.
13412  * here with a zero breakFlag because we always refresh rIBASE on
13420     je     1f                                # reload rIBASE & resume if not
13425     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13435  * because rIBASE is caller save and we need to reload it.
13438  * here with a zero breakFlag because we always refresh rIBASE on
13446     je     1f                                # reload rIBASE & resume if not
13451     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13461  * because rIBASE is caller save and we need to reload it.
13464  * here with a zero breakFlag because we always refresh rIBASE on
13472     je     1f                                # reload rIBASE & resume if not
13477     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13487  * because rIBASE is caller save and we need to reload it.
13490  * here with a zero breakFlag because we always refresh rIBASE on
13498     je     1f                                # reload rIBASE & resume if not
13503     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13513  * because rIBASE is caller save and we need to reload it.
13516  * here with a zero breakFlag because we always refresh rIBASE on
13524     je     1f                                # reload rIBASE & resume if not
13529     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13539  * because rIBASE is caller save and we need to reload it.
13542  * here with a zero breakFlag because we always refresh rIBASE on
13550     je     1f                                # reload rIBASE & resume if not
13555     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13565  * because rIBASE is caller save and we need to reload it.
13568  * here with a zero breakFlag because we always refresh rIBASE on
13576     je     1f                                # reload rIBASE & resume if not
13581     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13591  * because rIBASE is caller save and we need to reload it.
13594  * here with a zero breakFlag because we always refresh rIBASE on
13602     je     1f                                # reload rIBASE & resume if not
13607     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13617  * because rIBASE is caller save and we need to reload it.
13620  * here with a zero breakFlag because we always refresh rIBASE on
13628     je     1f                                # reload rIBASE & resume if not
13633     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13643  * because rIBASE is caller save and we need to reload it.
13646  * here with a zero breakFlag because we always refresh rIBASE on
13654     je     1f                                # reload rIBASE & resume if not
13659     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13669  * because rIBASE is caller save and we need to reload it.
13672  * here with a zero breakFlag because we always refresh rIBASE on
13680     je     1f                                # reload rIBASE & resume if not
13685     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13695  * because rIBASE is caller save and we need to reload it.
13698  * here with a zero breakFlag because we always refresh rIBASE on
13706     je     1f                                # reload rIBASE & resume if not
13711     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13721  * because rIBASE is caller save and we need to reload it.
13724  * here with a zero breakFlag because we always refresh rIBASE on
13732     je     1f                                # reload rIBASE & resume if not
13737     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13747  * because rIBASE is caller save and we need to reload it.
13750  * here with a zero breakFlag because we always refresh rIBASE on
13758     je     1f                                # reload rIBASE & resume if not
13763     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13773  * because rIBASE is caller save and we need to reload it.
13776  * here with a zero breakFlag because we always refresh rIBASE on
13784     je     1f                                # reload rIBASE & resume if not
13789     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13799  * because rIBASE is caller save and we need to reload it.
13802  * here with a zero breakFlag because we always refresh rIBASE on
13810     je     1f                                # reload rIBASE & resume if not
13815     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13825  * because rIBASE is caller save and we need to reload it.
13828  * here with a zero breakFlag because we always refresh rIBASE on
13836     je     1f                                # reload rIBASE & resume if not
13841     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13851  * because rIBASE is caller save and we need to reload it.
13854  * here with a zero breakFlag because we always refresh rIBASE on
13862     je     1f                                # reload rIBASE & resume if not
13867     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13877  * because rIBASE is caller save and we need to reload it.
13880  * here with a zero breakFlag because we always refresh rIBASE on
13888     je     1f                                # reload rIBASE & resume if not
13893     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13903  * because rIBASE is caller save and we need to reload it.
13906  * here with a zero breakFlag because we always refresh rIBASE on
13914     je     1f                                # reload rIBASE & resume if not
13919     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13929  * because rIBASE is caller save and we need to reload it.
13932  * here with a zero breakFlag because we always refresh rIBASE on
13940     je     1f                                # reload rIBASE & resume if not
13945     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13955  * because rIBASE is caller save and we need to reload it.
13958  * here with a zero breakFlag because we always refresh rIBASE on
13966     je     1f                                # reload rIBASE & resume if not
13971     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
13981  * because rIBASE is caller save and we need to reload it.
13984  * here with a zero breakFlag because we always refresh rIBASE on
13992     je     1f                                # reload rIBASE & resume if not
13997     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14007  * because rIBASE is caller save and we need to reload it.
14010  * here with a zero breakFlag because we always refresh rIBASE on
14018     je     1f                                # reload rIBASE & resume if not
14023     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14033  * because rIBASE is caller save and we need to reload it.
14036  * here with a zero breakFlag because we always refresh rIBASE on
14044     je     1f                                # reload rIBASE & resume if not
14049     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14059  * because rIBASE is caller save and we need to reload it.
14062  * here with a zero breakFlag because we always refresh rIBASE on
14070     je     1f                                # reload rIBASE & resume if not
14075     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14085  * because rIBASE is caller save and we need to reload it.
14088  * here with a zero breakFlag because we always refresh rIBASE on
14096     je     1f                                # reload rIBASE & resume if not
14101     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14111  * because rIBASE is caller save and we need to reload it.
14114  * here with a zero breakFlag because we always refresh rIBASE on
14122     je     1f                                # reload rIBASE & resume if not
14127     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14137  * because rIBASE is caller save and we need to reload it.
14140  * here with a zero breakFlag because we always refresh rIBASE on
14148     je     1f                                # reload rIBASE & resume if not
14153     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14163  * because rIBASE is caller save and we need to reload it.
14166  * here with a zero breakFlag because we always refresh rIBASE on
14174     je     1f                                # reload rIBASE & resume if not
14179     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14189  * because rIBASE is caller save and we need to reload it.
14192  * here with a zero breakFlag because we always refresh rIBASE on
14200     je     1f                                # reload rIBASE & resume if not
14205     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14215  * because rIBASE is caller save and we need to reload it.
14218  * here with a zero breakFlag because we always refresh rIBASE on
14226     je     1f                                # reload rIBASE & resume if not
14231     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14241  * because rIBASE is caller save and we need to reload it.
14244  * here with a zero breakFlag because we always refresh rIBASE on
14252     je     1f                                # reload rIBASE & resume if not
14257     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14267  * because rIBASE is caller save and we need to reload it.
14270  * here with a zero breakFlag because we always refresh rIBASE on
14278     je     1f                                # reload rIBASE & resume if not
14283     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14293  * because rIBASE is caller save and we need to reload it.
14296  * here with a zero breakFlag because we always refresh rIBASE on
14304     je     1f                                # reload rIBASE & resume if not
14309     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14319  * because rIBASE is caller save and we need to reload it.
14322  * here with a zero breakFlag because we always refresh rIBASE on
14330     je     1f                                # reload rIBASE & resume if not
14335     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14345  * because rIBASE is caller save and we need to reload it.
14348  * here with a zero breakFlag because we always refresh rIBASE on
14356     je     1f                                # reload rIBASE & resume if not
14361     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14371  * because rIBASE is caller save and we need to reload it.
14374  * here with a zero breakFlag because we always refresh rIBASE on
14382     je     1f                                # reload rIBASE & resume if not
14387     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14397  * because rIBASE is caller save and we need to reload it.
14400  * here with a zero breakFlag because we always refresh rIBASE on
14408     je     1f                                # reload rIBASE & resume if not
14413     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14423  * because rIBASE is caller save and we need to reload it.
14426  * here with a zero breakFlag because we always refresh rIBASE on
14434     je     1f                                # reload rIBASE & resume if not
14439     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14449  * because rIBASE is caller save and we need to reload it.
14452  * here with a zero breakFlag because we always refresh rIBASE on
14460     je     1f                                # reload rIBASE & resume if not
14465     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14475  * because rIBASE is caller save and we need to reload it.
14478  * here with a zero breakFlag because we always refresh rIBASE on
14486     je     1f                                # reload rIBASE & resume if not
14491     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14501  * because rIBASE is caller save and we need to reload it.
14504  * here with a zero breakFlag because we always refresh rIBASE on
14512     je     1f                                # reload rIBASE & resume if not
14517     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14527  * because rIBASE is caller save and we need to reload it.
14530  * here with a zero breakFlag because we always refresh rIBASE on
14538     je     1f                                # reload rIBASE & resume if not
14543     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14553  * because rIBASE is caller save and we need to reload it.
14556  * here with a zero breakFlag because we always refresh rIBASE on
14564     je     1f                                # reload rIBASE & resume if not
14569     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14579  * because rIBASE is caller save and we need to reload it.
14582  * here with a zero breakFlag because we always refresh rIBASE on
14590     je     1f                                # reload rIBASE & resume if not
14595     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14605  * because rIBASE is caller save and we need to reload it.
14608  * here with a zero breakFlag because we always refresh rIBASE on
14616     je     1f                                # reload rIBASE & resume if not
14621     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14631  * because rIBASE is caller save and we need to reload it.
14634  * here with a zero breakFlag because we always refresh rIBASE on
14642     je     1f                                # reload rIBASE & resume if not
14647     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14657  * because rIBASE is caller save and we need to reload it.
14660  * here with a zero breakFlag because we always refresh rIBASE on
14668     je     1f                                # reload rIBASE & resume if not
14673     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14683  * because rIBASE is caller save and we need to reload it.
14686  * here with a zero breakFlag because we always refresh rIBASE on
14694     je     1f                                # reload rIBASE & resume if not
14699     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14709  * because rIBASE is caller save and we need to reload it.
14712  * here with a zero breakFlag because we always refresh rIBASE on
14720     je     1f                                # reload rIBASE & resume if not
14725     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14735  * because rIBASE is caller save and we need to reload it.
14738  * here with a zero breakFlag because we always refresh rIBASE on
14746     je     1f                                # reload rIBASE & resume if not
14751     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14761  * because rIBASE is caller save and we need to reload it.
14764  * here with a zero breakFlag because we always refresh rIBASE on
14772     je     1f                                # reload rIBASE & resume if not
14777     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14787  * because rIBASE is caller save and we need to reload it.
14790  * here with a zero breakFlag because we always refresh rIBASE on
14798     je     1f                                # reload rIBASE & resume if not
14803     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14813  * because rIBASE is caller save and we need to reload it.
14816  * here with a zero breakFlag because we always refresh rIBASE on
14824     je     1f                                # reload rIBASE & resume if not
14829     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14839  * because rIBASE is caller save and we need to reload it.
14842  * here with a zero breakFlag because we always refresh rIBASE on
14850     je     1f                                # reload rIBASE & resume if not
14855     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14865  * because rIBASE is caller save and we need to reload it.
14868  * here with a zero breakFlag because we always refresh rIBASE on
14876     je     1f                                # reload rIBASE & resume if not
14881     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14891  * because rIBASE is caller save and we need to reload it.
14894  * here with a zero breakFlag because we always refresh rIBASE on
14902     je     1f                                # reload rIBASE & resume if not
14907     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14917  * because rIBASE is caller save and we need to reload it.
14920  * here with a zero breakFlag because we always refresh rIBASE on
14928     je     1f                                # reload rIBASE & resume if not
14933     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14943  * because rIBASE is caller save and we need to reload it.
14946  * here with a zero breakFlag because we always refresh rIBASE on
14954     je     1f                                # reload rIBASE & resume if not
14959     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14969  * because rIBASE is caller save and we need to reload it.
14972  * here with a zero breakFlag because we always refresh rIBASE on
14980     je     1f                                # reload rIBASE & resume if not
14985     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
14995  * because rIBASE is caller save and we need to reload it.
14998  * here with a zero breakFlag because we always refresh rIBASE on
15006     je     1f                                # reload rIBASE & resume if not
15011     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
15021  * because rIBASE is caller save and we need to reload it.
15024  * here with a zero breakFlag because we always refresh rIBASE on
15032     je     1f                                # reload rIBASE & resume if not
15037     movl   offThread_curHandlerTable(%eax), rIBASE # reload rIBASE
15610     movl    offThread_curHandlerTable(%ecx),rIBASE
15664     movl   offThread_curHandlerTable(%ecx),rIBASE
15721     movl   offThread_curHandlerTable(%ecx),rIBASE
15775     movl   offThread_curHandlerTable(%ecx),rIBASE
15809     movl   offThread_curHandlerTable(%ecx),rIBASE
15924     movl        offThread_curHandlerTable(%ecx), rIBASE
15957     SPILL(rIBASE)
15959     movl        rSELF, rIBASE
15960     GET_JIT_THRESHOLD rIBASE rINST  # leaves rSELF in %ecx
15963     movl   rIBASE,rINST            # preserve rSELF
15966     movl   rIBASE,OUT_ARG1(%esp)
15968     UNSPILL(rIBASE)
15989  * Call out to validate trace-building request. If successful, rIBASE will be swapped
16001    movl offThread_curHandlerTable(%ecx), rIBASE
16018  * Call out to validate trace-building request. If successful, rIBASE will be swapped
16029    movl offThread_curHandlerTable(%ecx), rIBASE
16048  *   rIBASE trashed, must reload before resuming interpreter
16102     * rIBASE trashed, must reload before resuming interpreter
16229     movl        offThread_curHandlerTable(%ecx),rIBASE
16284     movl        offThread_curHandlerTable(%eax),rIBASE
16341     movl        offThread_curHandlerTable(%ecx),rIBASE
16374     jmp     *(rIBASE,%ecx,4)
16486      movl  offThread_curHandlerTable(%eax),rIBASE
16659     movl       offThread_curHandlerTable(%ecx), rIBASE # refresh rIBASE

Indexes created Tue Mar 25 04:38:43 CET 2014