diff --git a/builtins/util-nvptx.m4 b/builtins/util-nvptx.m4
index 52041490..62b2391c 100644
--- a/builtins/util-nvptx.m4
+++ b/builtins/util-nvptx.m4
@@ -877,54 +877,8 @@ mask_converts(WIDTH)
 
 define(`global_atomic_associative', `
 
-define <$1 x $3> @__atomic_$2_$4_global($3 * %ptr, <$1 x $3> %val,
-                                        <$1 x MASK> %m) nounwind alwaysinline {
-  ; first, for any lanes where the mask is off, compute a vector where those lanes
-  ; hold the identity value..
-
-  ; for the bit tricks below, we need the mask to have the
-  ; the same element size as the element type.
-  %mask = call <$1 x $3> @convertmask_`'MASK`'_$3_$1(<$1 x MASK> %m)
-
-  ; zero out any lanes that are off
-  %valoff = and <$1 x $3> %val, %mask
-
-  ; compute an identity vector that is zero in on lanes and has the identiy value
-  ; in the off lanes
-  %idv1 = bitcast $3 $5 to <1 x $3>
-  %idvec = shufflevector <1 x $3> %idv1, <1 x $3> undef,
-     <$1 x i32> < forloop(i, 1, eval($1-1), `i32 0, ') i32 0 >
-  %notmask = xor <$1 x $3> %mask, < forloop(i, 1, eval($1-1), `$3 -1, ') $3 -1 >
-  %idoff = and <$1 x $3> %idvec, %notmask
-
-  ; and comptue the merged vector that holds the identity in the off lanes
-  %valp = or <$1 x $3> %valoff, %idoff
-
-  ; now compute the local reduction (val0 op val1 op ... )--initialize
-  ; %eltvec so that the 0th element is the identity, the first is val0,
-  ; the second is (val0 op val1), ..
-  %red0 = extractelement <$1 x $3> %valp, i32 0
-  %eltvec0 = insertelement <$1 x $3> undef, $3 $5, i32 0
-
-  forloop(i, 1, eval($1-1), `
-  %elt`'i = extractelement <$1 x $3> %valp, i32 i
-  %red`'i = $2 $3 %red`'eval(i-1), %elt`'i
-  %eltvec`'i = insertelement <$1 x $3> %eltvec`'eval(i-1), $3 %red`'eval(i-1), i32 i')
-
-  ; make the atomic call, passing it the final reduced value
-  %final0 = atomicrmw $2 $3 * %ptr, $3 %red`'eval($1-1) seq_cst
-
-  ; now go back and compute the values to be returned for each program 
-  ; instance--this just involves smearing the old value returned from the
-  ; actual atomic call across the vector and applying the vector op to the
-  ; %eltvec vector computed above..
-  %finalv1 = bitcast $3 %final0 to <1 x $3>
-  %final_base = shufflevector <1 x $3> %finalv1, <1 x $3> undef,
-     <$1 x i32> < forloop(i, 1, eval($1-1), `i32 0, ') i32 0 >
-  %r = $2 <$1 x $3> %final_base, %eltvec`'eval($1-1)
-
-  ret <$1 x $3> %r
-}
+declare <$1 x $3> @__atomic_$2_$4_global($3 * %ptr, <$1 x $3> %val,
+                                        <$1 x MASK> %m) nounwind alwaysinline ;
 ')
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -941,10 +895,7 @@ define <$1 x $3> @__atomic_$2_$4_global($3 * %ptr, <$1 x $3> %val,
 ;; $4: return type of the LLVM atomic type, in ispc naming paralance (e.g. int32)
 
 define(`global_atomic_uniform', `
-define $3 @__atomic_$2_uniform_$4_global($3 * %ptr, $3 %val) nounwind alwaysinline {
-  %r = atomicrmw $2 $3 * %ptr, $3 %val seq_cst
-  ret $3 %r
-}
+declare $3 @__atomic_$2_uniform_$4_global($3 * %ptr, $3 %val) nounwind alwaysinline ;
 ')
 
 ;; Macro to declare the function that implements the swap atomic.  
@@ -954,10 +905,7 @@ define $3 @__atomic_$2_uniform_$4_global($3 * %ptr, $3 %val) nounwind alwaysinli
 ;; $3: ispc type of the elements (e.g. int32)
 
 define(`global_swap', `
-define $2 @__atomic_swap_uniform_$3_global($2* %ptr, $2 %val) nounwind alwaysinline {
- %r = atomicrmw xchg $2 * %ptr, $2 %val seq_cst
- ret $2 %r
-}
+declare $2 @__atomic_swap_uniform_$3_global($2* %ptr, $2 %val) nounwind alwaysinline ;
 ')
 
 
@@ -969,27 +917,11 @@ define $2 @__atomic_swap_uniform_$3_global($2* %ptr, $2 %val) nounwind alwaysinl
 
 define(`global_atomic_exchange', `
 
-define <$1 x $2> @__atomic_compare_exchange_$3_global($2* %ptr, <$1 x $2> %cmp,
-                               <$1 x $2> %val, <$1 x MASK> %mask) nounwind alwaysinline {
-  %rptr = alloca <$1 x $2>
-  %rptr32 = bitcast <$1 x $2> * %rptr to $2 *
+declare <$1 x $2> @__atomic_compare_exchange_$3_global($2* %ptr, <$1 x $2> %cmp,
+                               <$1 x $2> %val, <$1 x MASK> %mask) nounwind alwaysinline ;
 
-  per_lane($1, <$1 x MASK> %mask, `
-   %cmp_LANE_ID = extractelement <$1 x $2> %cmp, i32 LANE
-   %val_LANE_ID = extractelement <$1 x $2> %val, i32 LANE
-   %r_LANE_ID = cmpxchg $2 * %ptr, $2 %cmp_LANE_ID, $2 %val_LANE_ID seq_cst
-   %rp_LANE_ID = getelementptr $2 * %rptr32, i32 LANE
-   store $2 %r_LANE_ID, $2 * %rp_LANE_ID')
-
-  %r = load <$1 x $2> * %rptr
-  ret <$1 x $2> %r
-}
-
-define $2 @__atomic_compare_exchange_uniform_$3_global($2* %ptr, $2 %cmp,
-                                                       $2 %val) nounwind alwaysinline {
-  %r = cmpxchg $2 * %ptr, $2 %cmp, $2 %val seq_cst
-  ret $2 %r
-}
+declare $2 @__atomic_compare_exchange_uniform_$3_global($2* %ptr, $2 %cmp,
+                                                       $2 %val) nounwind alwaysinline ;
 ')
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1053,607 +985,116 @@ define void @__prefetch_read_uniform_nt(i8 *) alwaysinline {
 ;; take 4 4-wide vectors laid out like <r0 g0 b0 a0> <r1 g1 b1 a1> ...
 ;; and reorder them to <r0 r1 r2 r3> <g0 g1 g2 g3> ...
 
-define(`aossoa', `define void
+define(`aossoa', `
+declare void
 @__aos_to_soa4_float4(<4 x float> %v0, <4 x float> %v1, <4 x float> %v2,
         <4 x float> %v3, <4 x float> * noalias %out0, 
         <4 x float> * noalias %out1, <4 x float> * noalias %out2, 
-        <4 x float> * noalias %out3) nounwind alwaysinline { 
-  %t0 = shufflevector <4 x float> %v2, <4 x float> %v3,  ; r2 r3 g2 g3
-          <4 x i32> <i32 0, i32 4, i32 1, i32 5>
-  %t1 = shufflevector <4 x float> %v2, <4 x float> %v3,  ; b2 b3 a2 a3
-          <4 x i32> <i32 2, i32 6, i32 3, i32 7>
-  %t2 = shufflevector <4 x float> %v0, <4 x float> %v1,  ; r0 r1 g0 g1
-          <4 x i32> <i32 0, i32 4, i32 1, i32 5>
-  %t3 = shufflevector <4 x float> %v0, <4 x float> %v1,  ; b0 b1 a0 a1
-          <4 x i32> <i32 2, i32 6, i32 3, i32 7>
-
-  %r0 = shufflevector <4 x float> %t2, <4 x float> %t0,  ; r0 r1 r2 r3
-          <4 x i32> <i32 0, i32 1, i32 4, i32 5>
-  store <4 x float> %r0, <4 x float> * %out0
-  %r1 = shufflevector <4 x float> %t2, <4 x float> %t0,  ; g0 g1 g2 g3
-          <4 x i32> <i32 2, i32 3, i32 6, i32 7>
-  store <4 x float> %r1, <4 x float> * %out1
-  %r2 = shufflevector <4 x float> %t3, <4 x float> %t1,  ; b0 b1 b2 b3
-          <4 x i32> <i32 0, i32 1, i32 4, i32 5>
-  store <4 x float> %r2, <4 x float> * %out2
-  %r3 = shufflevector <4 x float> %t3, <4 x float> %t1,  ; a0 a1 a2 a3
-          <4 x i32> <i32 2, i32 3, i32 6, i32 7>
-  store <4 x float> %r3, <4 x float> * %out3
-  ret void
-}
-
+        <4 x float> * noalias %out3) nounwind alwaysinline ;
 
 ;; Do the reverse of __aos_to_soa4_float4--reorder <r0 r1 r2 r3> <g0 g1 g2 g3> ..
 ;; to <r0 g0 b0 a0> <r1 g1 b1 a1> ...
 ;; This is the exact same set of operations that __soa_to_soa4_float4 does
 ;; (a 4x4 transpose), so just call that...
 
-define void
+declare void
 @__soa_to_aos4_float4(<4 x float> %v0, <4 x float> %v1, <4 x float> %v2,
         <4 x float> %v3, <4 x float> * noalias %out0, 
         <4 x float> * noalias %out1, <4 x float> * noalias %out2, 
-        <4 x float> * noalias %out3) nounwind alwaysinline { 
-  call void @__aos_to_soa4_float4(<4 x float> %v0, <4 x float> %v1, 
-    <4 x float> %v2, <4 x float> %v3, <4 x float> * %out0, 
-    <4 x float> * %out1, <4 x float> * %out2, <4 x float> * %out3)
-  ret void
-}
-
+        <4 x float> * noalias %out3) nounwind alwaysinline;
 
 ;; Convert 3-wide AOS values to SOA--specifically, given 3 4-vectors
 ;; <x0 y0 z0 x1> <y1 z1 x2 y2> <z2 x3 y3 z3>, transpose to
 ;; <x0 x1 x2 x3> <y0 y1 y2 y3> <z0 z1 z2 z3>.
 
-define void
+declare void
 @__aos_to_soa3_float4(<4 x float> %v0, <4 x float> %v1, <4 x float> %v2,
         <4 x float> * noalias %out0, <4 x float> * noalias %out1,
-        <4 x float> * noalias %out2) nounwind alwaysinline { 
-  %t0 = shufflevector <4 x float> %v0, <4 x float> %v1, ; x0 x1 y0 y1
-    <4 x i32> <i32 0, i32 3, i32 1, i32 4>
-  %t1 = shufflevector <4 x float> %v1, <4 x float> %v2, ; x2 x3 y2 y3
-    <4 x i32> <i32 2, i32 5, i32 3, i32 6>
-
-  %r0 = shufflevector <4 x float> %t0, <4 x float> %t1, ; x0 x1 x1 x3
-    <4 x i32> <i32 0, i32 1, i32 4, i32 5>
-  store <4 x float> %r0, <4 x float> * %out0
-
-  %r1 = shufflevector <4 x float> %t0, <4 x float> %t1, ; y0 y1 y2 y3
-    <4 x i32> <i32 2, i32 3, i32 6, i32 7>
-  store <4 x float> %r1, <4 x float> * %out1
-
-  %t2 = shufflevector <4 x float> %v0, <4 x float> %v1, ; z0 z1 x x
-    <4 x i32> <i32 2, i32 5, i32 undef, i32 undef>
-
-  %r2 = shufflevector <4 x float> %t2, <4 x float> %v2, ; z0 z1 z2 z3
-    <4 x i32> <i32 0, i32 1, i32 4, i32 7>
-  store <4 x float> %r2, <4 x float> * %out2
-  ret void
-}
-
-
+        <4 x float> * noalias %out2) nounwind alwaysinline 
 ;; The inverse of __aos_to_soa3_float4: convert 3 4-vectors
 ;; <x0 x1 x2 x3> <y0 y1 y2 y3> <z0 z1 z2 z3> to
 ;; <x0 y0 z0 x1> <y1 z1 x2 y2> <z2 x3 y3 z3>.
 
-define void
+declare void
 @__soa_to_aos3_float4(<4 x float> %v0, <4 x float> %v1, <4 x float> %v2,
         <4 x float> * noalias %out0, <4 x float> * noalias %out1,
-        <4 x float> * noalias %out2) nounwind alwaysinline { 
-  %t0 = shufflevector <4 x float> %v0, <4 x float> %v1, ; x0 x1 x2 y0
-    <4 x i32> <i32 0, i32 1, i32 2, i32 4>
-  %t1 = shufflevector <4 x float> %v1, <4 x float> %v2, ; y1 y2 z0 z1
-    <4 x i32> <i32 1, i32 2, i32 4, i32 5>
- 
-  %r0 = shufflevector <4 x float> %t0, <4 x float> %t1, ; x0 y0 z0 x1
-    <4 x i32> <i32 0, i32 3, i32 6, i32 1>
-  store <4 x float> %r0, <4 x float> * %out0
-  %r1 = shufflevector <4 x float> %t0, <4 x float> %t1, ; y1 z1 x2 y2
-    <4 x i32> <i32 4, i32 7, i32 2, i32 5>
-  store <4 x float> %r1, <4 x float> * %out1
-
-  %t2 = shufflevector <4 x float> %v0, <4 x float> %v1, ; x3 y3 x x
-    <4 x i32> <i32 3, i32 7, i32 undef, i32 undef>
-
-  %r2 = shufflevector <4 x float> %t2, <4 x float> %v2, ; z2 x3 y3 z3
-    <4 x i32> <i32 6, i32 0, i32 1, i32 7>
-  store <4 x float> %r2, <4 x float> * %out2
-  ret void
-}
-
+        <4 x float> * noalias %out2) nounwind alwaysinline 
 ;; 8-wide
 ;; These functions implement the 8-wide variants of the AOS/SOA conversion
 ;; routines above.  These implementations are all built on top of the 4-wide
 ;; vector versions.
  
-define void
+declare void
 @__aos_to_soa4_float8(<8 x float> %v0, <8 x float> %v1, <8 x float> %v2,
         <8 x float> %v3, <8 x float> * noalias %out0, 
         <8 x float> * noalias %out1, <8 x float> * noalias %out2, 
-        <8 x float> * noalias %out3) nounwind alwaysinline {
-  ;; Split each 8-vector into 2 4-vectors
-  %v0a = shufflevector <8 x float> %v0, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v0b = shufflevector <8 x float> %v0, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v1a = shufflevector <8 x float> %v1, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v1b = shufflevector <8 x float> %v1, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v2a = shufflevector <8 x float> %v2, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v2b = shufflevector <8 x float> %v2, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v3a = shufflevector <8 x float> %v3, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v3b = shufflevector <8 x float> %v3, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
+        <8 x float> * noalias %out3) nounwind alwaysinline 
 
-  ;; Similarly for the output pointers
-  %out0a = bitcast <8 x float> * %out0 to <4 x float> *
-  %out0b = getelementptr <4 x float> * %out0a, i32 1
-  %out1a = bitcast <8 x float> * %out1 to <4 x float> *
-  %out1b = getelementptr <4 x float> * %out1a, i32 1
-  %out2a = bitcast <8 x float> * %out2 to <4 x float> *
-  %out2b = getelementptr <4 x float> * %out2a, i32 1
-  %out3a = bitcast <8 x float> * %out3 to <4 x float> *
-  %out3b = getelementptr <4 x float> * %out3a, i32 1
- 
-  ;; Do the first part--given input vectors like
-  ;; <x0 y0 z0 x1 y1 z1 x2 y2> <z2 x3 y3 z3 x4 y4 z4 x5> <y5 z5 x6 y6 z6 x7 y7 z7>,
-  ;; pass 3 4-vectors <x0 y0 z0 x1> <y1 z1 x2 y2> <z2 z3 y3 z3> to the 4-vec
-  ;; version to compute the first 4 SOA values for the three output variables.
-  call void @__aos_to_soa4_float4(<4 x float> %v0a, <4 x float> %v0b,
-         <4 x float> %v1a, <4 x float> %v1b, <4 x float> * %out0a,
-         <4 x float> * %out1a, <4 x float> * %out2a, <4 x float> * %out3a)
-
-  ;; And similarly pass <x4 y4 z4 x5> <y5 z5 x6 y6> <z6 x7 y7 z7> to the 4-wide
-  ;; version to compute the second 4 SOA values for the three outputs
-  call void @__aos_to_soa4_float4(<4 x float> %v2a, <4 x float> %v2b,
-         <4 x float> %v3a, <4 x float> %v3b, <4 x float> * %out0b,
-         <4 x float> * %out1b, <4 x float> * %out2b, <4 x float> * %out3b)
-  ret void
-}
-
-
-define void
+declare void
 @__soa_to_aos4_float8(<8 x float> %v0, <8 x float> %v1, <8 x float> %v2,
         <8 x float> %v3, <8 x float> * noalias %out0, 
         <8 x float> * noalias %out1, <8 x float> * noalias %out2, 
-        <8 x float> * noalias %out3) nounwind alwaysinline {
-  ;; As above, split into 4-vectors and 4-wide outputs...
-  %v0a = shufflevector <8 x float> %v0, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v0b = shufflevector <8 x float> %v0, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v1a = shufflevector <8 x float> %v1, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v1b = shufflevector <8 x float> %v1, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v2a = shufflevector <8 x float> %v2, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v2b = shufflevector <8 x float> %v2, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v3a = shufflevector <8 x float> %v3, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v3b = shufflevector <8 x float> %v3, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
+        <8 x float> * noalias %out3) nounwind alwaysinline
 
-  %out0a = bitcast <8 x float> * %out0 to <4 x float> *
-  %out0b = getelementptr <4 x float> * %out0a, i32 1
-  %out1a = bitcast <8 x float> * %out1 to <4 x float> *
-  %out1b = getelementptr <4 x float> * %out1a, i32 1
-  %out2a = bitcast <8 x float> * %out2 to <4 x float> *
-  %out2b = getelementptr <4 x float> * %out2a, i32 1
-  %out3a = bitcast <8 x float> * %out3 to <4 x float> *
-  %out3b = getelementptr <4 x float> * %out3a, i32 1
-
-  ;; First part--given input vectors
-  ;; <x0 x1 x2 x3 x4 x5 x6 x7> <y0 y1 y2 y3 y4 y5 y6 y7> <z0 z1 z2 z3 z4 z5 z6 z7> 
-  ;; pass 3 4-vectors <x0 x1 x2 x3> <y0 y1 y2 y3> <z0 z1 z2 z3> to 
-  ;; compute the first 12 AOS output values.
-  call void @__soa_to_aos4_float4(<4 x float> %v0a, <4 x float> %v1a,
-         <4 x float> %v2a, <4 x float> %v3a, <4 x float> * %out0a,
-         <4 x float> * %out0b, <4 x float> * %out1a, <4 x float> * %out1b)
-
-  ;; And then pass the 3 4-vectors <x4 x5 x6 x7> <y4 y5 y6 y7> <z4 z5 z6 z7>
-  ;; To compute the next 12 AOS output values
-  call void @__soa_to_aos4_float4(<4 x float> %v0b, <4 x float> %v1b,
-         <4 x float> %v2b, <4 x float> %v3b, <4 x float> * %out2a,
-         <4 x float> * %out2b, <4 x float> * %out3a, <4 x float> * %out3b)
-  ret void
-}
-
-
-define void
+declare void
 @__aos_to_soa3_float8(<8 x float> %v0, <8 x float> %v1, <8 x float> %v2,
         <8 x float> * noalias %out0, <8 x float> * noalias %out1,
-        <8 x float> * noalias %out2) nounwind alwaysinline {
-  %v0a = shufflevector <8 x float> %v0, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v0b = shufflevector <8 x float> %v0, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v1a = shufflevector <8 x float> %v1, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v1b = shufflevector <8 x float> %v1, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v2a = shufflevector <8 x float> %v2, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v2b = shufflevector <8 x float> %v2, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-
-  %out0a = bitcast <8 x float> * %out0 to <4 x float> *
-  %out0b = getelementptr <4 x float> * %out0a, i32 1
-  %out1a = bitcast <8 x float> * %out1 to <4 x float> *
-  %out1b = getelementptr <4 x float> * %out1a, i32 1
-  %out2a = bitcast <8 x float> * %out2 to <4 x float> *
-  %out2b = getelementptr <4 x float> * %out2a, i32 1
-
-  call void @__aos_to_soa3_float4(<4 x float> %v0a, <4 x float> %v0b,
-         <4 x float> %v1a, <4 x float> * %out0a, <4 x float> * %out1a,
-         <4 x float> * %out2a)
-  call void @__aos_to_soa3_float4(<4 x float> %v1b, <4 x float> %v2a,
-         <4 x float> %v2b, <4 x float> * %out0b, <4 x float> * %out1b,
-         <4 x float> * %out2b)
-  ret void
-}
+        <8 x float> * noalias %out2) nounwind alwaysinline ;
 
 
-define void
+declare void
 @__soa_to_aos3_float8(<8 x float> %v0, <8 x float> %v1, <8 x float> %v2,
         <8 x float> * noalias %out0, <8 x float> * noalias %out1,
-        <8 x float> * noalias %out2) nounwind alwaysinline {
-  %v0a = shufflevector <8 x float> %v0, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v0b = shufflevector <8 x float> %v0, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v1a = shufflevector <8 x float> %v1, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v1b = shufflevector <8 x float> %v1, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v2a = shufflevector <8 x float> %v2, <8 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v2b = shufflevector <8 x float> %v2, <8 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-
-  %out0a = bitcast <8 x float> * %out0 to <4 x float> *
-  %out0b = getelementptr <4 x float> * %out0a, i32 1
-  %out1a = bitcast <8 x float> * %out1 to <4 x float> *
-  %out1b = getelementptr <4 x float> * %out1a, i32 1
-  %out2a = bitcast <8 x float> * %out2 to <4 x float> *
-  %out2b = getelementptr <4 x float> * %out2a, i32 1
-
-  call void @__soa_to_aos3_float4(<4 x float> %v0a, <4 x float> %v1a,
-         <4 x float> %v2a, <4 x float> * %out0a, <4 x float> * %out0b,
-         <4 x float> * %out1a)
-  call void @__soa_to_aos3_float4(<4 x float> %v0b, <4 x float> %v1b,
-         <4 x float> %v2b, <4 x float> * %out1b, <4 x float> * %out2a,
-         <4 x float> * %out2b)
-  ret void
-}
+        <8 x float> * noalias %out2) nounwind alwaysinline ;
 
 ;; 16-wide
 
-define void
+declare void
 @__aos_to_soa4_float16(<16 x float> %v0, <16 x float> %v1, <16 x float> %v2,
         <16 x float> %v3, <16 x float> * noalias %out0, 
         <16 x float> * noalias %out1, <16 x float> * noalias %out2, 
-        <16 x float> * noalias %out3) nounwind alwaysinline {
-  %v0a = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v0b = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v0c = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v0d = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
-  %v1a = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v1b = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v1c = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v1d = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
-  %v2a = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v2b = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v2c = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v2d = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
-  %v3a = shufflevector <16 x float> %v3, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v3b = shufflevector <16 x float> %v3, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v3c = shufflevector <16 x float> %v3, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v3d = shufflevector <16 x float> %v3, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
-
-  %out0a = bitcast <16 x float> * %out0 to <4 x float> *
-  %out0b = getelementptr <4 x float> * %out0a, i32 1
-  %out0c = getelementptr <4 x float> * %out0a, i32 2
-  %out0d = getelementptr <4 x float> * %out0a, i32 3
-  %out1a = bitcast <16 x float> * %out1 to <4 x float> *
-  %out1b = getelementptr <4 x float> * %out1a, i32 1
-  %out1c = getelementptr <4 x float> * %out1a, i32 2
-  %out1d = getelementptr <4 x float> * %out1a, i32 3
-  %out2a = bitcast <16 x float> * %out2 to <4 x float> *
-  %out2b = getelementptr <4 x float> * %out2a, i32 1
-  %out2c = getelementptr <4 x float> * %out2a, i32 2
-  %out2d = getelementptr <4 x float> * %out2a, i32 3
-  %out3a = bitcast <16 x float> * %out3 to <4 x float> *
-  %out3b = getelementptr <4 x float> * %out3a, i32 1
-  %out3c = getelementptr <4 x float> * %out3a, i32 2
-  %out3d = getelementptr <4 x float> * %out3a, i32 3
-
-  call void @__aos_to_soa4_float4(<4 x float> %v0a, <4 x float> %v0b,
-         <4 x float> %v0c, <4 x float> %v0d, <4 x float> * %out0a,
-         <4 x float> * %out1a, <4 x float> * %out2a, <4 x float> * %out3a)
-  call void @__aos_to_soa4_float4(<4 x float> %v1a, <4 x float> %v1b,
-         <4 x float> %v1c, <4 x float> %v1d, <4 x float> * %out0b,
-         <4 x float> * %out1b, <4 x float> * %out2b, <4 x float> * %out3b)
-  call void @__aos_to_soa4_float4(<4 x float> %v2a, <4 x float> %v2b,
-         <4 x float> %v2c, <4 x float> %v2d, <4 x float> * %out0c,
-         <4 x float> * %out1c, <4 x float> * %out2c, <4 x float> * %out3c)
-  call void @__aos_to_soa4_float4(<4 x float> %v3a, <4 x float> %v3b,
-         <4 x float> %v3c, <4 x float> %v3d, <4 x float> * %out0d,
-         <4 x float> * %out1d, <4 x float> * %out2d, <4 x float> * %out3d)
-  ret void
-}
+        <16 x float> * noalias %out3) nounwind alwaysinline ;
 
 
-define void
+declare void
 @__soa_to_aos4_float16(<16 x float> %v0, <16 x float> %v1, <16 x float> %v2,
         <16 x float> %v3, <16 x float> * noalias %out0, 
         <16 x float> * noalias %out1, <16 x float> * noalias %out2, 
-        <16 x float> * noalias %out3) nounwind alwaysinline {
-  %v0a = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v0b = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v0c = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v0d = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
-  %v1a = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v1b = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v1c = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v1d = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
-  %v2a = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v2b = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v2c = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v2d = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
-  %v3a = shufflevector <16 x float> %v3, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v3b = shufflevector <16 x float> %v3, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v3c = shufflevector <16 x float> %v3, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v3d = shufflevector <16 x float> %v3, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
+        <16 x float> * noalias %out3) nounwind alwaysinline ;
 
-  %out0a = bitcast <16 x float> * %out0 to <4 x float> *
-  %out0b = getelementptr <4 x float> * %out0a, i32 1
-  %out0c = getelementptr <4 x float> * %out0a, i32 2
-  %out0d = getelementptr <4 x float> * %out0a, i32 3
-  %out1a = bitcast <16 x float> * %out1 to <4 x float> *
-  %out1b = getelementptr <4 x float> * %out1a, i32 1
-  %out1c = getelementptr <4 x float> * %out1a, i32 2
-  %out1d = getelementptr <4 x float> * %out1a, i32 3
-  %out2a = bitcast <16 x float> * %out2 to <4 x float> *
-  %out2b = getelementptr <4 x float> * %out2a, i32 1
-  %out2c = getelementptr <4 x float> * %out2a, i32 2
-  %out2d = getelementptr <4 x float> * %out2a, i32 3
-  %out3a = bitcast <16 x float> * %out3 to <4 x float> *
-  %out3b = getelementptr <4 x float> * %out3a, i32 1
-  %out3c = getelementptr <4 x float> * %out3a, i32 2
-  %out3d = getelementptr <4 x float> * %out3a, i32 3
-
-  call void @__soa_to_aos4_float4(<4 x float> %v0a, <4 x float> %v1a,
-         <4 x float> %v2a, <4 x float> %v3a, <4 x float> * %out0a,
-         <4 x float> * %out0b, <4 x float> * %out0c, <4 x float> * %out0d)
-  call void @__soa_to_aos4_float4(<4 x float> %v0b, <4 x float> %v1b,
-         <4 x float> %v2b, <4 x float> %v3b, <4 x float> * %out1a,
-         <4 x float> * %out1b, <4 x float> * %out1c, <4 x float> * %out1d)
-  call void @__soa_to_aos4_float4(<4 x float> %v0c, <4 x float> %v1c,
-         <4 x float> %v2c, <4 x float> %v3c, <4 x float> * %out2a,
-         <4 x float> * %out2b, <4 x float> * %out2c, <4 x float> * %out2d)
-  call void @__soa_to_aos4_float4(<4 x float> %v0d, <4 x float> %v1d,
-         <4 x float> %v2d, <4 x float> %v3d, <4 x float> * %out3a,
-         <4 x float> * %out3b, <4 x float> * %out3c, <4 x float> * %out3d)
-  ret void
-}
-
-
-define void
+declare void
 @__aos_to_soa3_float16(<16 x float> %v0, <16 x float> %v1, <16 x float> %v2,
         <16 x float> * noalias %out0, <16 x float> * noalias %out1,
-        <16 x float> * noalias %out2) nounwind alwaysinline {
-  %v0a = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v0b = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v0c = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v0d = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
-  %v1a = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v1b = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v1c = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v1d = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
-  %v2a = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v2b = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v2c = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v2d = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
+        <16 x float> * noalias %out2) nounwind alwaysinline ;
 
-  %out0a = bitcast <16 x float> * %out0 to <4 x float> *
-  %out0b = getelementptr <4 x float> * %out0a, i32 1
-  %out0c = getelementptr <4 x float> * %out0a, i32 2
-  %out0d = getelementptr <4 x float> * %out0a, i32 3
-  %out1a = bitcast <16 x float> * %out1 to <4 x float> *
-  %out1b = getelementptr <4 x float> * %out1a, i32 1
-  %out1c = getelementptr <4 x float> * %out1a, i32 2
-  %out1d = getelementptr <4 x float> * %out1a, i32 3
-  %out2a = bitcast <16 x float> * %out2 to <4 x float> *
-  %out2b = getelementptr <4 x float> * %out2a, i32 1
-  %out2c = getelementptr <4 x float> * %out2a, i32 2
-  %out2d = getelementptr <4 x float> * %out2a, i32 3
-
-  call void @__aos_to_soa3_float4(<4 x float> %v0a, <4 x float> %v0b,
-         <4 x float> %v0c, <4 x float> * %out0a, <4 x float> * %out1a,
-         <4 x float> * %out2a)
-  call void @__aos_to_soa3_float4(<4 x float> %v0d, <4 x float> %v1a,
-         <4 x float> %v1b, <4 x float> * %out0b, <4 x float> * %out1b,
-         <4 x float> * %out2b)
-  call void @__aos_to_soa3_float4(<4 x float> %v1c, <4 x float> %v1d,
-         <4 x float> %v2a, <4 x float> * %out0c, <4 x float> * %out1c,
-         <4 x float> * %out2c)
-  call void @__aos_to_soa3_float4(<4 x float> %v2b, <4 x float> %v2c,
-         <4 x float> %v2d, <4 x float> * %out0d, <4 x float> * %out1d,
-         <4 x float> * %out2d)
-  ret void
-}
-
-
-define void
+declare void
 @__soa_to_aos3_float16(<16 x float> %v0, <16 x float> %v1, <16 x float> %v2,
         <16 x float> * noalias %out0, <16 x float> * noalias %out1,
-        <16 x float> * noalias %out2) nounwind alwaysinline {
-  %v0a = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v0b = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v0c = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v0d = shufflevector <16 x float> %v0, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
-  %v1a = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v1b = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v1c = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v1d = shufflevector <16 x float> %v1, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
-  %v2a = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 0, i32 1, i32 2, i32 3>
-  %v2b = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 4, i32 5, i32 6, i32 7>
-  %v2c = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 8, i32 9, i32 10, i32 11>
-  %v2d = shufflevector <16 x float> %v2, <16 x float> undef,
-         <4 x i32> <i32 12, i32 13, i32 14, i32 15>
-
-  %out0a = bitcast <16 x float> * %out0 to <4 x float> *
-  %out0b = getelementptr <4 x float> * %out0a, i32 1
-  %out0c = getelementptr <4 x float> * %out0a, i32 2
-  %out0d = getelementptr <4 x float> * %out0a, i32 3
-  %out1a = bitcast <16 x float> * %out1 to <4 x float> *
-  %out1b = getelementptr <4 x float> * %out1a, i32 1
-  %out1c = getelementptr <4 x float> * %out1a, i32 2
-  %out1d = getelementptr <4 x float> * %out1a, i32 3
-  %out2a = bitcast <16 x float> * %out2 to <4 x float> *
-  %out2b = getelementptr <4 x float> * %out2a, i32 1
-  %out2c = getelementptr <4 x float> * %out2a, i32 2
-  %out2d = getelementptr <4 x float> * %out2a, i32 3
-
-  call void @__soa_to_aos3_float4(<4 x float> %v0a, <4 x float> %v1a,
-         <4 x float> %v2a, <4 x float> * %out0a, <4 x float> * %out0b,
-         <4 x float> * %out0c)
-  call void @__soa_to_aos3_float4(<4 x float> %v0b, <4 x float> %v1b,
-         <4 x float> %v2b, <4 x float> * %out0d, <4 x float> * %out1a,
-         <4 x float> * %out1b)
-  call void @__soa_to_aos3_float4(<4 x float> %v0c, <4 x float> %v1c,
-         <4 x float> %v2c, <4 x float> * %out1c, <4 x float> * %out1d,
-         <4 x float> * %out2a)
-  call void @__soa_to_aos3_float4(<4 x float> %v0d, <4 x float> %v1d,
-         <4 x float> %v2d, <4 x float> * %out2b, <4 x float> * %out2c,
-         <4 x float> * %out2d)
-  ret void
-}
+        <16 x float> * noalias %out2) nounwind alwaysinline ;
 
 ;; versions to be called from stdlib
 
-define void
+declare void
 @__aos_to_soa4_float(float * noalias %p,
         <WIDTH x float> * noalias %out0, <WIDTH x float> * noalias %out1,
         <WIDTH x float> * noalias %out2, <WIDTH x float> * noalias %out3)
-        nounwind alwaysinline { 
-  %p0 = bitcast float * %p to <WIDTH x float> *
-  %v0 = load <WIDTH x float> * %p0, align 4
-  %p1 = getelementptr <WIDTH x float> * %p0, i32 1
-  %v1 = load <WIDTH x float> * %p1, align 4
-  %p2 = getelementptr <WIDTH x float> * %p0, i32 2
-  %v2 = load <WIDTH x float> * %p2, align 4
-  %p3 = getelementptr <WIDTH x float> * %p0, i32 3
-  %v3 = load <WIDTH x float> * %p3, align 4
-  call void @__aos_to_soa4_float`'WIDTH (<WIDTH x float> %v0, <WIDTH x float> %v1, 
-         <WIDTH x float> %v2, <WIDTH x float> %v3, <WIDTH x float> * %out0, 
-         <WIDTH x float> * %out1, <WIDTH x float> * %out2, <WIDTH x float> * %out3)
-  ret void
-}
+        nounwind alwaysinline ;
 
 
-define void
+declare void
 @__soa_to_aos4_float(<WIDTH x float> %v0, <WIDTH x float> %v1, <WIDTH x float> %v2,
-             <WIDTH x float> %v3, float * noalias %p) nounwind alwaysinline { 
-  %out0 = bitcast float * %p to <WIDTH x float> *
-  %out1 = getelementptr <WIDTH x float> * %out0, i32 1
-  %out2 = getelementptr <WIDTH x float> * %out0, i32 2
-  %out3 = getelementptr <WIDTH x float> * %out0, i32 3
-  call void @__soa_to_aos4_float`'WIDTH (<WIDTH x float> %v0, <WIDTH x float> %v1, 
-         <WIDTH x float> %v2, <WIDTH x float> %v3, <WIDTH x float> * %out0, 
-         <WIDTH x float> * %out1, <WIDTH x float> * %out2, <WIDTH x float> * %out3)
-  ret void
-}
+             <WIDTH x float> %v3, float * noalias %p) nounwind alwaysinline ;
 
 
-define void
+declare void
 @__aos_to_soa3_float(float * noalias %p,
         <WIDTH x float> * %out0, <WIDTH x float> * %out1,
-        <WIDTH x float> * %out2) nounwind alwaysinline { 
-  %p0 = bitcast float * %p to <WIDTH x float> *
-  %v0 = load <WIDTH x float> * %p0, align 4
-  %p1 = getelementptr <WIDTH x float> * %p0, i32 1
-  %v1 = load <WIDTH x float> * %p1, align 4
-  %p2 = getelementptr <WIDTH x float> * %p0, i32 2
-  %v2 = load <WIDTH x float> * %p2, align 4
-  call void @__aos_to_soa3_float`'WIDTH (<WIDTH x float> %v0, <WIDTH x float> %v1, 
-         <WIDTH x float> %v2, <WIDTH x float> * %out0, <WIDTH x float> * %out1,
-         <WIDTH x float> * %out2)
-  ret void
-}
+        <WIDTH x float> * %out2) nounwind alwaysinline ;
 
 
-define void
+declare void
 @__soa_to_aos3_float(<WIDTH x float> %v0, <WIDTH x float> %v1, <WIDTH x float> %v2,
-                     float * noalias %p) nounwind alwaysinline { 
-  %out0 = bitcast float * %p to <WIDTH x float> *
-  %out1 = getelementptr <WIDTH x float> * %out0, i32 1
-  %out2 = getelementptr <WIDTH x float> * %out0, i32 2
-  call void @__soa_to_aos3_float`'WIDTH (<WIDTH x float> %v0, <WIDTH x float> %v1, 
-         <WIDTH x float> %v2, <WIDTH x float> * %out0, <WIDTH x float> * %out1,
-         <WIDTH x float> * %out2)
-  ret void
-}
+                     float * noalias %p) nounwind alwaysinline ;
 ')
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -3109,67 +2550,19 @@ global_atomic_uniform(WIDTH, umax, i64, uint64)
 global_swap(WIDTH, i32, int32)
 global_swap(WIDTH, i64, int64)
 
-define float @__atomic_swap_uniform_float_global(float * %ptr, float %val) nounwind alwaysinline {
-  %iptr = bitcast float * %ptr to i32 *
-  %ival = bitcast float %val to i32
-  %iret = call i32 @__atomic_swap_uniform_int32_global(i32 * %iptr, i32 %ival)
-  %ret = bitcast i32 %iret to float
-  ret float %ret
-}
-
-define double @__atomic_swap_uniform_double_global(double * %ptr, double %val) nounwind alwaysinline {
-  %iptr = bitcast double * %ptr to i64 *
-  %ival = bitcast double %val to i64
-  %iret = call i64 @__atomic_swap_uniform_int64_global(i64 * %iptr, i64 %ival)
-  %ret = bitcast i64 %iret to double
-  ret double %ret
-}
-
+declare float @__atomic_swap_uniform_float_global(float * %ptr, float %val) nounwind alwaysinline ;
+declare double @__atomic_swap_uniform_double_global(double * %ptr, double %val) nounwind alwaysinline ;
 global_atomic_exchange(WIDTH, i32, int32)
 global_atomic_exchange(WIDTH, i64, int64)
 
-define <WIDTH x float> @__atomic_compare_exchange_float_global(float * %ptr,
-                      <WIDTH x float> %cmp, <WIDTH x float> %val, <WIDTH x MASK> %mask) nounwind alwaysinline {
-  %iptr = bitcast float * %ptr to i32 *
-  %icmp = bitcast <WIDTH x float> %cmp to <WIDTH x i32>
-  %ival = bitcast <WIDTH x float> %val to <WIDTH x i32>
-  %iret = call <WIDTH x i32> @__atomic_compare_exchange_int32_global(i32 * %iptr, <WIDTH x i32> %icmp,
-                                                                  <WIDTH x i32> %ival, <WIDTH x MASK> %mask)
-  %ret = bitcast <WIDTH x i32> %iret to <WIDTH x float>
-  ret <WIDTH x float> %ret
-}
-
-define <WIDTH x double> @__atomic_compare_exchange_double_global(double * %ptr,
-                      <WIDTH x double> %cmp, <WIDTH x double> %val, <WIDTH x MASK> %mask) nounwind alwaysinline {
-  %iptr = bitcast double * %ptr to i64 *
-  %icmp = bitcast <WIDTH x double> %cmp to <WIDTH x i64>
-  %ival = bitcast <WIDTH x double> %val to <WIDTH x i64>
-  %iret = call <WIDTH x i64> @__atomic_compare_exchange_int64_global(i64 * %iptr, <WIDTH x i64> %icmp,
-                                                                  <WIDTH x i64> %ival, <WIDTH x MASK> %mask)
-  %ret = bitcast <WIDTH x i64> %iret to <WIDTH x double>
-  ret <WIDTH x double> %ret
-}
-
-define float @__atomic_compare_exchange_uniform_float_global(float * %ptr, float %cmp,
-                                                             float %val) nounwind alwaysinline {
-  %iptr = bitcast float * %ptr to i32 *
-  %icmp = bitcast float %cmp to i32
-  %ival = bitcast float %val to i32
-  %iret = call i32 @__atomic_compare_exchange_uniform_int32_global(i32 * %iptr, i32 %icmp,
-                                                                   i32 %ival)
-  %ret = bitcast i32 %iret to float
-  ret float %ret
-}
-
-define double @__atomic_compare_exchange_uniform_double_global(double * %ptr, double %cmp,
-                                                               double %val) nounwind alwaysinline {
-  %iptr = bitcast double * %ptr to i64 *
-  %icmp = bitcast double %cmp to i64
-  %ival = bitcast double %val to i64
-  %iret = call i64 @__atomic_compare_exchange_uniform_int64_global(i64 * %iptr, i64 %icmp, i64 %ival)
-  %ret = bitcast i64 %iret to double
-  ret double %ret
-}
+declare <WIDTH x float> @__atomic_compare_exchange_float_global(float * %ptr,
+                      <WIDTH x float> %cmp, <WIDTH x float> %val, <WIDTH x MASK> %mask) nounwind alwaysinline ;
+declare <WIDTH x double> @__atomic_compare_exchange_double_global(double * %ptr,
+                      <WIDTH x double> %cmp, <WIDTH x double> %val, <WIDTH x MASK> %mask) nounwind alwaysinline ;
+declare float @__atomic_compare_exchange_uniform_float_global(float * %ptr, float %cmp,
+                                                             float %val) nounwind alwaysinline ;
+declare double @__atomic_compare_exchange_uniform_double_global(double * %ptr, double %cmp,
+                                                               double %val) nounwind alwaysinline ;
 
 ')