Cycles: Kernel address space changes for MSL

This is the first of a sequence of changes to support compiling Cycles kernels as MSL (Metal Shading Language) in preparation for a Metal GPU device implementation.

MSL requires that all pointer types be declared with explicit address space attributes (device, thread, etc...). There is already precedent for this with Cycles' address space macros (ccl_global, ccl_private, etc...), therefore the first step of MSL-enablement is to apply these consistently. Line-for-line this represents the largest change required to enable MSL. Applying this change first will simplify future patches as well as offering the emergent benefit of enhanced descriptiveness.

The vast majority of deltas in this patch fall into one of two cases:

- Ensuring ccl_private is specified for thread-local pointer types
- Ensuring ccl_global is specified for device-wide pointer types

Additionally, the ccl_addr_space qualifier can be removed. Prior to Cycles X, ccl_addr_space was used as a context-dependent address space qualifier, but now it is either redundant (e.g. in struct typedefs), or can be replaced by ccl_global in the case of pointer types. Associated function variants (e.g. lcg_step_float_addrspace) are also redundant.

In cases where address space qualifiers are chained with "const", this patch places the address space qualifier first. The rationale for this is that the choice of address space is likely to have the greater impact on runtime performance and overall architecture.

The final part of this patch is the addition of a metal/compat.h header. This is partially complete and will be extended in future patches, paving the way for the full Metal implementation.

Ref T92212

Reviewed By: brecht

Maniphest Tasks: T92212

Differential Revision: https://developer.blender.org/D12864

15 files changed, 348 insertions, 300 deletions

diff --git a/intern/cycles/kernel/geom/geom_attribute.h b/intern/cycles/kernel/geom/geom_attribute.h
index 9532a21fec7..850ac44e6e0 100644
--- a/intern/cycles/kernel/geom/geom_attribute.h
+++ b/intern/cycles/kernel/geom/geom_attribute.h
@@ -27,9 +27,11 @@ CCL_NAMESPACE_BEGIN
  * Lookup of attributes is different between OSL and SVM, as OSL is ustring
  * based while for SVM we use integer ids. */
 
-ccl_device_inline uint subd_triangle_patch(const KernelGlobals *kg, const ShaderData *sd);
+ccl_device_inline uint subd_triangle_patch(ccl_global const KernelGlobals *kg,
+                                           ccl_private const ShaderData *sd);
 
-ccl_device_inline uint attribute_primitive_type(const KernelGlobals *kg, const ShaderData *sd)
+ccl_device_inline uint attribute_primitive_type(ccl_global const KernelGlobals *kg,
+                                                ccl_private const ShaderData *sd)
 {
   if ((sd->type & PRIMITIVE_ALL_TRIANGLE) && subd_triangle_patch(kg, sd) != ~0) {
     return ATTR_PRIM_SUBD;
@@ -48,13 +50,13 @@ ccl_device_inline AttributeDescriptor attribute_not_found()
 
 /* Find attribute based on ID */
 
-ccl_device_inline uint object_attribute_map_offset(const KernelGlobals *kg, int object)
+ccl_device_inline uint object_attribute_map_offset(ccl_global const KernelGlobals *kg, int object)
 {
   return kernel_tex_fetch(__objects, object).attribute_map_offset;
 }
 
-ccl_device_inline AttributeDescriptor find_attribute(const KernelGlobals *kg,
-                                                     const ShaderData *sd,
+ccl_device_inline AttributeDescriptor find_attribute(ccl_global const KernelGlobals *kg,
+                                                     ccl_private const ShaderData *sd,
                                                      uint id)
 {
   if (sd->object == OBJECT_NONE) {
@@ -100,8 +102,8 @@ ccl_device_inline AttributeDescriptor find_attribute(const KernelGlobals *kg,
 
 /* Transform matrix attribute on meshes */
 
-ccl_device Transform primitive_attribute_matrix(const KernelGlobals *kg,
-                                                const ShaderData *sd,
+ccl_device Transform primitive_attribute_matrix(ccl_global const KernelGlobals *kg,
+                                                ccl_private const ShaderData *sd,
                                                 const AttributeDescriptor desc)
 {
   Transform tfm;
diff --git a/intern/cycles/kernel/geom/geom_curve.h b/intern/cycles/kernel/geom/geom_curve.h
index 811558edae9..07f218d781b 100644
--- a/intern/cycles/kernel/geom/geom_curve.h
+++ b/intern/cycles/kernel/geom/geom_curve.h
@@ -27,11 +27,11 @@ CCL_NAMESPACE_BEGIN
 
 /* Reading attributes on various curve elements */
 
-ccl_device float curve_attribute_float(const KernelGlobals *kg,
-                                       const ShaderData *sd,
+ccl_device float curve_attribute_float(ccl_global const KernelGlobals *kg,
+                                       ccl_private const ShaderData *sd,
                                        const AttributeDescriptor desc,
-                                       float *dx,
-                                       float *dy)
+                                       ccl_private float *dx,
+                                       ccl_private float *dy)
 {
   if (desc.element & (ATTR_ELEMENT_CURVE_KEY | ATTR_ELEMENT_CURVE_KEY_MOTION)) {
     KernelCurve curve = kernel_tex_fetch(__curves, sd->prim);
@@ -69,11 +69,11 @@ ccl_device float curve_attribute_float(const KernelGlobals *kg,
   }
 }
 
-ccl_device float2 curve_attribute_float2(const KernelGlobals *kg,
-                                         const ShaderData *sd,
+ccl_device float2 curve_attribute_float2(ccl_global const KernelGlobals *kg,
+                                         ccl_private const ShaderData *sd,
                                          const AttributeDescriptor desc,
-                                         float2 *dx,
-                                         float2 *dy)
+                                         ccl_private float2 *dx,
+                                         ccl_private float2 *dy)
 {
   if (desc.element & (ATTR_ELEMENT_CURVE_KEY | ATTR_ELEMENT_CURVE_KEY_MOTION)) {
     KernelCurve curve = kernel_tex_fetch(__curves, sd->prim);
@@ -115,11 +115,11 @@ ccl_device float2 curve_attribute_float2(const KernelGlobals *kg,
   }
 }
 
-ccl_device float3 curve_attribute_float3(const KernelGlobals *kg,
-                                         const ShaderData *sd,
+ccl_device float3 curve_attribute_float3(ccl_global const KernelGlobals *kg,
+                                         ccl_private const ShaderData *sd,
                                          const AttributeDescriptor desc,
-                                         float3 *dx,
-                                         float3 *dy)
+                                         ccl_private float3 *dx,
+                                         ccl_private float3 *dy)
 {
   if (desc.element & (ATTR_ELEMENT_CURVE_KEY | ATTR_ELEMENT_CURVE_KEY_MOTION)) {
     KernelCurve curve = kernel_tex_fetch(__curves, sd->prim);
@@ -157,11 +157,11 @@ ccl_device float3 curve_attribute_float3(const KernelGlobals *kg,
   }
 }
 
-ccl_device float4 curve_attribute_float4(const KernelGlobals *kg,
-                                         const ShaderData *sd,
+ccl_device float4 curve_attribute_float4(ccl_global const KernelGlobals *kg,
+                                         ccl_private const ShaderData *sd,
                                          const AttributeDescriptor desc,
-                                         float4 *dx,
-                                         float4 *dy)
+                                         ccl_private float4 *dx,
+                                         ccl_private float4 *dy)
 {
   if (desc.element & (ATTR_ELEMENT_CURVE_KEY | ATTR_ELEMENT_CURVE_KEY_MOTION)) {
     KernelCurve curve = kernel_tex_fetch(__curves, sd->prim);
@@ -201,7 +201,8 @@ ccl_device float4 curve_attribute_float4(const KernelGlobals *kg,
 
 /* Curve thickness */
 
-ccl_device float curve_thickness(const KernelGlobals *kg, const ShaderData *sd)
+ccl_device float curve_thickness(ccl_global const KernelGlobals *kg,
+                                 ccl_private const ShaderData *sd)
 {
   float r = 0.0f;
 
@@ -229,7 +230,8 @@ ccl_device float curve_thickness(const KernelGlobals *kg, const ShaderData *sd)
 /* Curve location for motion pass, linear interpolation between keys and
  * ignoring radius because we do the same for the motion keys */
 
-ccl_device float3 curve_motion_center_location(const KernelGlobals *kg, const ShaderData *sd)
+ccl_device float3 curve_motion_center_location(ccl_global const KernelGlobals *kg,
+                                               ccl_private const ShaderData *sd)
 {
   KernelCurve curve = kernel_tex_fetch(__curves, sd->prim);
   int k0 = curve.first_key + PRIMITIVE_UNPACK_SEGMENT(sd->type);
@@ -245,7 +247,8 @@ ccl_device float3 curve_motion_center_location(const KernelGlobals *kg, const Sh
 
 /* Curve tangent normal */
 
-ccl_device float3 curve_tangent_normal(const KernelGlobals *kg, const ShaderData *sd)
+ccl_device float3 curve_tangent_normal(ccl_global const KernelGlobals *kg,
+                                       ccl_private const ShaderData *sd)
 {
   float3 tgN = make_float3(0.0f, 0.0f, 0.0f);
 
@@ -265,12 +268,12 @@ ccl_device float3 curve_tangent_normal(const KernelGlobals *kg, const ShaderData
 
 /* Curve bounds utility function */
 
-ccl_device_inline void curvebounds(float *lower,
-                                   float *upper,
-                                   float *extremta,
-                                   float *extrema,
-                                   float *extremtb,
-                                   float *extremb,
+ccl_device_inline void curvebounds(ccl_private float *lower,
+                                   ccl_private float *upper,
+                                   ccl_private float *extremta,
+                                   ccl_private float *extrema,
+                                   ccl_private float *extremtb,
+                                   ccl_private float *extremb,
                                    float p0,
                                    float p1,
                                    float p2,
diff --git a/intern/cycles/kernel/geom/geom_curve_intersect.h b/intern/cycles/kernel/geom/geom_curve_intersect.h
index 30addb9616d..04af8ea1421 100644
--- a/intern/cycles/kernel/geom/geom_curve_intersect.h
+++ b/intern/cycles/kernel/geom/geom_curve_intersect.h
@@ -86,11 +86,11 @@ ccl_device_inline bool cylinder_intersect(const float3 cylinder_start,
                                           const float3 cylinder_end,
                                           const float cylinder_radius,
                                           const float3 ray_dir,
-                                          float2 *t_o,
-                                          float *u0_o,
-                                          float3 *Ng0_o,
-                                          float *u1_o,
-                                          float3 *Ng1_o)
+                                          ccl_private float2 *t_o,
+                                          ccl_private float *u0_o,
+                                          ccl_private float3 *Ng0_o,
+                                          ccl_private float *u1_o,
+                                          ccl_private float3 *Ng1_o)
 {
   /* Calculate quadratic equation to solve. */
   const float rl = 1.0f / len(cylinder_end - cylinder_start);
@@ -169,13 +169,13 @@ ccl_device_inline float2 half_plane_intersect(const float3 P, const float3 N, co
 }
 
 ccl_device bool curve_intersect_iterative(const float3 ray_dir,
-                                          float *ray_tfar,
+                                          ccl_private float *ray_tfar,
                                           const float dt,
                                           const float4 curve[4],
                                           float u,
                                           float t,
                                           const bool use_backfacing,
-                                          Intersection *isect)
+                                          ccl_private Intersection *isect)
 {
   const float length_ray_dir = len(ray_dir);
 
@@ -265,7 +265,7 @@ ccl_device bool curve_intersect_recursive(const float3 ray_orig,
                                           const float3 ray_dir,
                                           float ray_tfar,
                                           float4 curve[4],
-                                          Intersection *isect)
+                                          ccl_private Intersection *isect)
 {
   /* Move ray closer to make intersection stable. */
   const float3 center = float4_to_float3(0.25f * (curve[0] + curve[1] + curve[2] + curve[3]));
@@ -474,9 +474,9 @@ ccl_device_inline bool ribbon_intersect_quad(const float ray_tfar,
                                              const float3 quad_v1,
                                              const float3 quad_v2,
                                              const float3 quad_v3,
-                                             float *u_o,
-                                             float *v_o,
-                                             float *t_o)
+                                             ccl_private float *u_o,
+                                             ccl_private float *v_o,
+                                             ccl_private float *t_o)
 {
   /* Calculate vertices relative to ray origin? */
   const float3 O = make_float3(0.0f, 0.0f, 0.0f);
@@ -550,7 +550,7 @@ ccl_device_inline bool ribbon_intersect(const float3 ray_org,
                                         float ray_tfar,
                                         const int N,
                                         float4 curve[4],
-                                        Intersection *isect)
+                                        ccl_private Intersection *isect)
 {
   /* Transform control points into ray space. */
   float3 ray_space[3];
@@ -625,8 +625,8 @@ ccl_device_inline bool ribbon_intersect(const float3 ray_org,
   return false;
 }
 
-ccl_device_forceinline bool curve_intersect(const KernelGlobals *kg,
-                                            Intersection *isect,
+ccl_device_forceinline bool curve_intersect(ccl_global const KernelGlobals *kg,
+                                            ccl_private Intersection *isect,
                                             const float3 P,
                                             const float3 dir,
                                             const float tmax,
@@ -679,8 +679,8 @@ ccl_device_forceinline bool curve_intersect(const KernelGlobals *kg,
   }
 }
 
-ccl_device_inline void curve_shader_setup(const KernelGlobals *kg,
-                                          ShaderData *sd,
+ccl_device_inline void curve_shader_setup(ccl_global const KernelGlobals *kg,
+                                          ccl_private ShaderData *sd,
                                           float3 P,
                                           float3 D,
                                           float t,
diff --git a/intern/cycles/kernel/geom/geom_motion_curve.h b/intern/cycles/kernel/geom/geom_motion_curve.h
index 5294da03145..8e32df439cd 100644
--- a/intern/cycles/kernel/geom/geom_motion_curve.h
+++ b/intern/cycles/kernel/geom/geom_motion_curve.h
@@ -27,10 +27,10 @@ CCL_NAMESPACE_BEGIN
 
 #ifdef __HAIR__
 
-ccl_device_inline int find_attribute_curve_motion(const KernelGlobals *kg,
+ccl_device_inline int find_attribute_curve_motion(ccl_global const KernelGlobals *kg,
                                                   int object,
                                                   uint id,
-                                                  AttributeElement *elem)
+                                                  ccl_private AttributeElement *elem)
 {
   /* todo: find a better (faster) solution for this, maybe store offset per object.
    *
@@ -52,7 +52,7 @@ ccl_device_inline int find_attribute_curve_motion(const KernelGlobals *kg,
   return (attr_map.y == ATTR_ELEMENT_NONE) ? (int)ATTR_STD_NOT_FOUND : (int)attr_map.z;
 }
 
-ccl_device_inline void motion_curve_keys_for_step_linear(const KernelGlobals *kg,
+ccl_device_inline void motion_curve_keys_for_step_linear(ccl_global const KernelGlobals *kg,
                                                          int offset,
                                                          int numkeys,
                                                          int numsteps,
@@ -79,8 +79,13 @@ ccl_device_inline void motion_curve_keys_for_step_linear(const KernelGlobals *kg
 }
 
 /* return 2 curve key locations */
-ccl_device_inline void motion_curve_keys_linear(
-    const KernelGlobals *kg, int object, int prim, float time, int k0, int k1, float4 keys[2])
+ccl_device_inline void motion_curve_keys_linear(ccl_global const KernelGlobals *kg,
+                                                int object,
+                                                int prim,
+                                                float time,
+                                                int k0,
+                                                int k1,
+                                                float4 keys[2])
 {
   /* get motion info */
   int numsteps, numkeys;
@@ -107,7 +112,7 @@ ccl_device_inline void motion_curve_keys_linear(
   keys[1] = (1.0f - t) * keys[1] + t * next_keys[1];
 }
 
-ccl_device_inline void motion_curve_keys_for_step(const KernelGlobals *kg,
+ccl_device_inline void motion_curve_keys_for_step(ccl_global const KernelGlobals *kg,
                                                   int offset,
                                                   int numkeys,
                                                   int numsteps,
@@ -140,7 +145,7 @@ ccl_device_inline void motion_curve_keys_for_step(const KernelGlobals *kg,
 }
 
 /* return 2 curve key locations */
-ccl_device_inline void motion_curve_keys(const KernelGlobals *kg,
+ccl_device_inline void motion_curve_keys(ccl_global const KernelGlobals *kg,
                                          int object,
                                          int prim,
                                          float time,
diff --git a/intern/cycles/kernel/geom/geom_motion_triangle.h b/intern/cycles/kernel/geom/geom_motion_triangle.h
index b7f182090aa..161b358110d 100644
--- a/intern/cycles/kernel/geom/geom_motion_triangle.h
+++ b/intern/cycles/kernel/geom/geom_motion_triangle.h
@@ -31,10 +31,10 @@ CCL_NAMESPACE_BEGIN
 
 /* Time interpolation of vertex positions and normals */
 
-ccl_device_inline int find_attribute_motion(const KernelGlobals *kg,
+ccl_device_inline int find_attribute_motion(ccl_global const KernelGlobals *kg,
                                             int object,
                                             uint id,
-                                            AttributeElement *elem)
+                                            ccl_private AttributeElement *elem)
 {
   /* todo: find a better (faster) solution for this, maybe store offset per object */
   uint attr_offset = object_attribute_map_offset(kg, object);
@@ -62,7 +62,7 @@ ccl_device_inline int find_attribute_motion(const KernelGlobals *kg,
   return (attr_map.y == ATTR_ELEMENT_NONE) ? (int)ATTR_STD_NOT_FOUND : (int)attr_map.z;
 }
 
-ccl_device_inline void motion_triangle_verts_for_step(const KernelGlobals *kg,
+ccl_device_inline void motion_triangle_verts_for_step(ccl_global const KernelGlobals *kg,
                                                       uint4 tri_vindex,
                                                       int offset,
                                                       int numverts,
@@ -89,7 +89,7 @@ ccl_device_inline void motion_triangle_verts_for_step(const KernelGlobals *kg,
   }
 }
 
-ccl_device_inline void motion_triangle_normals_for_step(const KernelGlobals *kg,
+ccl_device_inline void motion_triangle_normals_for_step(ccl_global const KernelGlobals *kg,
                                                         uint4 tri_vindex,
                                                         int offset,
                                                         int numverts,
@@ -117,7 +117,7 @@ ccl_device_inline void motion_triangle_normals_for_step(const KernelGlobals *kg,
 }
 
 ccl_device_inline void motion_triangle_vertices(
-    const KernelGlobals *kg, int object, int prim, float time, float3 verts[3])
+    ccl_global const KernelGlobals *kg, int object, int prim, float time, float3 verts[3])
 {
   /* get motion info */
   int numsteps, numverts;
@@ -146,8 +146,13 @@ ccl_device_inline void motion_triangle_vertices(
   verts[2] = (1.0f - t) * verts[2] + t * next_verts[2];
 }
 
-ccl_device_inline float3 motion_triangle_smooth_normal(
-    const KernelGlobals *kg, float3 Ng, int object, int prim, float u, float v, float time)
+ccl_device_inline float3 motion_triangle_smooth_normal(ccl_global const KernelGlobals *kg,
+                                                       float3 Ng,
+                                                       int object,
+                                                       int prim,
+                                                       float u,
+                                                       float v,
+                                                       float time)
 {
   /* get motion info */
   int numsteps, numverts;
diff --git a/intern/cycles/kernel/geom/geom_motion_triangle_intersect.h b/intern/cycles/kernel/geom/geom_motion_triangle_intersect.h
index 6fb9756ff92..94d00875f0a 100644
--- a/intern/cycles/kernel/geom/geom_motion_triangle_intersect.h
+++ b/intern/cycles/kernel/geom/geom_motion_triangle_intersect.h
@@ -34,8 +34,8 @@ CCL_NAMESPACE_BEGIN
  * a closer distance.
  */
 
-ccl_device_inline float3 motion_triangle_refine(const KernelGlobals *kg,
-                                                ShaderData *sd,
+ccl_device_inline float3 motion_triangle_refine(ccl_global const KernelGlobals *kg,
+                                                ccl_private ShaderData *sd,
                                                 float3 P,
                                                 float3 D,
                                                 float t,
@@ -92,8 +92,8 @@ ccl_device_noinline
 ccl_device_inline
 #  endif
     float3
-    motion_triangle_refine_local(const KernelGlobals *kg,
-                                 ShaderData *sd,
+    motion_triangle_refine_local(ccl_global const KernelGlobals *kg,
+                                 ccl_private ShaderData *sd,
                                  float3 P,
                                  float3 D,
                                  float t,
@@ -145,8 +145,8 @@ ccl_device_inline
  * time and do a ray intersection with the resulting triangle.
  */
 
-ccl_device_inline bool motion_triangle_intersect(const KernelGlobals *kg,
-                                                 Intersection *isect,
+ccl_device_inline bool motion_triangle_intersect(ccl_global const KernelGlobals *kg,
+                                                 ccl_private Intersection *isect,
                                                  float3 P,
                                                  float3 dir,
                                                  float tmax,
@@ -202,8 +202,8 @@ ccl_device_inline bool motion_triangle_intersect(const KernelGlobals *kg,
  * Returns whether traversal should be stopped.
  */
 #ifdef __BVH_LOCAL__
-ccl_device_inline bool motion_triangle_intersect_local(const KernelGlobals *kg,
-                                                       LocalIntersection *local_isect,
+ccl_device_inline bool motion_triangle_intersect_local(ccl_global const KernelGlobals *kg,
+                                                       ccl_private LocalIntersection *local_isect,
                                                        float3 P,
                                                        float3 dir,
                                                        float time,
@@ -211,7 +211,7 @@ ccl_device_inline bool motion_triangle_intersect_local(const KernelGlobals *kg,
                                                        int local_object,
                                                        int prim_addr,
                                                        float tmax,
-                                                       uint *lcg_state,
+                                                       ccl_private uint *lcg_state,
                                                        int max_hits)
 {
   /* Only intersect with matching object, for instanced objects we
@@ -285,7 +285,7 @@ ccl_device_inline bool motion_triangle_intersect_local(const KernelGlobals *kg,
   }
 
   /* Record intersection. */
-  Intersection *isect = &local_isect->hits[hit];
+  ccl_private Intersection *isect = &local_isect->hits[hit];
   isect->t = t;
   isect->u = u;
   isect->v = v;
diff --git a/intern/cycles/kernel/geom/geom_motion_triangle_shader.h b/intern/cycles/kernel/geom/geom_motion_triangle_shader.h
index 85c4f0ca522..03bb1fba2a2 100644
--- a/intern/cycles/kernel/geom/geom_motion_triangle_shader.h
+++ b/intern/cycles/kernel/geom/geom_motion_triangle_shader.h
@@ -34,8 +34,8 @@ CCL_NAMESPACE_BEGIN
  * normals */
 
 /* return 3 triangle vertex normals */
-ccl_device_noinline void motion_triangle_shader_setup(const KernelGlobals *kg,
-                                                      ShaderData *sd,
+ccl_device_noinline void motion_triangle_shader_setup(ccl_global const KernelGlobals *kg,
+                                                      ccl_private ShaderData *sd,
                                                       const float3 P,
                                                       const float3 D,
                                                       const float ray_t,
diff --git a/intern/cycles/kernel/geom/geom_object.h b/intern/cycles/kernel/geom/geom_object.h
index 7d6ad7b4fe3..730c01d4709 100644
--- a/intern/cycles/kernel/geom/geom_object.h
+++ b/intern/cycles/kernel/geom/geom_object.h
@@ -37,7 +37,7 @@ enum ObjectVectorTransform { OBJECT_PASS_MOTION_PRE = 0, OBJECT_PASS_MOTION_POST
 
 /* Object to world space transformation */
 
-ccl_device_inline Transform object_fetch_transform(const KernelGlobals *kg,
+ccl_device_inline Transform object_fetch_transform(ccl_global const KernelGlobals *kg,
                                                    int object,
                                                    enum ObjectTransform type)
 {
@@ -51,7 +51,9 @@ ccl_device_inline Transform object_fetch_transform(const KernelGlobals *kg,
 
 /* Lamp to world space transformation */
 
-ccl_device_inline Transform lamp_fetch_transform(const KernelGlobals *kg, int lamp, bool inverse)
+ccl_device_inline Transform lamp_fetch_transform(ccl_global const KernelGlobals *kg,
+                                                 int lamp,
+                                                 bool inverse)
 {
   if (inverse) {
     return kernel_tex_fetch(__lights, lamp).itfm;
@@ -63,7 +65,7 @@ ccl_device_inline Transform lamp_fetch_transform(const KernelGlobals *kg, int la
 
 /* Object to world space transformation for motion vectors */
 
-ccl_device_inline Transform object_fetch_motion_pass_transform(const KernelGlobals *kg,
+ccl_device_inline Transform object_fetch_motion_pass_transform(ccl_global const KernelGlobals *kg,
                                                                int object,
                                                                enum ObjectVectorTransform type)
 {
@@ -74,12 +76,12 @@ ccl_device_inline Transform object_fetch_motion_pass_transform(const KernelGloba
 /* Motion blurred object transformations */
 
 #ifdef __OBJECT_MOTION__
-ccl_device_inline Transform object_fetch_transform_motion(const KernelGlobals *kg,
+ccl_device_inline Transform object_fetch_transform_motion(ccl_global const KernelGlobals *kg,
                                                           int object,
                                                           float time)
 {
   const uint motion_offset = kernel_tex_fetch(__objects, object).motion_offset;
-  const ccl_global DecomposedTransform *motion = &kernel_tex_fetch(__object_motion, motion_offset);
+  ccl_global const DecomposedTransform *motion = &kernel_tex_fetch(__object_motion, motion_offset);
   const uint num_steps = kernel_tex_fetch(__objects, object).numsteps * 2 + 1;
 
   Transform tfm;
@@ -88,10 +90,10 @@ ccl_device_inline Transform object_fetch_transform_motion(const KernelGlobals *k
   return tfm;
 }
 
-ccl_device_inline Transform object_fetch_transform_motion_test(const KernelGlobals *kg,
+ccl_device_inline Transform object_fetch_transform_motion_test(ccl_global const KernelGlobals *kg,
                                                                int object,
                                                                float time,
-                                                               Transform *itfm)
+                                                               ccl_private Transform *itfm)
 {
   int object_flag = kernel_tex_fetch(__object_flag, object);
   if (object_flag & SD_OBJECT_MOTION) {
@@ -115,7 +117,8 @@ ccl_device_inline Transform object_fetch_transform_motion_test(const KernelGloba
 
 /* Get transform matrix for shading point. */
 
-ccl_device_inline Transform object_get_transform(const KernelGlobals *kg, const ShaderData *sd)
+ccl_device_inline Transform object_get_transform(ccl_global const KernelGlobals *kg,
+                                                 ccl_private const ShaderData *sd)
 {
 #ifdef __OBJECT_MOTION__
   return (sd->object_flag & SD_OBJECT_MOTION) ?
@@ -126,8 +129,8 @@ ccl_device_inline Transform object_get_transform(const KernelGlobals *kg, const
 #endif
 }
 
-ccl_device_inline Transform object_get_inverse_transform(const KernelGlobals *kg,
-                                                         const ShaderData *sd)
+ccl_device_inline Transform object_get_inverse_transform(ccl_global const KernelGlobals *kg,
+                                                         ccl_private const ShaderData *sd)
 {
 #ifdef __OBJECT_MOTION__
   return (sd->object_flag & SD_OBJECT_MOTION) ?
@@ -139,9 +142,9 @@ ccl_device_inline Transform object_get_inverse_transform(const KernelGlobals *kg
 }
 /* Transform position from object to world space */
 
-ccl_device_inline void object_position_transform(const KernelGlobals *kg,
-                                                 const ShaderData *sd,
-                                                 float3 *P)
+ccl_device_inline void object_position_transform(ccl_global const KernelGlobals *kg,
+                                                 ccl_private const ShaderData *sd,
+                                                 ccl_private float3 *P)
 {
 #ifdef __OBJECT_MOTION__
   if (sd->object_flag & SD_OBJECT_MOTION) {
@@ -156,9 +159,9 @@ ccl_device_inline void object_position_transform(const KernelGlobals *kg,
 
 /* Transform position from world to object space */
 
-ccl_device_inline void object_inverse_position_transform(const KernelGlobals *kg,
-                                                         const ShaderData *sd,
-                                                         float3 *P)
+ccl_device_inline void object_inverse_position_transform(ccl_global const KernelGlobals *kg,
+                                                         ccl_private const ShaderData *sd,
+                                                         ccl_private float3 *P)
 {
 #ifdef __OBJECT_MOTION__
   if (sd->object_flag & SD_OBJECT_MOTION) {
@@ -173,9 +176,9 @@ ccl_device_inline void object_inverse_position_transform(const KernelGlobals *kg
 
 /* Transform normal from world to object space */
 
-ccl_device_inline void object_inverse_normal_transform(const KernelGlobals *kg,
-                                                       const ShaderData *sd,
-                                                       float3 *N)
+ccl_device_inline void object_inverse_normal_transform(ccl_global const KernelGlobals *kg,
+                                                       ccl_private const ShaderData *sd,
+                                                       ccl_private float3 *N)
 {
 #ifdef __OBJECT_MOTION__
   if (sd->object_flag & SD_OBJECT_MOTION) {
@@ -198,9 +201,9 @@ ccl_device_inline void object_inverse_normal_transform(const KernelGlobals *kg,
 
 /* Transform normal from object to world space */
 
-ccl_device_inline void object_normal_transform(const KernelGlobals *kg,
-                                               const ShaderData *sd,
-                                               float3 *N)
+ccl_device_inline void object_normal_transform(ccl_global const KernelGlobals *kg,
+                                               ccl_private const ShaderData *sd,
+                                               ccl_private float3 *N)
 {
 #ifdef __OBJECT_MOTION__
   if (sd->object_flag & SD_OBJECT_MOTION) {
@@ -215,9 +218,9 @@ ccl_device_inline void object_normal_transform(const KernelGlobals *kg,
 
 /* Transform direction vector from object to world space */
 
-ccl_device_inline void object_dir_transform(const KernelGlobals *kg,
-                                            const ShaderData *sd,
-                                            float3 *D)
+ccl_device_inline void object_dir_transform(ccl_global const KernelGlobals *kg,
+                                            ccl_private const ShaderData *sd,
+                                            ccl_private float3 *D)
 {
 #ifdef __OBJECT_MOTION__
   if (sd->object_flag & SD_OBJECT_MOTION) {
@@ -232,9 +235,9 @@ ccl_device_inline void object_dir_transform(const KernelGlobals *kg,
 
 /* Transform direction vector from world to object space */
 
-ccl_device_inline void object_inverse_dir_transform(const KernelGlobals *kg,
-                                                    const ShaderData *sd,
-                                                    float3 *D)
+ccl_device_inline void object_inverse_dir_transform(ccl_global const KernelGlobals *kg,
+                                                    ccl_private const ShaderData *sd,
+                                                    ccl_private float3 *D)
 {
 #ifdef __OBJECT_MOTION__
   if (sd->object_flag & SD_OBJECT_MOTION) {
@@ -249,7 +252,8 @@ ccl_device_inline void object_inverse_dir_transform(const KernelGlobals *kg,
 
 /* Object center position */
 
-ccl_device_inline float3 object_location(const KernelGlobals *kg, const ShaderData *sd)
+ccl_device_inline float3 object_location(ccl_global const KernelGlobals *kg,
+                                         ccl_private const ShaderData *sd)
 {
   if (sd->object == OBJECT_NONE)
     return make_float3(0.0f, 0.0f, 0.0f);
@@ -266,18 +270,18 @@ ccl_device_inline float3 object_location(const KernelGlobals *kg, const ShaderDa
 
 /* Color of the object */
 
-ccl_device_inline float3 object_color(const KernelGlobals *kg, int object)
+ccl_device_inline float3 object_color(ccl_global const KernelGlobals *kg, int object)
 {
   if (object == OBJECT_NONE)
     return make_float3(0.0f, 0.0f, 0.0f);
 
-  const ccl_global KernelObject *kobject = &kernel_tex_fetch(__objects, object);
+  ccl_global const KernelObject *kobject = &kernel_tex_fetch(__objects, object);
   return make_float3(kobject->color[0], kobject->color[1], kobject->color[2]);
 }
 
 /* Pass ID number of object */
 
-ccl_device_inline float object_pass_id(const KernelGlobals *kg, int object)
+ccl_device_inline float object_pass_id(ccl_global const KernelGlobals *kg, int object)
 {
   if (object == OBJECT_NONE)
     return 0.0f;
@@ -287,7 +291,7 @@ ccl_device_inline float object_pass_id(const KernelGlobals *kg, int object)
 
 /* Per lamp random number for shader variation */
 
-ccl_device_inline float lamp_random_number(const KernelGlobals *kg, int lamp)
+ccl_device_inline float lamp_random_number(ccl_global const KernelGlobals *kg, int lamp)
 {
   if (lamp == LAMP_NONE)
     return 0.0f;
@@ -297,7 +301,7 @@ ccl_device_inline float lamp_random_number(const KernelGlobals *kg, int lamp)
 
 /* Per object random number for shader variation */
 
-ccl_device_inline float object_random_number(const KernelGlobals *kg, int object)
+ccl_device_inline float object_random_number(ccl_global const KernelGlobals *kg, int object)
 {
   if (object == OBJECT_NONE)
     return 0.0f;
@@ -307,7 +311,7 @@ ccl_device_inline float object_random_number(const KernelGlobals *kg, int object
 
 /* Particle ID from which this object was generated */
 
-ccl_device_inline int object_particle_id(const KernelGlobals *kg, int object)
+ccl_device_inline int object_particle_id(ccl_global const KernelGlobals *kg, int object)
 {
   if (object == OBJECT_NONE)
     return 0;
@@ -317,31 +321,34 @@ ccl_device_inline int object_particle_id(const KernelGlobals *kg, int object)
 
 /* Generated texture coordinate on surface from where object was instanced */
 
-ccl_device_inline float3 object_dupli_generated(const KernelGlobals *kg, int object)
+ccl_device_inline float3 object_dupli_generated(ccl_global const KernelGlobals *kg, int object)
 {
   if (object == OBJECT_NONE)
     return make_float3(0.0f, 0.0f, 0.0f);
 
-  const ccl_global KernelObject *kobject = &kernel_tex_fetch(__objects, object);
+  ccl_global const KernelObject *kobject = &kernel_tex_fetch(__objects, object);
   return make_float3(
       kobject->dupli_generated[0], kobject->dupli_generated[1], kobject->dupli_generated[2]);
 }
 
 /* UV texture coordinate on surface from where object was instanced */
 
-ccl_device_inline float3 object_dupli_uv(const KernelGlobals *kg, int object)
+ccl_device_inline float3 object_dupli_uv(ccl_global const KernelGlobals *kg, int object)
 {
   if (object == OBJECT_NONE)
     return make_float3(0.0f, 0.0f, 0.0f);
 
-  const ccl_global KernelObject *kobject = &kernel_tex_fetch(__objects, object);
+  ccl_global const KernelObject *kobject = &kernel_tex_fetch(__objects, object);
   return make_float3(kobject->dupli_uv[0], kobject->dupli_uv[1], 0.0f);
 }
 
 /* Information about mesh for motion blurred triangles and curves */
 
-ccl_device_inline void object_motion_info(
-    const KernelGlobals *kg, int object, int *numsteps, int *numverts, int *numkeys)
+ccl_device_inline void object_motion_info(ccl_global const KernelGlobals *kg,
+                                          int object,
+                                          ccl_private int *numsteps,
+                                          ccl_private int *numverts,
+                                          ccl_private int *numkeys)
 {
   if (numkeys) {
     *numkeys = kernel_tex_fetch(__objects, object).numkeys;
@@ -355,7 +362,7 @@ ccl_device_inline void object_motion_info(
 
 /* Offset to an objects patch map */
 
-ccl_device_inline uint object_patch_map_offset(const KernelGlobals *kg, int object)
+ccl_device_inline uint object_patch_map_offset(ccl_global const KernelGlobals *kg, int object)
 {
   if (object == OBJECT_NONE)
     return 0;
@@ -365,7 +372,7 @@ ccl_device_inline uint object_patch_map_offset(const KernelGlobals *kg, int obje
 
 /* Volume step size */
 
-ccl_device_inline float object_volume_density(const KernelGlobals *kg, int object)
+ccl_device_inline float object_volume_density(ccl_global const KernelGlobals *kg, int object)
 {
   if (object == OBJECT_NONE) {
     return 1.0f;
@@ -374,7 +381,7 @@ ccl_device_inline float object_volume_density(const KernelGlobals *kg, int objec
   return kernel_tex_fetch(__objects, object).volume_density;
 }
 
-ccl_device_inline float object_volume_step_size(const KernelGlobals *kg, int object)
+ccl_device_inline float object_volume_step_size(ccl_global const KernelGlobals *kg, int object)
 {
   if (object == OBJECT_NONE) {
     return kernel_data.background.volume_step_size;
@@ -385,14 +392,14 @@ ccl_device_inline float object_volume_step_size(const KernelGlobals *kg, int obj
 
 /* Pass ID for shader */
 
-ccl_device int shader_pass_id(const KernelGlobals *kg, const ShaderData *sd)
+ccl_device int shader_pass_id(ccl_global const KernelGlobals *kg, ccl_private const ShaderData *sd)
 {
   return kernel_tex_fetch(__shaders, (sd->shader & SHADER_MASK)).pass_id;
 }
 
 /* Cryptomatte ID */
 
-ccl_device_inline float object_cryptomatte_id(const KernelGlobals *kg, int object)
+ccl_device_inline float object_cryptomatte_id(ccl_global const KernelGlobals *kg, int object)
 {
   if (object == OBJECT_NONE)
     return 0.0f;
@@ -400,7 +407,7 @@ ccl_device_inline float object_cryptomatte_id(const KernelGlobals *kg, int objec
   return kernel_tex_fetch(__objects, object).cryptomatte_object;
 }
 
-ccl_device_inline float object_cryptomatte_asset_id(const KernelGlobals *kg, int object)
+ccl_device_inline float object_cryptomatte_asset_id(ccl_global const KernelGlobals *kg, int object)
 {
   if (object == OBJECT_NONE)
     return 0;
@@ -410,42 +417,42 @@ ccl_device_inline float object_cryptomatte_asset_id(const KernelGlobals *kg, int
 
 /* Particle data from which object was instanced */
 
-ccl_device_inline uint particle_index(const KernelGlobals *kg, int particle)
+ccl_device_inline uint particle_index(ccl_global const KernelGlobals *kg, int particle)
 {
   return kernel_tex_fetch(__particles, particle).index;
 }
 
-ccl_device float particle_age(const KernelGlobals *kg, int particle)
+ccl_device float particle_age(ccl_global const KernelGlobals *kg, int particle)
 {
   return kernel_tex_fetch(__particles, particle).age;
 }
 
-ccl_device float particle_lifetime(const KernelGlobals *kg, int particle)
+ccl_device float particle_lifetime(ccl_global const KernelGlobals *kg, int particle)
 {
   return kernel_tex_fetch(__particles, particle).lifetime;
 }
 
-ccl_device float particle_size(const KernelGlobals *kg, int particle)
+ccl_device float particle_size(ccl_global const KernelGlobals *kg, int particle)
 {
   return kernel_tex_fetch(__particles, particle).size;
 }
 
-ccl_device float4 particle_rotation(const KernelGlobals *kg, int particle)
+ccl_device float4 particle_rotation(ccl_global const KernelGlobals *kg, int particle)
 {
   return kernel_tex_fetch(__particles, particle).rotation;
 }
 
-ccl_device float3 particle_location(const KernelGlobals *kg, int particle)
+ccl_device float3 particle_location(ccl_global const KernelGlobals *kg, int particle)
 {
   return float4_to_float3(kernel_tex_fetch(__particles, particle).location);
 }
 
-ccl_device float3 particle_velocity(const KernelGlobals *kg, int particle)
+ccl_device float3 particle_velocity(ccl_global const KernelGlobals *kg, int particle)
 {
   return float4_to_float3(kernel_tex_fetch(__particles, particle).velocity);
 }
 
-ccl_device float3 particle_angular_velocity(const KernelGlobals *kg, int particle)
+ccl_device float3 particle_angular_velocity(ccl_global const KernelGlobals *kg, int particle)
 {
   return float4_to_float3(kernel_tex_fetch(__particles, particle).angular_velocity);
 }
@@ -467,8 +474,12 @@ ccl_device_inline float3 bvh_inverse_direction(float3 dir)
 
 /* Transform ray into object space to enter static object in BVH */
 
-ccl_device_inline float bvh_instance_push(
-    const KernelGlobals *kg, int object, const Ray *ray, float3 *P, float3 *dir, float3 *idir)
+ccl_device_inline float bvh_instance_push(ccl_global const KernelGlobals *kg,
+                                          int object,
+                                          ccl_private const Ray *ray,
+                                          ccl_private float3 *P,
+                                          ccl_private float3 *dir,
+                                          ccl_private float3 *idir)
 {
   Transform tfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM);
 
@@ -483,12 +494,12 @@ ccl_device_inline float bvh_instance_push(
 
 /* Transform ray to exit static object in BVH. */
 
-ccl_device_inline float bvh_instance_pop(const KernelGlobals *kg,
+ccl_device_inline float bvh_instance_pop(ccl_global const KernelGlobals *kg,
                                          int object,
-                                         const Ray *ray,
-                                         float3 *P,
-                                         float3 *dir,
-                                         float3 *idir,
+                                         ccl_private const Ray *ray,
+                                         ccl_private float3 *P,
+                                         ccl_private float3 *dir,
+                                         ccl_private float3 *idir,
                                          float t)
 {
   if (t != FLT_MAX) {
@@ -505,13 +516,13 @@ ccl_device_inline float bvh_instance_pop(const KernelGlobals *kg,
 
 /* Same as above, but returns scale factor to apply to multiple intersection distances */
 
-ccl_device_inline void bvh_instance_pop_factor(const KernelGlobals *kg,
+ccl_device_inline void bvh_instance_pop_factor(ccl_global const KernelGlobals *kg,
                                                int object,
-                                               const Ray *ray,
-                                               float3 *P,
-                                               float3 *dir,
-                                               float3 *idir,
-                                               float *t_fac)
+                                               ccl_private const Ray *ray,
+                                               ccl_private float3 *P,
+                                               ccl_private float3 *dir,
+                                               ccl_private float3 *idir,
+                                               ccl_private float *t_fac)
 {
   Transform tfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM);
   *t_fac = 1.0f / len(transform_direction(&tfm, ray->D));
@@ -524,13 +535,13 @@ ccl_device_inline void bvh_instance_pop_factor(const KernelGlobals *kg,
 #ifdef __OBJECT_MOTION__
 /* Transform ray into object space to enter motion blurred object in BVH */
 
-ccl_device_inline float bvh_instance_motion_push(const KernelGlobals *kg,
+ccl_device_inline float bvh_instance_motion_push(ccl_global const KernelGlobals *kg,
                                                  int object,
-                                                 const Ray *ray,
-                                                 float3 *P,
-                                                 float3 *dir,
-                                                 float3 *idir,
-                                                 Transform *itfm)
+                                                 ccl_private const Ray *ray,
+                                                 ccl_private float3 *P,
+                                                 ccl_private float3 *dir,
+                                                 ccl_private float3 *idir,
+                                                 ccl_private Transform *itfm)
 {
   object_fetch_transform_motion_test(kg, object, ray->time, itfm);
 
@@ -545,14 +556,14 @@ ccl_device_inline float bvh_instance_motion_push(const KernelGlobals *kg,
 
 /* Transform ray to exit motion blurred object in BVH. */
 
-ccl_device_inline float bvh_instance_motion_pop(const KernelGlobals *kg,
+ccl_device_inline float bvh_instance_motion_pop(ccl_global const KernelGlobals *kg,
                                                 int object,
-                                                const Ray *ray,
-                                                float3 *P,
-                                                float3 *dir,
-                                                float3 *idir,
+                                                ccl_private const Ray *ray,
+                                                ccl_private float3 *P,
+                                                ccl_private float3 *dir,
+                                                ccl_private float3 *idir,
                                                 float t,
-                                                Transform *itfm)
+                                                ccl_private Transform *itfm)
 {
   if (t != FLT_MAX) {
     t /= len(transform_direction(itfm, ray->D));
@@ -567,14 +578,14 @@ ccl_device_inline float bvh_instance_motion_pop(const KernelGlobals *kg,
 
 /* Same as above, but returns scale factor to apply to multiple intersection distances */
 
-ccl_device_inline void bvh_instance_motion_pop_factor(const KernelGlobals *kg,
+ccl_device_inline void bvh_instance_motion_pop_factor(ccl_global const KernelGlobals *kg,
                                                       int object,
-                                                      const Ray *ray,
-                                                      float3 *P,
-                                                      float3 *dir,
-                                                      float3 *idir,
-                                                      float *t_fac,
-                                                      Transform *itfm)
+                                                      ccl_private const Ray *ray,
+                                                      ccl_private float3 *P,
+                                                      ccl_private float3 *dir,
+                                                      ccl_private float3 *idir,
+                                                      ccl_private float *t_fac,
+                                                      ccl_private Transform *itfm)
 {
   *t_fac = 1.0f / len(transform_direction(itfm, ray->D));
   *P = ray->P;
diff --git a/intern/cycles/kernel/geom/geom_patch.h b/intern/cycles/kernel/geom/geom_patch.h
index ce0fc15f196..b54eafd6220 100644
--- a/intern/cycles/kernel/geom/geom_patch.h
+++ b/intern/cycles/kernel/geom/geom_patch.h
@@ -32,7 +32,9 @@ typedef struct PatchHandle {
   int array_index, patch_index, vert_index;
 } PatchHandle;
 
-ccl_device_inline int patch_map_resolve_quadrant(float median, float *u, float *v)
+ccl_device_inline int patch_map_resolve_quadrant(float median,
+                                                 ccl_private float *u,
+                                                 ccl_private float *v)
 {
   int quadrant = -1;
 
@@ -62,7 +64,7 @@ ccl_device_inline int patch_map_resolve_quadrant(float median, float *u, float *
 /* retrieve PatchHandle from patch coords */
 
 ccl_device_inline PatchHandle
-patch_map_find_patch(const KernelGlobals *kg, int object, int patch, float u, float v)
+patch_map_find_patch(ccl_global const KernelGlobals *kg, int object, int patch, float u, float v)
 {
   PatchHandle handle;
 
@@ -108,7 +110,9 @@ patch_map_find_patch(const KernelGlobals *kg, int object, int patch, float u, fl
   return handle;
 }
 
-ccl_device_inline void patch_eval_bspline_weights(float t, float *point, float *deriv)
+ccl_device_inline void patch_eval_bspline_weights(float t,
+                                                  ccl_private float *point,
+                                                  ccl_private float *deriv)
 {
   /* The four uniform cubic B-Spline basis functions evaluated at t */
   float inv_6 = 1.0f / 6.0f;
@@ -128,7 +132,9 @@ ccl_device_inline void patch_eval_bspline_weights(float t, float *point, float *
   deriv[3] = 0.5f * t2;
 }
 
-ccl_device_inline void patch_eval_adjust_boundary_weights(uint bits, float *s, float *t)
+ccl_device_inline void patch_eval_adjust_boundary_weights(uint bits,
+                                                          ccl_private float *s,
+                                                          ccl_private float *t)
 {
   int boundary = ((bits >> 8) & 0xf);
 
@@ -175,7 +181,9 @@ ccl_device_inline float patch_eval_param_fraction(uint patch_bits)
   }
 }
 
-ccl_device_inline void patch_eval_normalize_coords(uint patch_bits, float *u, float *v)
+ccl_device_inline void patch_eval_normalize_coords(uint patch_bits,
+                                                   ccl_private float *u,
+                                                   ccl_private float *v)
 {
   float frac = patch_eval_param_fraction(patch_bits);
 
@@ -193,8 +201,8 @@ ccl_device_inline void patch_eval_normalize_coords(uint patch_bits, float *u, fl
 
 /* retrieve patch control indices */
 
-ccl_device_inline int patch_eval_indices(const KernelGlobals *kg,
-                                         const PatchHandle *handle,
+ccl_device_inline int patch_eval_indices(ccl_global const KernelGlobals *kg,
+                                         ccl_private const PatchHandle *handle,
                                          int channel,
                                          int indices[PATCH_MAX_CONTROL_VERTS])
 {
@@ -210,8 +218,8 @@ ccl_device_inline int patch_eval_indices(const KernelGlobals *kg,
 
 /* evaluate patch basis functions */
 
-ccl_device_inline void patch_eval_basis(const KernelGlobals *kg,
-                                        const PatchHandle *handle,
+ccl_device_inline void patch_eval_basis(ccl_global const KernelGlobals *kg,
+                                        ccl_private const PatchHandle *handle,
                                         float u,
                                         float v,
                                         float weights[PATCH_MAX_CONTROL_VERTS],
@@ -249,7 +257,7 @@ ccl_device_inline void patch_eval_basis(const KernelGlobals *kg,
 
 /* generic function for evaluating indices and weights from patch coords */
 
-ccl_device_inline int patch_eval_control_verts(const KernelGlobals *kg,
+ccl_device_inline int patch_eval_control_verts(ccl_global const KernelGlobals *kg,
                                                int object,
                                                int patch,
                                                float u,
@@ -271,15 +279,15 @@ ccl_device_inline int patch_eval_control_verts(const KernelGlobals *kg,
 
 /* functions for evaluating attributes on patches */
 
-ccl_device float patch_eval_float(const KernelGlobals *kg,
-                                  const ShaderData *sd,
+ccl_device float patch_eval_float(ccl_global const KernelGlobals *kg,
+                                  ccl_private const ShaderData *sd,
                                   int offset,
                                   int patch,
                                   float u,
                                   float v,
                                   int channel,
-                                  float *du,
-                                  float *dv)
+                                  ccl_private float *du,
+                                  ccl_private float *dv)
 {
   int indices[PATCH_MAX_CONTROL_VERTS];
   float weights[PATCH_MAX_CONTROL_VERTS];
@@ -308,15 +316,15 @@ ccl_device float patch_eval_float(const KernelGlobals *kg,
   return val;
 }
 
-ccl_device float2 patch_eval_float2(const KernelGlobals *kg,
-                                    const ShaderData *sd,
+ccl_device float2 patch_eval_float2(ccl_global const KernelGlobals *kg,
+                                    ccl_private const ShaderData *sd,
                                     int offset,
                                     int patch,
                                     float u,
                                     float v,
                                     int channel,
-                                    float2 *du,
-                                    float2 *dv)
+                                    ccl_private float2 *du,
+                                    ccl_private float2 *dv)
 {
   int indices[PATCH_MAX_CONTROL_VERTS];
   float weights[PATCH_MAX_CONTROL_VERTS];
@@ -345,15 +353,15 @@ ccl_device float2 patch_eval_float2(const KernelGlobals *kg,
   return val;
 }
 
-ccl_device float3 patch_eval_float3(const KernelGlobals *kg,
-                                    const ShaderData *sd,
+ccl_device float3 patch_eval_float3(ccl_global const KernelGlobals *kg,
+                                    ccl_private const ShaderData *sd,
                                     int offset,
                                     int patch,
                                     float u,
                                     float v,
                                     int channel,
-                                    float3 *du,
-                                    float3 *dv)
+                                    ccl_private float3 *du,
+                                    ccl_private float3 *dv)
 {
   int indices[PATCH_MAX_CONTROL_VERTS];
   float weights[PATCH_MAX_CONTROL_VERTS];
@@ -382,15 +390,15 @@ ccl_device float3 patch_eval_float3(const KernelGlobals *kg,
   return val;
 }
 
-ccl_device float4 patch_eval_float4(const KernelGlobals *kg,
-                                    const ShaderData *sd,
+ccl_device float4 patch_eval_float4(ccl_global const KernelGlobals *kg,
+                                    ccl_private const ShaderData *sd,
                                     int offset,
                                     int patch,
                                     float u,
                                     float v,
                                     int channel,
-                                    float4 *du,
-                                    float4 *dv)
+                                    ccl_private float4 *du,
+                                    ccl_private float4 *dv)
 {
   int indices[PATCH_MAX_CONTROL_VERTS];
   float weights[PATCH_MAX_CONTROL_VERTS];
@@ -419,15 +427,15 @@ ccl_device float4 patch_eval_float4(const KernelGlobals *kg,
   return val;
 }
 
-ccl_device float4 patch_eval_uchar4(const KernelGlobals *kg,
-                                    const ShaderData *sd,
+ccl_device float4 patch_eval_uchar4(ccl_global const KernelGlobals *kg,
+                                    ccl_private const ShaderData *sd,
                                     int offset,
                                     int patch,
                                     float u,
                                     float v,
                                     int channel,
-                                    float4 *du,
-                                    float4 *dv)
+                                    ccl_private float4 *du,
+                                    ccl_private float4 *dv)
 {
   int indices[PATCH_MAX_CONTROL_VERTS];
   float weights[PATCH_MAX_CONTROL_VERTS];
diff --git a/intern/cycles/kernel/geom/geom_primitive.h b/intern/cycles/kernel/geom/geom_primitive.h
index ba31b12e817..869b911f76f 100644
--- a/intern/cycles/kernel/geom/geom_primitive.h
+++ b/intern/cycles/kernel/geom/geom_primitive.h
@@ -31,11 +31,11 @@ CCL_NAMESPACE_BEGIN
  * attributes for performance, mainly for GPU performance to avoid bringing in
  * heavy volume interpolation code. */
 
-ccl_device_inline float primitive_surface_attribute_float(const KernelGlobals *kg,
-                                                          const ShaderData *sd,
+ccl_device_inline float primitive_surface_attribute_float(ccl_global const KernelGlobals *kg,
+                                                          ccl_private const ShaderData *sd,
                                                           const AttributeDescriptor desc,
-                                                          float *dx,
-                                                          float *dy)
+                                                          ccl_private float *dx,
+                                                          ccl_private float *dy)
 {
   if (sd->type & PRIMITIVE_ALL_TRIANGLE) {
     if (subd_triangle_patch(kg, sd) == ~0)
@@ -57,11 +57,11 @@ ccl_device_inline float primitive_surface_attribute_float(const KernelGlobals *k
   }
 }
 
-ccl_device_inline float2 primitive_surface_attribute_float2(const KernelGlobals *kg,
-                                                            const ShaderData *sd,
+ccl_device_inline float2 primitive_surface_attribute_float2(ccl_global const KernelGlobals *kg,
+                                                            ccl_private const ShaderData *sd,
                                                             const AttributeDescriptor desc,
-                                                            float2 *dx,
-                                                            float2 *dy)
+                                                            ccl_private float2 *dx,
+                                                            ccl_private float2 *dy)
 {
   if (sd->type & PRIMITIVE_ALL_TRIANGLE) {
     if (subd_triangle_patch(kg, sd) == ~0)
@@ -83,11 +83,11 @@ ccl_device_inline float2 primitive_surface_attribute_float2(const KernelGlobals
   }
 }
 
-ccl_device_inline float3 primitive_surface_attribute_float3(const KernelGlobals *kg,
-                                                            const ShaderData *sd,
+ccl_device_inline float3 primitive_surface_attribute_float3(ccl_global const KernelGlobals *kg,
+                                                            ccl_private const ShaderData *sd,
                                                             const AttributeDescriptor desc,
-                                                            float3 *dx,
-                                                            float3 *dy)
+                                                            ccl_private float3 *dx,
+                                                            ccl_private float3 *dy)
 {
   if (sd->type & PRIMITIVE_ALL_TRIANGLE) {
     if (subd_triangle_patch(kg, sd) == ~0)
@@ -109,11 +109,12 @@ ccl_device_inline float3 primitive_surface_attribute_float3(const KernelGlobals
   }
 }
 
-ccl_device_forceinline float4 primitive_surface_attribute_float4(const KernelGlobals *kg,
-                                                                 const ShaderData *sd,
-                                                                 const AttributeDescriptor desc,
-                                                                 float4 *dx,
-                                                                 float4 *dy)
+ccl_device_forceinline float4
+primitive_surface_attribute_float4(ccl_global const KernelGlobals *kg,
+                                   ccl_private const ShaderData *sd,
+                                   const AttributeDescriptor desc,
+                                   ccl_private float4 *dx,
+                                   ccl_private float4 *dy)
 {
   if (sd->type & PRIMITIVE_ALL_TRIANGLE) {
     if (subd_triangle_patch(kg, sd) == ~0)
@@ -142,14 +143,14 @@ ccl_device_forceinline float4 primitive_surface_attribute_float4(const KernelGlo
  * attributes for performance, mainly for GPU performance to avoid bringing in
  * heavy volume interpolation code. */
 
-ccl_device_inline bool primitive_is_volume_attribute(const ShaderData *sd,
+ccl_device_inline bool primitive_is_volume_attribute(ccl_private const ShaderData *sd,
                                                      const AttributeDescriptor desc)
 {
   return sd->type == PRIMITIVE_VOLUME;
 }
 
-ccl_device_inline float primitive_volume_attribute_float(const KernelGlobals *kg,
-                                                         const ShaderData *sd,
+ccl_device_inline float primitive_volume_attribute_float(ccl_global const KernelGlobals *kg,
+                                                         ccl_private const ShaderData *sd,
                                                          const AttributeDescriptor desc)
 {
   if (primitive_is_volume_attribute(sd, desc)) {
@@ -160,8 +161,8 @@ ccl_device_inline float primitive_volume_attribute_float(const KernelGlobals *kg
   }
 }
 
-ccl_device_inline float3 primitive_volume_attribute_float3(const KernelGlobals *kg,
-                                                           const ShaderData *sd,
+ccl_device_inline float3 primitive_volume_attribute_float3(ccl_global const KernelGlobals *kg,
+                                                           ccl_private const ShaderData *sd,
                                                            const AttributeDescriptor desc)
 {
   if (primitive_is_volume_attribute(sd, desc)) {
@@ -172,8 +173,8 @@ ccl_device_inline float3 primitive_volume_attribute_float3(const KernelGlobals *
   }
 }
 
-ccl_device_inline float4 primitive_volume_attribute_float4(const KernelGlobals *kg,
-                                                           const ShaderData *sd,
+ccl_device_inline float4 primitive_volume_attribute_float4(ccl_global const KernelGlobals *kg,
+                                                           ccl_private const ShaderData *sd,
                                                            const AttributeDescriptor desc)
 {
   if (primitive_is_volume_attribute(sd, desc)) {
@@ -187,7 +188,8 @@ ccl_device_inline float4 primitive_volume_attribute_float4(const KernelGlobals *
 
 /* Default UV coordinate */
 
-ccl_device_inline float3 primitive_uv(const KernelGlobals *kg, const ShaderData *sd)
+ccl_device_inline float3 primitive_uv(ccl_global const KernelGlobals *kg,
+                                      ccl_private const ShaderData *sd)
 {
   const AttributeDescriptor desc = find_attribute(kg, sd, ATTR_STD_UV);
 
@@ -200,7 +202,10 @@ ccl_device_inline float3 primitive_uv(const KernelGlobals *kg, const ShaderData
 
 /* Ptex coordinates */
 
-ccl_device bool primitive_ptex(const KernelGlobals *kg, ShaderData *sd, float2 *uv, int *face_id)
+ccl_device bool primitive_ptex(ccl_global const KernelGlobals *kg,
+                               ccl_private ShaderData *sd,
+                               ccl_private float2 *uv,
+                               ccl_private int *face_id)
 {
   /* storing ptex data as attributes is not memory efficient but simple for tests */
   const AttributeDescriptor desc_face_id = find_attribute(kg, sd, ATTR_STD_PTEX_FACE_ID);
@@ -220,7 +225,7 @@ ccl_device bool primitive_ptex(const KernelGlobals *kg, ShaderData *sd, float2 *
 
 /* Surface tangent */
 
-ccl_device float3 primitive_tangent(const KernelGlobals *kg, ShaderData *sd)
+ccl_device float3 primitive_tangent(ccl_global const KernelGlobals *kg, ccl_private ShaderData *sd)
 {
 #ifdef __HAIR__
   if (sd->type & PRIMITIVE_ALL_CURVE)
@@ -252,7 +257,8 @@ ccl_device float3 primitive_tangent(const KernelGlobals *kg, ShaderData *sd)
 
 /* Motion vector for motion pass */
 
-ccl_device_inline float4 primitive_motion_vector(const KernelGlobals *kg, const ShaderData *sd)
+ccl_device_inline float4 primitive_motion_vector(ccl_global const KernelGlobals *kg,
+                                                 ccl_private const ShaderData *sd)
 {
   /* center position */
   float3 center;
diff --git a/intern/cycles/kernel/geom/geom_shader_data.h b/intern/cycles/kernel/geom/geom_shader_data.h
index f78d194359d..2cf60e263c3 100644
--- a/intern/cycles/kernel/geom/geom_shader_data.h
+++ b/intern/cycles/kernel/geom/geom_shader_data.h
@@ -25,8 +25,8 @@ CCL_NAMESPACE_BEGIN
 /* ShaderData setup from incoming ray */
 
 #ifdef __OBJECT_MOTION__
-ccl_device void shader_setup_object_transforms(const KernelGlobals *ccl_restrict kg,
-                                               ShaderData *ccl_restrict sd,
+ccl_device void shader_setup_object_transforms(ccl_global const KernelGlobals *ccl_restrict kg,
+                                               ccl_private ShaderData *ccl_restrict sd,
                                                float time)
 {
   if (sd->object_flag & SD_OBJECT_MOTION) {
@@ -38,10 +38,10 @@ ccl_device void shader_setup_object_transforms(const KernelGlobals *ccl_restrict
 
 /* TODO: break this up if it helps reduce register pressure to load data from
  * global memory as we write it to shader-data. */
-ccl_device_inline void shader_setup_from_ray(const KernelGlobals *ccl_restrict kg,
-                                             ShaderData *ccl_restrict sd,
-                                             const Ray *ccl_restrict ray,
-                                             const Intersection *ccl_restrict isect)
+ccl_device_inline void shader_setup_from_ray(ccl_global const KernelGlobals *ccl_restrict kg,
+                                             ccl_private ShaderData *ccl_restrict sd,
+                                             ccl_private const Ray *ccl_restrict ray,
+                                             ccl_private const Intersection *ccl_restrict isect)
 {
   /* Read intersection data into shader globals.
    *
@@ -135,8 +135,8 @@ ccl_device_inline void shader_setup_from_ray(const KernelGlobals *ccl_restrict k
 
 /* ShaderData setup from position sampled on mesh */
 
-ccl_device_inline void shader_setup_from_sample(const KernelGlobals *ccl_restrict kg,
-                                                ShaderData *ccl_restrict sd,
+ccl_device_inline void shader_setup_from_sample(ccl_global const KernelGlobals *ccl_restrict kg,
+                                                ccl_private ShaderData *ccl_restrict sd,
                                                 const float3 P,
                                                 const float3 Ng,
                                                 const float3 I,
@@ -247,8 +247,8 @@ ccl_device_inline void shader_setup_from_sample(const KernelGlobals *ccl_restric
 
 /* ShaderData setup for displacement */
 
-ccl_device void shader_setup_from_displace(const KernelGlobals *ccl_restrict kg,
-                                           ShaderData *ccl_restrict sd,
+ccl_device void shader_setup_from_displace(ccl_global const KernelGlobals *ccl_restrict kg,
+                                           ccl_private ShaderData *ccl_restrict sd,
                                            int object,
                                            int prim,
                                            float u,
@@ -281,8 +281,9 @@ ccl_device void shader_setup_from_displace(const KernelGlobals *ccl_restrict kg,
 
 /* ShaderData setup from ray into background */
 
-ccl_device_inline void shader_setup_from_background(const KernelGlobals *ccl_restrict kg,
-                                                    ShaderData *ccl_restrict sd,
+ccl_device_inline void shader_setup_from_background(ccl_global const KernelGlobals *ccl_restrict
+                                                        kg,
+                                                    ccl_private ShaderData *ccl_restrict sd,
                                                     const float3 ray_P,
                                                     const float3 ray_D,
                                                     const float ray_time)
@@ -325,9 +326,9 @@ ccl_device_inline void shader_setup_from_background(const KernelGlobals *ccl_res
 /* ShaderData setup from point inside volume */
 
 #ifdef __VOLUME__
-ccl_device_inline void shader_setup_from_volume(const KernelGlobals *ccl_restrict kg,
-                                                ShaderData *ccl_restrict sd,
-                                                const Ray *ccl_restrict ray)
+ccl_device_inline void shader_setup_from_volume(ccl_global const KernelGlobals *ccl_restrict kg,
+                                                ccl_private ShaderData *ccl_restrict sd,
+                                                ccl_private const Ray *ccl_restrict ray)
 {
 
   /* vectors */
diff --git a/intern/cycles/kernel/geom/geom_subd_triangle.h b/intern/cycles/kernel/geom/geom_subd_triangle.h
index 877b2ece15b..927d630fe91 100644
--- a/intern/cycles/kernel/geom/geom_subd_triangle.h
+++ b/intern/cycles/kernel/geom/geom_subd_triangle.h
@@ -22,15 +22,16 @@ CCL_NAMESPACE_BEGIN
 
 /* Patch index for triangle, -1 if not subdivision triangle */
 
-ccl_device_inline uint subd_triangle_patch(const KernelGlobals *kg, const ShaderData *sd)
+ccl_device_inline uint subd_triangle_patch(ccl_global const KernelGlobals *kg,
+                                           ccl_private const ShaderData *sd)
 {
   return (sd->prim != PRIM_NONE) ? kernel_tex_fetch(__tri_patch, sd->prim) : ~0;
 }
 
 /* UV coords of triangle within patch */
 
-ccl_device_inline void subd_triangle_patch_uv(const KernelGlobals *kg,
-                                              const ShaderData *sd,
+ccl_device_inline void subd_triangle_patch_uv(ccl_global const KernelGlobals *kg,
+                                              ccl_private const ShaderData *sd,
                                               float2 uv[3])
 {
   uint4 tri_vindex = kernel_tex_fetch(__tri_vindex, sd->prim);
@@ -42,7 +43,7 @@ ccl_device_inline void subd_triangle_patch_uv(const KernelGlobals *kg,
 
 /* Vertex indices of patch */
 
-ccl_device_inline uint4 subd_triangle_patch_indices(const KernelGlobals *kg, int patch)
+ccl_device_inline uint4 subd_triangle_patch_indices(ccl_global const KernelGlobals *kg, int patch)
 {
   uint4 indices;
 
@@ -56,21 +57,22 @@ ccl_device_inline uint4 subd_triangle_patch_indices(const KernelGlobals *kg, int
 
 /* Originating face for patch */
 
-ccl_device_inline uint subd_triangle_patch_face(const KernelGlobals *kg, int patch)
+ccl_device_inline uint subd_triangle_patch_face(ccl_global const KernelGlobals *kg, int patch)
 {
   return kernel_tex_fetch(__patches, patch + 4);
 }
 
 /* Number of corners on originating face */
 
-ccl_device_inline uint subd_triangle_patch_num_corners(const KernelGlobals *kg, int patch)
+ccl_device_inline uint subd_triangle_patch_num_corners(ccl_global const KernelGlobals *kg,
+                                                       int patch)
 {
   return kernel_tex_fetch(__patches, patch + 5) & 0xffff;
 }
 
 /* Indices of the four corners that are used by the patch */
 
-ccl_device_inline void subd_triangle_patch_corners(const KernelGlobals *kg,
+ccl_device_inline void subd_triangle_patch_corners(ccl_global const KernelGlobals *kg,
                                                    int patch,
                                                    int corners[4])
 {
@@ -103,11 +105,11 @@ ccl_device_inline void subd_triangle_patch_corners(const KernelGlobals *kg,
 
 /* Reading attributes on various subdivision triangle elements */
 
-ccl_device_noinline float subd_triangle_attribute_float(const KernelGlobals *kg,
-                                                        const ShaderData *sd,
+ccl_device_noinline float subd_triangle_attribute_float(ccl_global const KernelGlobals *kg,
+                                                        ccl_private const ShaderData *sd,
                                                         const AttributeDescriptor desc,
-                                                        float *dx,
-                                                        float *dy)
+                                                        ccl_private float *dx,
+                                                        ccl_private float *dy)
 {
   int patch = subd_triangle_patch(kg, sd);
 
@@ -242,11 +244,11 @@ ccl_device_noinline float subd_triangle_attribute_float(const KernelGlobals *kg,
   }
 }
 
-ccl_device_noinline float2 subd_triangle_attribute_float2(const KernelGlobals *kg,
-                                                          const ShaderData *sd,
+ccl_device_noinline float2 subd_triangle_attribute_float2(ccl_global const KernelGlobals *kg,
+                                                          ccl_private const ShaderData *sd,
                                                           const AttributeDescriptor desc,
-                                                          float2 *dx,
-                                                          float2 *dy)
+                                                          ccl_private float2 *dx,
+                                                          ccl_private float2 *dy)
 {
   int patch = subd_triangle_patch(kg, sd);
 
@@ -385,11 +387,11 @@ ccl_device_noinline float2 subd_triangle_attribute_float2(const KernelGlobals *k
   }
 }
 
-ccl_device_noinline float3 subd_triangle_attribute_float3(const KernelGlobals *kg,
-                                                          const ShaderData *sd,
+ccl_device_noinline float3 subd_triangle_attribute_float3(ccl_global const KernelGlobals *kg,
+                                                          ccl_private const ShaderData *sd,
                                                           const AttributeDescriptor desc,
-                                                          float3 *dx,
-                                                          float3 *dy)
+                                                          ccl_private float3 *dx,
+                                                          ccl_private float3 *dy)
 {
   int patch = subd_triangle_patch(kg, sd);
 
@@ -527,11 +529,11 @@ ccl_device_noinline float3 subd_triangle_attribute_float3(const KernelGlobals *k
   }
 }
 
-ccl_device_noinline float4 subd_triangle_attribute_float4(const KernelGlobals *kg,
-                                                          const ShaderData *sd,
+ccl_device_noinline float4 subd_triangle_attribute_float4(ccl_global const KernelGlobals *kg,
+                                                          ccl_private const ShaderData *sd,
                                                           const AttributeDescriptor desc,
-                                                          float4 *dx,
-                                                          float4 *dy)
+                                                          ccl_private float4 *dx,
+                                                          ccl_private float4 *dy)
 {
   int patch = subd_triangle_patch(kg, sd);
 
diff --git a/intern/cycles/kernel/geom/geom_triangle.h b/intern/cycles/kernel/geom/geom_triangle.h
index 8edba46fd39..17f87b7c570 100644
--- a/intern/cycles/kernel/geom/geom_triangle.h
+++ b/intern/cycles/kernel/geom/geom_triangle.h
@@ -25,7 +25,8 @@
 CCL_NAMESPACE_BEGIN
 
 /* Normal on triangle. */
-ccl_device_inline float3 triangle_normal(const KernelGlobals *kg, ShaderData *sd)
+ccl_device_inline float3 triangle_normal(ccl_global const KernelGlobals *kg,
+                                         ccl_private ShaderData *sd)
 {
   /* load triangle vertices */
   const uint4 tri_vindex = kernel_tex_fetch(__tri_vindex, sd->prim);
@@ -43,14 +44,14 @@ ccl_device_inline float3 triangle_normal(const KernelGlobals *kg, ShaderData *sd
 }
 
 /* Point and normal on triangle. */
-ccl_device_inline void triangle_point_normal(const KernelGlobals *kg,
+ccl_device_inline void triangle_point_normal(ccl_global const KernelGlobals *kg,
                                              int object,
                                              int prim,
                                              float u,
                                              float v,
-                                             float3 *P,
-                                             float3 *Ng,
-                                             int *shader)
+                                             ccl_private float3 *P,
+                                             ccl_private float3 *Ng,
+                                             ccl_private int *shader)
 {
   /* load triangle vertices */
   const uint4 tri_vindex = kernel_tex_fetch(__tri_vindex, prim);
@@ -75,7 +76,7 @@ ccl_device_inline void triangle_point_normal(const KernelGlobals *kg,
 
 /* Triangle vertex locations */
 
-ccl_device_inline void triangle_vertices(const KernelGlobals *kg, int prim, float3 P[3])
+ccl_device_inline void triangle_vertices(ccl_global const KernelGlobals *kg, int prim, float3 P[3])
 {
   const uint4 tri_vindex = kernel_tex_fetch(__tri_vindex, prim);
   P[0] = float4_to_float3(kernel_tex_fetch(__tri_verts, tri_vindex.w + 0));
@@ -85,7 +86,7 @@ ccl_device_inline void triangle_vertices(const KernelGlobals *kg, int prim, floa
 
 /* Triangle vertex locations and vertex normals */
 
-ccl_device_inline void triangle_vertices_and_normals(const KernelGlobals *kg,
+ccl_device_inline void triangle_vertices_and_normals(ccl_global const KernelGlobals *kg,
                                                      int prim,
                                                      float3 P[3],
                                                      float3 N[3])
@@ -102,7 +103,7 @@ ccl_device_inline void triangle_vertices_and_normals(const KernelGlobals *kg,
 /* Interpolate smooth vertex normal from vertices */
 
 ccl_device_inline float3
-triangle_smooth_normal(const KernelGlobals *kg, float3 Ng, int prim, float u, float v)
+triangle_smooth_normal(ccl_global const KernelGlobals *kg, float3 Ng, int prim, float u, float v)
 {
   /* load triangle vertices */
   const uint4 tri_vindex = kernel_tex_fetch(__tri_vindex, prim);
@@ -115,8 +116,12 @@ triangle_smooth_normal(const KernelGlobals *kg, float3 Ng, int prim, float u, fl
   return is_zero(N) ? Ng : N;
 }
 
-ccl_device_inline float3 triangle_smooth_normal_unnormalized(
-    const KernelGlobals *kg, const ShaderData *sd, float3 Ng, int prim, float u, float v)
+ccl_device_inline float3 triangle_smooth_normal_unnormalized(ccl_global const KernelGlobals *kg,
+                                                             ccl_private const ShaderData *sd,
+                                                             float3 Ng,
+                                                             int prim,
+                                                             float u,
+                                                             float v)
 {
   /* load triangle vertices */
   const uint4 tri_vindex = kernel_tex_fetch(__tri_vindex, prim);
@@ -138,10 +143,10 @@ ccl_device_inline float3 triangle_smooth_normal_unnormalized(
 
 /* Ray differentials on triangle */
 
-ccl_device_inline void triangle_dPdudv(const KernelGlobals *kg,
+ccl_device_inline void triangle_dPdudv(ccl_global const KernelGlobals *kg,
                                        int prim,
-                                       ccl_addr_space float3 *dPdu,
-                                       ccl_addr_space float3 *dPdv)
+                                       ccl_private float3 *dPdu,
+                                       ccl_private float3 *dPdv)
 {
   /* fetch triangle vertex coordinates */
   const uint4 tri_vindex = kernel_tex_fetch(__tri_vindex, prim);
@@ -156,11 +161,11 @@ ccl_device_inline void triangle_dPdudv(const KernelGlobals *kg,
 
 /* Reading attributes on various triangle elements */
 
-ccl_device float triangle_attribute_float(const KernelGlobals *kg,
-                                          const ShaderData *sd,
+ccl_device float triangle_attribute_float(ccl_global const KernelGlobals *kg,
+                                          ccl_private const ShaderData *sd,
                                           const AttributeDescriptor desc,
-                                          float *dx,
-                                          float *dy)
+                                          ccl_private float *dx,
+                                          ccl_private float *dy)
 {
   if (desc.element & (ATTR_ELEMENT_VERTEX | ATTR_ELEMENT_VERTEX_MOTION | ATTR_ELEMENT_CORNER)) {
     float f0, f1, f2;
@@ -206,11 +211,11 @@ ccl_device float triangle_attribute_float(const KernelGlobals *kg,
   }
 }
 
-ccl_device float2 triangle_attribute_float2(const KernelGlobals *kg,
-                                            const ShaderData *sd,
+ccl_device float2 triangle_attribute_float2(ccl_global const KernelGlobals *kg,
+                                            ccl_private const ShaderData *sd,
                                             const AttributeDescriptor desc,
-                                            float2 *dx,
-                                            float2 *dy)
+                                            ccl_private float2 *dx,
+                                            ccl_private float2 *dy)
 {
   if (desc.element & (ATTR_ELEMENT_VERTEX | ATTR_ELEMENT_VERTEX_MOTION | ATTR_ELEMENT_CORNER)) {
     float2 f0, f1, f2;
@@ -256,11 +261,11 @@ ccl_device float2 triangle_attribute_float2(const KernelGlobals *kg,
   }
 }
 
-ccl_device float3 triangle_attribute_float3(const KernelGlobals *kg,
-                                            const ShaderData *sd,
+ccl_device float3 triangle_attribute_float3(ccl_global const KernelGlobals *kg,
+                                            ccl_private const ShaderData *sd,
                                             const AttributeDescriptor desc,
-                                            float3 *dx,
-                                            float3 *dy)
+                                            ccl_private float3 *dx,
+                                            ccl_private float3 *dy)
 {
   if (desc.element & (ATTR_ELEMENT_VERTEX | ATTR_ELEMENT_VERTEX_MOTION | ATTR_ELEMENT_CORNER)) {
     float3 f0, f1, f2;
@@ -306,11 +311,11 @@ ccl_device float3 triangle_attribute_float3(const KernelGlobals *kg,
   }
 }
 
-ccl_device float4 triangle_attribute_float4(const KernelGlobals *kg,
-                                            const ShaderData *sd,
+ccl_device float4 triangle_attribute_float4(ccl_global const KernelGlobals *kg,
+                                            ccl_private const ShaderData *sd,
                                             const AttributeDescriptor desc,
-                                            float4 *dx,
-                                            float4 *dy)
+                                            ccl_private float4 *dx,
+                                            ccl_private float4 *dy)
 {
   if (desc.element & (ATTR_ELEMENT_VERTEX | ATTR_ELEMENT_VERTEX_MOTION | ATTR_ELEMENT_CORNER |
                       ATTR_ELEMENT_CORNER_BYTE)) {
diff --git a/intern/cycles/kernel/geom/geom_triangle_intersect.h b/intern/cycles/kernel/geom/geom_triangle_intersect.h
index b784cc75d08..f637206da19 100644
--- a/intern/cycles/kernel/geom/geom_triangle_intersect.h
+++ b/intern/cycles/kernel/geom/geom_triangle_intersect.h
@@ -26,8 +26,8 @@
 
 CCL_NAMESPACE_BEGIN
 
-ccl_device_inline bool triangle_intersect(const KernelGlobals *kg,
-                                          Intersection *isect,
+ccl_device_inline bool triangle_intersect(ccl_global const KernelGlobals *kg,
+                                          ccl_private Intersection *isect,
                                           float3 P,
                                           float3 dir,
                                           float tmax,
@@ -85,15 +85,15 @@ ccl_device_inline bool triangle_intersect(const KernelGlobals *kg,
  */
 
 #ifdef __BVH_LOCAL__
-ccl_device_inline bool triangle_intersect_local(const KernelGlobals *kg,
-                                                LocalIntersection *local_isect,
+ccl_device_inline bool triangle_intersect_local(ccl_global const KernelGlobals *kg,
+                                                ccl_private LocalIntersection *local_isect,
                                                 float3 P,
                                                 float3 dir,
                                                 int object,
                                                 int local_object,
                                                 int prim_addr,
                                                 float tmax,
-                                                uint *lcg_state,
+                                                ccl_private uint *lcg_state,
                                                 int max_hits)
 {
   /* Only intersect with matching object, for instanced objects we
@@ -169,7 +169,7 @@ ccl_device_inline bool triangle_intersect_local(const KernelGlobals *kg,
   }
 
   /* Record intersection. */
-  Intersection *isect = &local_isect->hits[hit];
+  ccl_private Intersection *isect = &local_isect->hits[hit];
   isect->prim = prim;
   isect->object = local_object;
   isect->type = PRIMITIVE_TRIANGLE;
@@ -200,8 +200,8 @@ ccl_device_inline bool triangle_intersect_local(const KernelGlobals *kg,
  * http://www.cs.virginia.edu/~gfx/Courses/2003/ImageSynthesis/papers/Acceleration/Fast%20MinimumStorage%20RayTriangle%20Intersection.pdf
  */
 
-ccl_device_inline float3 triangle_refine(const KernelGlobals *kg,
-                                         ShaderData *sd,
+ccl_device_inline float3 triangle_refine(ccl_global const KernelGlobals *kg,
+                                         ccl_private ShaderData *sd,
                                          float3 P,
                                          float3 D,
                                          float t,
@@ -256,8 +256,8 @@ ccl_device_inline float3 triangle_refine(const KernelGlobals *kg,
 /* Same as above, except that t is assumed to be in object space for
  * instancing.
  */
-ccl_device_inline float3 triangle_refine_local(const KernelGlobals *kg,
-                                               ShaderData *sd,
+ccl_device_inline float3 triangle_refine_local(ccl_global const KernelGlobals *kg,
+                                               ccl_private ShaderData *sd,
                                                float3 P,
                                                float3 D,
                                                float t,
diff --git a/intern/cycles/kernel/geom/geom_volume.h b/intern/cycles/kernel/geom/geom_volume.h
index 2bcd7e56b5f..c466c3fb07a 100644
--- a/intern/cycles/kernel/geom/geom_volume.h
+++ b/intern/cycles/kernel/geom/geom_volume.h
@@ -31,8 +31,8 @@ CCL_NAMESPACE_BEGIN
 
 /* Return position normalized to 0..1 in mesh bounds */
 
-ccl_device_inline float3 volume_normalized_position(const KernelGlobals *kg,
-                                                    const ShaderData *sd,
+ccl_device_inline float3 volume_normalized_position(ccl_global const KernelGlobals *kg,
+                                                    ccl_private const ShaderData *sd,
                                                     float3 P)
 {
   /* todo: optimize this so it's just a single matrix multiplication when
@@ -70,8 +70,8 @@ ccl_device float3 volume_attribute_value_to_float3(const float4 value)
   }
 }
 
-ccl_device float4 volume_attribute_float4(const KernelGlobals *kg,
-                                          const ShaderData *sd,
+ccl_device float4 volume_attribute_float4(ccl_global const KernelGlobals *kg,
+                                          ccl_private const ShaderData *sd,
                                           const AttributeDescriptor desc)
 {
   if (desc.element & (ATTR_ELEMENT_OBJECT | ATTR_ELEMENT_MESH)) {