Print this page
restore sparc comments
de-linting of .s files

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/sun4v/cpu/common_asm.s
          +++ new/usr/src/uts/sun4v/cpu/common_asm.s
↓ open down ↓ 14 lines elided ↑ open up ↑
  15   15   * If applicable, add the following below this CDDL HEADER, with the
  16   16   * fields enclosed by brackets "[]" replaced with your own identifying
  17   17   * information: Portions Copyright [yyyy] [name of copyright owner]
  18   18   *
  19   19   * CDDL HEADER END
  20   20   */
  21   21  /*
  22   22   * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  23   23   */
  24   24  
  25      -#if !defined(lint)
  26   25  #include "assym.h"
  27      -#endif
  28   26  
  29   27  /*
  30   28   * General assembly language routines.
  31   29   * It is the intent of this file to contain routines that are
  32   30   * specific to cpu architecture.
  33   31   */
  34   32  
  35   33  /*
  36   34   * WARNING: If you add a fast trap handler which can be invoked by a
  37   35   * non-privileged user, you may have to use the FAST_TRAP_DONE macro
  38   36   * instead of "done" instruction to return back to the user mode. See
  39   37   * comments for the "fast_trap_done" entry point for more information.
  40   38   */
  41   39  #define FAST_TRAP_DONE  \
  42   40          ba,a    fast_trap_done
  43   41  
  44   42  #include <sys/machclock.h>
  45   43  #include <sys/clock.h>
  46   44  
  47      -#if defined(lint)
  48      -#include <sys/types.h>
  49      -#include <sys/scb.h>
  50      -#include <sys/systm.h>
  51      -#include <sys/regset.h>
  52      -#include <sys/sunddi.h>
  53      -#include <sys/lockstat.h>
  54      -#endif  /* lint */
  55   45  
  56      -
  57   46  #include <sys/asm_linkage.h>
  58   47  #include <sys/privregs.h>
  59   48  #include <vm/hat_sfmmu.h>
  60   49  #include <sys/machparam.h>      /* To get SYSBASE and PAGESIZE */
  61   50  #include <sys/machthread.h>
  62   51  #include <sys/clock.h>
  63   52  #include <sys/intreg.h>
  64   53  #include <sys/psr_compat.h>
  65   54  #include <sys/isa_defs.h>
  66   55  #include <sys/dditypes.h>
  67   56  #include <sys/intr.h>
  68   57  #include <sys/hypervisor_api.h>
  69   58  
  70      -#if !defined(lint)
  71   59  #include "assym.h"
  72      -#endif
  73   60  
  74   61  #define ICACHE_FLUSHSZ  0x20
  75   62  
  76      -#if defined(lint)
  77   63  /*
  78      - * Softint generated when counter field of tick reg matches value field 
       64 + * Softint generated when counter field of tick reg matches value field
  79   65   * of tick_cmpr reg
  80   66   */
  81      -/*ARGSUSED*/
  82      -void
  83      -tickcmpr_set(uint64_t clock_cycles)
  84      -{}
  85      -
  86      -#else   /* lint */
  87      -
  88   67          ENTRY_NP(tickcmpr_set)
  89   68          ! get 64-bit clock_cycles interval
  90   69          mov     %o0, %o2
  91   70          mov     8, %o3                  ! A reasonable initial step size
  92   71  1:
  93   72          WR_TICKCMPR(%o2,%o4,%o5,__LINE__)       ! Write to TICK_CMPR
  94   73  
  95   74          GET_NATIVE_TIME(%o0,%o4,%o5,__LINE__)   ! Read %tick to confirm the
  96   75                                                  ! value we wrote was in the
  97   76                                                  ! future.
↓ open down ↓ 1 lines elided ↑ open up ↑
  99   78          cmp     %o2, %o0                ! If the value we wrote was in the
 100   79          bg,pt   %xcc, 2f                !   future, then blow out of here.
 101   80            sllx  %o3, 1, %o3             ! If not, then double our step size,
 102   81          ba,pt   %xcc, 1b                !   and take another lap.
 103   82            add   %o0, %o3, %o2           !
 104   83  2:
 105   84          retl
 106   85            nop
 107   86          SET_SIZE(tickcmpr_set)
 108   87  
 109      -#endif  /* lint */
 110      -
 111      -#if defined(lint)
 112      -
 113      -void
 114      -tickcmpr_disable(void)
 115      -{}
 116      -
 117      -#else
 118      -
 119   88          ENTRY_NP(tickcmpr_disable)
 120   89          mov     1, %g1
 121   90          sllx    %g1, TICKINT_DIS_SHFT, %o0
 122   91          WR_TICKCMPR(%o0,%o4,%o5,__LINE__)       ! Write to TICK_CMPR
 123   92          retl
 124   93            nop
 125   94          SET_SIZE(tickcmpr_disable)
 126   95  
 127      -#endif
       96 +        .seg    ".text"
       97 +tick_write_delta_panic:
       98 +        .asciz  "tick_write_delta: not supported, delta: 0x%lx"
 128   99  
 129      -#if defined(lint)
 130      -
 131  100  /*
 132  101   * tick_write_delta() is intended to increment %stick by the specified delta,
 133  102   * but %stick is only writeable in hyperprivileged mode and at present there
 134  103   * is no provision for this. tick_write_delta is called by the cylic subsystem
 135  104   * if a negative %stick delta is observed after cyclic processing is resumed
 136  105   * after an event such as an OS suspend/resume. On sun4v, the suspend/resume
 137  106   * routines should adjust the %stick offset preventing the cyclic subsystem
 138  107   * from detecting a negative delta. If a negative delta is detected, panic the
 139  108   * system. The negative delta could be caused by improper %stick
 140  109   * synchronization after a suspend/resume.
 141  110   */
 142      -
 143      -/*ARGSUSED*/
 144      -void
 145      -tick_write_delta(uint64_t delta)
 146      -{}
 147      -
 148      -#else   /* lint */
 149      -
 150      -        .seg    ".text"
 151      -tick_write_delta_panic:
 152      -        .asciz  "tick_write_delta: not supported, delta: 0x%lx"
 153      -
 154  111          ENTRY_NP(tick_write_delta)
 155  112          sethi   %hi(tick_write_delta_panic), %o1
 156  113          save    %sp, -SA(MINFRAME), %sp ! get a new window to preserve caller
 157  114          mov     %i0, %o1
 158  115          call    panic
 159  116            or    %i1, %lo(tick_write_delta_panic), %o0
 160  117          /*NOTREACHED*/
 161  118          retl
 162  119            nop
 163      -#endif
 164  120  
 165      -#if defined(lint)
 166      -/*
 167      - *  return 1 if disabled
 168      - */
 169      -
 170      -int
 171      -tickcmpr_disabled(void)
 172      -{ return (0); }
 173      -
 174      -#else   /* lint */
 175      -
 176  121          ENTRY_NP(tickcmpr_disabled)
 177  122          RD_TICKCMPR(%g1,%o0,%o1,__LINE__)
 178  123          retl
 179  124            srlx  %g1, TICKINT_DIS_SHFT, %o0
 180  125          SET_SIZE(tickcmpr_disabled)
 181  126  
 182      -#endif  /* lint */
 183      -
 184  127  /*
 185  128   * Get current tick
 186  129   */
 187      -#if defined(lint)
 188  130  
 189      -u_longlong_t
 190      -gettick(void)
 191      -{ return (0); }
 192      -
 193      -u_longlong_t
 194      -randtick(void)
 195      -{ return (0); }
 196      -
 197      -#else   /* lint */
 198      -
 199  131          ENTRY(gettick)
 200  132          ALTENTRY(randtick)
 201  133          GET_NATIVE_TIME(%o0,%o2,%o3,__LINE__)
 202  134          retl
 203  135            nop
 204  136          SET_SIZE(randtick)
 205  137          SET_SIZE(gettick)
 206  138  
 207      -#endif  /* lint */
 208      -
 209  139  /*
 210  140   * Get current tick. For trapstat use only.
 211  141   */
 212      -#if defined (lint)
 213      -
 214      -hrtime_t
 215      -rdtick()
 216      -{ return (0); }
 217      -
 218      -#else
 219  142          ENTRY(rdtick)
 220  143          retl
 221  144          RD_TICK_PHYSICAL(%o0)
 222  145          SET_SIZE(rdtick)
 223      -#endif /* lint */
 224  146  
 225  147  
 226  148  /*
 227  149   * Return the counter portion of the tick register.
 228  150   */
 229  151  
 230      -#if defined(lint)
 231      -
 232      -uint64_t
 233      -gettick_counter(void)
 234      -{ return(0); }
 235      -
 236      -uint64_t
 237      -gettick_npt(void)
 238      -{ return(0); }
 239      -
 240      -uint64_t
 241      -getstick_npt(void)
 242      -{ return(0); }
 243      -
 244      -#else   /* lint */
 245      -
 246  152          ENTRY_NP(gettick_counter)
 247  153          RD_TICK(%o0,%o1,%o2,__LINE__)
 248  154          retl
 249  155          nop
 250  156          SET_SIZE(gettick_counter)
 251  157  
 252  158          ENTRY_NP(gettick_npt)
 253  159          RD_TICK_PHYSICAL(%o0)
 254  160          retl
 255  161          srlx    %o0, 63, %o0
 256  162          SET_SIZE(gettick_npt)
 257  163  
 258  164          ENTRY_NP(getstick_npt)
 259  165          RD_STICK_PHYSICAL(%o0)
 260  166          retl
 261  167          srlx    %o0, 63, %o0
 262  168          SET_SIZE(getstick_npt)
 263      -#endif  /* lint */
 264  169  
 265  170  /*
 266  171   * Provide a C callable interface to the trap that reads the hi-res timer.
 267  172   * Returns 64-bit nanosecond timestamp in %o0 and %o1.
 268  173   */
 269  174  
 270      -#if defined(lint)
 271      -
 272      -hrtime_t
 273      -gethrtime(void)
 274      -{
 275      -        return ((hrtime_t)0);
 276      -}
 277      -
 278      -hrtime_t
 279      -gethrtime_unscaled(void)
 280      -{
 281      -        return ((hrtime_t)0);
 282      -}
 283      -
 284      -hrtime_t
 285      -gethrtime_max(void)
 286      -{
 287      -        return ((hrtime_t)0);
 288      -}
 289      -
 290      -void
 291      -scalehrtime(hrtime_t *hrt)
 292      -{
 293      -        *hrt = 0;
 294      -}
 295      -
 296      -void
 297      -gethrestime(timespec_t *tp)
 298      -{
 299      -        tp->tv_sec = 0;
 300      -        tp->tv_nsec = 0;
 301      -}
 302      -
 303      -time_t
 304      -gethrestime_sec(void)
 305      -{
 306      -        return (0);
 307      -}
 308      -
 309      -void
 310      -gethrestime_lasttick(timespec_t *tp)
 311      -{
 312      -        tp->tv_sec = 0;
 313      -        tp->tv_nsec = 0;
 314      -}
 315      -
 316      -/*ARGSUSED*/
 317      -void
 318      -hres_tick(void)
 319      -{
 320      -}
 321      -
 322      -void
 323      -panic_hres_tick(void)
 324      -{
 325      -}
 326      -
 327      -#else   /* lint */
 328      -
 329  175          ENTRY_NP(gethrtime)
 330  176          GET_HRTIME(%g1,%o0,%o1,%o2,%o3,%o4,%o5,%g2,__LINE__)
 331  177                                                          ! %g1 = hrtime
 332  178          retl
 333  179            mov   %g1, %o0
 334  180          SET_SIZE(gethrtime)
 335  181  
 336  182          ENTRY_NP(gethrtime_unscaled)
 337  183          GET_NATIVE_TIME(%g1,%o2,%o3,__LINE__)   ! %g1 = native time
 338  184          retl
↓ open down ↓ 272 lines elided ↑ open up ↑
 611  457          ld      [%l4 + %lo(hres_lock)], %i1
 612  458          inc     %i1
 613  459          st      %i1, [%l4 + %lo(hres_lock)]
 614  460  
 615  461          sethi   %hi(hrtime_base_panic), %o0
 616  462          call    panic
 617  463            or    %o0, %lo(hrtime_base_panic), %o0
 618  464  
 619  465          SET_SIZE(hres_tick)
 620  466  
 621      -#endif  /* lint */
 622      -
 623      -#if !defined(lint) && !defined(__lint)
 624      -
 625  467          .seg    ".text"
 626  468  kstat_q_panic_msg:
 627  469          .asciz  "kstat_q_exit: qlen == 0"
 628  470  
 629  471          ENTRY(kstat_q_panic)
 630  472          save    %sp, -SA(MINFRAME), %sp
 631  473          sethi   %hi(kstat_q_panic_msg), %o0
 632  474          call    panic
 633  475            or    %o0, %lo(kstat_q_panic_msg), %o0
 634  476          /*NOTREACHED*/
↓ open down ↓ 89 lines elided ↑ open up ↑
 724  566          ENTRY(kstat_runq_back_to_waitq)
 725  567          GET_NATIVE_TIME(%g1,%g2,%g3,__LINE__)
 726  568  #if defined(DEBUG)
 727  569          KSTAT_Q_UPDATE(sub, BRZPN, kstat_q_panic, 1:, KSTAT_IO_R)
 728  570  #else
 729  571          KSTAT_Q_UPDATE_ND(sub, 1:, KSTAT_IO_R)
 730  572  #endif
 731  573          KSTAT_Q_UPDATE(add, BRZPT, 1f, 1:retl, KSTAT_IO_W)
 732  574          SET_SIZE(kstat_runq_back_to_waitq)
 733  575  
 734      -#endif /* lint */
 735      -
 736      -#ifdef lint     
 737      -
 738      -int64_t timedelta;
 739      -hrtime_t hres_last_tick;
 740      -volatile timestruc_t hrestime;
 741      -int64_t hrestime_adj;
 742      -volatile int hres_lock;
 743      -uint_t nsec_scale;
 744      -hrtime_t hrtime_base;
 745      -int traptrace_use_stick;
 746      -
 747      -#else
 748  576          /*
 749  577           *  -- WARNING --
 750  578           *
 751  579           * The following variables MUST be together on a 128-byte boundary.
 752  580           * In addition to the primary performance motivation (having them all
 753  581           * on the same cache line(s)), code here and in the GET*TIME() macros
 754  582           * assumes that they all have the same high 22 address bits (so
 755  583           * there's only one sethi).
 756  584           */
 757  585          .seg    ".data"
↓ open down ↓ 23 lines elided ↑ open up ↑
 781  609          .word   NSEC_SHIFT
 782  610  adj_shift:
 783  611          .word   ADJ_SHIFT
 784  612          .align  8
 785  613  native_tick_offset:
 786  614          .word   0, 0
 787  615          .align  8
 788  616  native_stick_offset:
 789  617          .word   0, 0
 790  618  
 791      -#endif
 792  619  
 793      -
 794  620  /*
 795  621   * drv_usecwait(clock_t n)      [DDI/DKI - section 9F]
 796  622   * usec_delay(int n)            [compatibility - should go one day]
 797  623   * Delay by spinning.
 798  624   *
 799  625   * delay for n microseconds.  numbers <= 0 delay 1 usec
 800  626   *
 801  627   * With UltraSPARC-III the combination of supporting mixed-speed CPUs
 802  628   * and variable clock rate for power management requires that we
 803  629   * use %stick to implement this routine.
 804  630   */
 805  631  
 806      -#if defined(lint)
 807      -
 808      -/*ARGSUSED*/
 809      -void
 810      -drv_usecwait(clock_t n)
 811      -{}
 812      -
 813      -/*ARGSUSED*/
 814      -void
 815      -usec_delay(int n)
 816      -{}
 817      -
 818      -#else   /* lint */
 819      -
 820  632          ENTRY(drv_usecwait)
 821  633          ALTENTRY(usec_delay)
 822  634          brlez,a,pn %o0, 0f
 823  635            mov   1, %o0
 824  636  0:
 825  637          sethi   %hi(sticks_per_usec), %o1
 826  638          lduw    [%o1 + %lo(sticks_per_usec)], %o1
 827  639          mulx    %o1, %o0, %o1           ! Scale usec to ticks
 828  640          inc     %o1                     ! We don't start on a tick edge
 829  641          GET_NATIVE_TIME(%o2,%o3,%o4,__LINE__)
 830  642          add     %o1, %o2, %o1
 831  643  
 832  644  1:      cmp     %o1, %o2
 833  645          GET_NATIVE_TIME(%o2,%o3,%o4,__LINE__)
 834  646          bgeu,pt %xcc, 1b
 835  647            nop
 836  648          retl
 837  649            nop
 838  650          SET_SIZE(usec_delay)
 839  651          SET_SIZE(drv_usecwait)
 840      -#endif  /* lint */
 841  652  
 842      -#if defined(lint)
 843      -
 844      -/* ARGSUSED */
 845      -void
 846      -pil14_interrupt(int level)
 847      -{}
 848      -
 849      -#else
 850      -
 851  653  /*
 852  654   * Level-14 interrupt prologue.
 853  655   */
 854  656          ENTRY_NP(pil14_interrupt)
 855  657          CPU_ADDR(%g1, %g2)
 856  658          rdpr    %pil, %g6                       ! %g6 = interrupted PIL
 857  659          stn     %g6, [%g1 + CPU_PROFILE_PIL]    ! record interrupted PIL
 858  660          rdpr    %tstate, %g6
 859  661          rdpr    %tpc, %g5
 860  662          btst    TSTATE_PRIV, %g6                ! trap from supervisor mode?
↓ open down ↓ 65 lines elided ↑ open up ↑
 926  728          cmp     %o5, %o0                        ! In the future?
 927  729          bg,a,pt %xcc, 2f                        ! Yes, drive on.
 928  730            wrpr  %g0, %g5, %pstate               !    delay: enable vec intr
 929  731          ba      1b                              ! No, try again.
 930  732            sllx  %o4, 1, %o4                     !    delay: double step size
 931  733  
 932  734  2:      ba      current_thread_complete
 933  735            nop
 934  736          SET_SIZE(tick_rtt)
 935  737  
 936      -#endif /* lint */
 937      -
 938      -#if defined(lint)
 939      -
 940      -/* ARGSUSED */
 941      -void
 942      -pil15_interrupt(int level)
 943      -{}
 944      -
 945      -#else   /* lint */
 946      -
 947  738  /*
 948  739   * Level-15 interrupt prologue.
 949  740   */
 950  741         ENTRY_NP(pil15_interrupt)
 951  742         CPU_ADDR(%g1, %g2)
 952  743         rdpr    %tstate, %g6
 953  744         rdpr    %tpc, %g5
 954  745         btst    TSTATE_PRIV, %g6                ! trap from supervisor mode?
 955  746         bnz,a,pt %xcc, 1f
 956  747         stn     %g5, [%g1 + CPU_CPCPROFILE_PC]  ! if so, record kernel PC
 957  748         stn     %g5, [%g1 + CPU_CPCPROFILE_UPC] ! if not, record user PC
 958  749         ba      pil15_epilogue                  ! must be large-disp branch
 959  750         stn     %g0, [%g1 + CPU_CPCPROFILE_PC]  ! zero kernel PC
 960  751  1:     ba      pil15_epilogue                  ! must be large-disp branch
 961  752         stn     %g0, [%g1 + CPU_CPCPROFILE_UPC] ! zero user PC
 962  753         SET_SIZE(pil15_interrupt)
 963  754  
 964      -#endif  /* lint */
 965      -
 966      -#if defined(lint)
 967  755  /*
 968  756   * Prefetch a page_t for write or read, this assumes a linear
 969  757   * scan of sequential page_t's.
 970  758   */
 971      -/*ARGSUSED*/
 972      -void
 973      -prefetch_page_w(void *pp)
 974      -{}
 975      -
 976      -/*ARGSUSED*/
 977      -void
 978      -prefetch_page_r(void *pp)
 979      -{}
 980      -#else   /* lint */
 981      -
 982  759  /* XXXQ These should be inline templates, not functions */
 983  760          ENTRY(prefetch_page_w)
 984  761          retl
 985  762            nop
 986  763          SET_SIZE(prefetch_page_w)
 987  764  
 988  765          ENTRY(prefetch_page_r)
 989  766          retl
 990  767            nop
 991  768          SET_SIZE(prefetch_page_r)
 992  769  
 993      -#endif  /* lint */
 994      -
 995      -#if defined(lint)
 996  770  /*
 997      - * Prefetch struct smap for write. 
      771 + * Prefetch struct smap for write.
 998  772   */
 999      -/*ARGSUSED*/
1000      -void
1001      -prefetch_smap_w(void *smp)
1002      -{}
1003      -#else   /* lint */
1004      -
1005  773  /* XXXQ These should be inline templates, not functions */
1006  774          ENTRY(prefetch_smap_w)
1007  775          retl
1008  776            nop
1009  777          SET_SIZE(prefetch_smap_w)
1010  778  
1011      -#endif  /* lint */
1012      -
1013  779  /*
1014  780   * Generic sun4v MMU and Cache operations.
1015  781   */
1016  782  
1017      -#if defined(lint)
1018      -
1019      -/*ARGSUSED*/
1020      -void
1021      -vtag_flushpage(caddr_t vaddr, uint64_t sfmmup)
1022      -{}
1023      -
1024      -/*ARGSUSED*/
1025      -void
1026      -vtag_flushall(void)
1027      -{}
1028      -
1029      -/*ARGSUSED*/
1030      -void
1031      -vtag_unmap_perm_tl1(uint64_t vaddr, uint64_t ctxnum)
1032      -{}
1033      -
1034      -/*ARGSUSED*/
1035      -void
1036      -vtag_flushpage_tl1(uint64_t vaddr, uint64_t sfmmup)
1037      -{}
1038      -
1039      -/*ARGSUSED*/
1040      -void
1041      -vtag_flush_pgcnt_tl1(uint64_t vaddr, uint64_t sfmmup_pgcnt)
1042      -{}
1043      -
1044      -/*ARGSUSED*/
1045      -void
1046      -vtag_flushall_tl1(uint64_t dummy1, uint64_t dummy2)
1047      -{}
1048      -
1049      -/*ARGSUSED*/
1050      -void
1051      -vac_flushpage(pfn_t pfnum, int vcolor)
1052      -{}
1053      -
1054      -/*ARGSUSED*/
1055      -void
1056      -vac_flushpage_tl1(uint64_t pfnum, uint64_t vcolor)
1057      -{}
1058      -
1059      -/*ARGSUSED*/
1060      -void
1061      -flush_instr_mem(caddr_t vaddr, size_t len)
1062      -{}
1063      -
1064      -#else   /* lint */
1065      -
1066  783          ENTRY_NP(vtag_flushpage)
1067  784          /*
1068  785           * flush page from the tlb
1069  786           *
1070  787           * %o0 = vaddr
1071  788           * %o1 = sfmmup
1072  789           */
1073  790          SFMMU_CPU_CNUM(%o1, %g1, %g2)   /* %g1 = sfmmu cnum on this CPU */
1074  791  
1075  792          mov     %g1, %o1 
↓ open down ↓ 179 lines elided ↑ open up ↑
1255  972  1:
1256  973          flush   %o0
1257  974          subcc   %o1, ICACHE_FLUSHSZ, %o1                ! bytes = bytes-0x20
1258  975          bgu,pt  %ncc, 1b
1259  976            add   %o0, ICACHE_FLUSHSZ, %o0                ! vaddr = vaddr+0x20
1260  977  
1261  978          retl
1262  979            nop
1263  980          SET_SIZE(flush_instr_mem)
1264  981  
1265      -#endif /* !lint */
1266      -
1267  982  #if !defined(CUSTOM_FPZERO)
1268  983  
1269  984  /*
1270  985   * fp_zero() - clear all fp data registers and the fsr
1271  986   */
1272  987  
1273      -#if defined(lint) || defined(__lint)
1274      -
1275      -void
1276      -fp_zero(void)
1277      -{}
1278      -
1279      -#else   /* lint */
1280      -
1281  988  .global fp_zero_zero
1282  989  .align 8
1283  990  fp_zero_zero:
1284  991          .xword  0
1285  992  
1286  993          ENTRY_NP(fp_zero)
1287  994          sethi   %hi(fp_zero_zero), %o0
1288  995          ldx     [%o0 + %lo(fp_zero_zero)], %fsr
1289  996          ldd     [%o0 + %lo(fp_zero_zero)], %f0
1290  997          fmovd   %f0, %f2
↓ open down ↓ 23 lines elided ↑ open up ↑
1314 1021          fmovd   %f0, %f50
1315 1022          fmovd   %f0, %f52
1316 1023          fmovd   %f0, %f54
1317 1024          fmovd   %f0, %f56
1318 1025          fmovd   %f0, %f58
1319 1026          fmovd   %f0, %f60
1320 1027          retl
1321 1028          fmovd   %f0, %f62
1322 1029          SET_SIZE(fp_zero)
1323 1030  
1324      -#endif  /* lint */
1325 1031  #endif  /* CUSTOM_FPZERO */
    
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX