6.59.15.3 MIPS-3D Built-in Functions

The MIPS-3D Application-Specific Extension (ASE) includes additional paired-single instructions that are designed to improve the performance of 3D graphics operations. Support for these instructions is controlled by the -mips3d command-line option.

The functions listed below map directly to a particular MIPS-3D instruction. Please refer to the architecture specification for more details on what each instruction does.

v2sf __builtin_mips_addr_ps (v2sf, v2sf)
Reduction add (addr.ps ).
v2sf __builtin_mips_mulr_ps (v2sf, v2sf)
Reduction multiply (mulr.ps ).
v2sf __builtin_mips_cvt_pw_ps (v2sf)
Convert paired single to paired word (cvt.pw.ps ).
v2sf __builtin_mips_cvt_ps_pw (v2sf)
Convert paired word to paired single (cvt.ps.pw ).
float __builtin_mips_recip1_s (float)
double __builtin_mips_recip1_d (double)
v2sf __builtin_mips_recip1_ps (v2sf)
Reduced-precision reciprocal (sequence step 1) (recip1. fmt ).
float __builtin_mips_recip2_s (float, float)
double __builtin_mips_recip2_d (double, double)
v2sf __builtin_mips_recip2_ps (v2sf, v2sf)
Reduced-precision reciprocal (sequence step 2) (recip2. fmt ).
float __builtin_mips_rsqrt1_s (float)
double __builtin_mips_rsqrt1_d (double)
v2sf __builtin_mips_rsqrt1_ps (v2sf)
Reduced-precision reciprocal square root (sequence step 1) (rsqrt1. fmt ).
float __builtin_mips_rsqrt2_s (float, float)
double __builtin_mips_rsqrt2_d (double, double)
v2sf __builtin_mips_rsqrt2_ps (v2sf, v2sf)
Reduced-precision reciprocal square root (sequence step 2) (rsqrt2. fmt ).

The following multi-instruction functions are also available. In each case, cond can be any of the 16 floating-point conditions: f , un , eq , ueq , olt , ult , ole , ule , sf , ngle , seq , ngl , lt , nge , le or ngt .

int __builtin_mips_cabs_ cond _s (float a , float b )
int __builtin_mips_cabs_ cond _d (double a , double b )
Absolute comparison of two scalar values (cabs. cond . fmt , bc1t /bc1f ).

These functions compare a and b using cabs. cond .s or cabs. cond .d and return the result as a boolean value. For example:

          float a, b;
          if (__builtin_mips_cabs_eq_s (a, b))
            true ();
          else
            false ();

int __builtin_mips_upper_cabs_ cond _ps (v2sf a , v2sf b )
int __builtin_mips_lower_cabs_ cond _ps (v2sf a , v2sf b )
Absolute comparison of two paired-single values (cabs. cond .ps , bc1t /bc1f ).

These functions compare a and b using cabs. cond .ps and return either the upper or lower half of the result. For example:

          v2sf a, b;
          if (__builtin_mips_upper_cabs_eq_ps (a, b))
            upper_halves_are_equal ();
          else
            upper_halves_are_unequal ();
          
          if (__builtin_mips_lower_cabs_eq_ps (a, b))
            lower_halves_are_equal ();
          else
            lower_halves_are_unequal ();

v2sf __builtin_mips_movt_cabs_ cond _ps (v2sf a , v2sf b , v2sf c , v2sf d )
v2sf __builtin_mips_movf_cabs_ cond _ps (v2sf a , v2sf b , v2sf c , v2sf d )
Conditional move based on absolute comparison (cabs. cond .ps , movt.ps /movf.ps ).

The movt functions return the value x computed by:

          cabs.cond
.ps cc
,a
,b

          mov.ps x
,c

          movt.ps x
,d
,cc

The movf functions are similar but use movf.ps instead of movt.ps .

int __builtin_mips_any_c_ cond _ps (v2sf a , v2sf b )
int __builtin_mips_all_c_ cond _ps (v2sf a , v2sf b )
int __builtin_mips_any_cabs_ cond _ps (v2sf a , v2sf b )
int __builtin_mips_all_cabs_ cond _ps (v2sf a , v2sf b )
Comparison of two paired-single values (c. cond .ps /cabs. cond .ps , bc1any2t /bc1any2f ).

These functions compare a and b using c. cond .ps or cabs. cond .ps . The any forms return true if either result is true and the all forms return true if both results are true. For example:

          v2sf a, b;
          if (__builtin_mips_any_c_eq_ps (a, b))
            one_is_true ();
          else
            both_are_false ();
          
          if (__builtin_mips_all_c_eq_ps (a, b))
            both_are_true ();
          else
            one_is_false ();

int __builtin_mips_any_c_ cond _4s (v2sf a , v2sf b , v2sf c , v2sf d )
int __builtin_mips_all_c_ cond _4s (v2sf a , v2sf b , v2sf c , v2sf d )
int __builtin_mips_any_cabs_ cond _4s (v2sf a , v2sf b , v2sf c , v2sf d )
int __builtin_mips_all_cabs_ cond _4s (v2sf a , v2sf b , v2sf c , v2sf d )
Comparison of four paired-single values (c. cond .ps /cabs. cond .ps , bc1any4t /bc1any4f ).

These functions use c. cond .ps or cabs. cond .ps to compare a with b and to compare c with d . The any forms return true if any of the four results are true and the all forms return true if all four results are true. For example:

          v2sf a, b, c, d;
          if (__builtin_mips_any_c_eq_4s (a, b, c, d))
            some_are_true ();
          else
            all_are_false ();
          
          if (__builtin_mips_all_c_eq_4s (a, b, c, d))
            all_are_true ();
          else
            some_are_false ();