From 55b81e35a7ace4eb11565a45f036583a492e5038 Mon Sep 17 00:00:00 2001 From: Matt Pharr Date: Wed, 29 Feb 2012 14:21:03 -0800 Subject: [PATCH] Modify rules for default variability of pointed-to types. Now, the pointed-to type is always uniform by default (if an explicit rate qualifier isn't provided). This rule is easier to remember and seems to work well in more cases than the previous rule from 6d7ff7eba2f. --- docs/ispc.rst | 13 ++++++------ expr.cpp | 7 ++----- stdlib.ispc | 32 +++++++++++++++-------------- tests/ptr-21.ispc | 2 +- tests/struct-nested-4.ispc | 2 +- tests_errors/new-delete-6.ispc | 2 +- tests_errors/ptrcast-lose-info.ispc | 2 +- type.cpp | 6 ++---- 8 files changed, 31 insertions(+), 35 deletions(-) diff --git a/docs/ispc.rst b/docs/ispc.rst index 2dc59437..aba4104a 100644 --- a/docs/ispc.rst +++ b/docs/ispc.rst @@ -1507,9 +1507,8 @@ As with other basic types, pointers can be both ``uniform`` and ** Like other types in ``ispc``, pointers are ``varying`` by default, if an explicit ``uniform`` qualifier isn't provided. However, the default -variability of the pointed-to type (``uniform`` or ``varying``) is the -opposite of the pointer variability. ** This rule will be illustrated and -explained in examples below. +variability of the pointed-to type is uniform. ** This rule will be +illustrated and explained in examples below. For example, the ``ptr`` variable in the code below is a varying pointer to ``uniform float`` values. Each program instance has a separate pointer @@ -1529,7 +1528,7 @@ qualifier: :: float f = 0; - float * uniform pf = &f; // uniform pointer to a varying float + varying float * uniform pf = &f; // uniform pointer to a varying float *pf = 1; The placement of the ``uniform`` qualifier to declare a ``uniform`` pointer @@ -1546,7 +1545,7 @@ out with a separate location in memory for each program instance.) :: float a; - float * uniform pa = &a; + varying float * uniform pa = &a; *pa = programIndex; // same as (a = programIndex) Also as in C, arrays are silently converted into pointers: @@ -1554,8 +1553,8 @@ Also as in C, arrays are silently converted into pointers: :: float a[10] = { ... }; - float * uniform pa = a; // pointer to first element of a - float * uniform pb = a + 5; // pointer to 5th element of a + varying float * uniform pa = a; // pointer to first element of a + varying float * uniform pb = a + 5; // pointer to 5th element of a Any pointer type can be explicitly typecast to another pointer type, as long as the source type isn't a ``varying`` pointer when the destination diff --git a/expr.cpp b/expr.cpp index cdf4388c..a838ca1b 100644 --- a/expr.cpp +++ b/expr.cpp @@ -7432,11 +7432,8 @@ NewExpr::NewExpr(int typeQual, const Type *t, Expr *init, Expr *count, // varying new. isVarying = (typeQual == 0) || (typeQual & TYPEQUAL_VARYING); - if (allocType != NULL && allocType->HasUnboundVariability()) { - Type::Variability childVariability = isVarying ? - Type::Uniform : Type::Varying; - allocType = allocType->ResolveUnboundVariability(childVariability); - } + if (allocType != NULL && allocType->HasUnboundVariability()) + allocType = allocType->ResolveUnboundVariability(Type::Uniform); } diff --git a/stdlib.ispc b/stdlib.ispc index 82993e32..738e3a36 100644 --- a/stdlib.ispc +++ b/stdlib.ispc @@ -446,8 +446,8 @@ count_trailing_zeros(int64 v) { // AOS/SOA conversion static inline void -aos_to_soa3(uniform float a[], float * uniform v0, float * uniform v1, - float * uniform v2) { +aos_to_soa3(uniform float a[], varying float * uniform v0, + varying float * uniform v1, varying float * uniform v2) { __aos_to_soa3_float(a, v0, v1, v2); } @@ -457,8 +457,9 @@ soa_to_aos3(float v0, float v1, float v2, uniform float a[]) { } static inline void -aos_to_soa4(uniform float a[], float * uniform v0, float * uniform v1, - float * uniform v2, float * uniform v3) { +aos_to_soa4(uniform float a[], varying float * uniform v0, + varying float * uniform v1, varying float * uniform v2, + varying float * uniform v3) { __aos_to_soa4_float(a, v0, v1, v2, v3); } @@ -468,10 +469,10 @@ soa_to_aos4(float v0, float v1, float v2, float v3, uniform float a[]) { } static inline void -aos_to_soa3(uniform int32 a[], int32 * uniform v0, int32 * uniform v1, - int32 * uniform v2) { - aos_to_soa3((uniform float * uniform)a, (float * uniform)v0, - (float * uniform)v1, (float * uniform)v2); +aos_to_soa3(uniform int32 a[], varying int32 * uniform v0, + varying int32 * uniform v1, varying int32 * uniform v2) { + aos_to_soa3((uniform float * uniform)a, (varying float * uniform)v0, + (varying float * uniform)v1, (varying float * uniform)v2); } static inline void @@ -481,11 +482,12 @@ soa_to_aos3(int32 v0, int32 v1, int32 v2, uniform int32 a[]) { } static inline void -aos_to_soa4(uniform int32 a[], int32 * uniform v0, int32 * uniform v1, - int32 * uniform v2, int32 * uniform v3) { - aos_to_soa4((uniform float * uniform)a, (float * uniform )v0, - (float * uniform)v1, (float * uniform)v2, - (float * uniform)v3); +aos_to_soa4(uniform int32 a[], varying int32 * uniform v0, + varying int32 * uniform v1, varying int32 * uniform v2, + varying int32 * uniform v3) { + aos_to_soa4((uniform float * uniform)a, (varying float * uniform )v0, + (varying float * uniform)v1, (varying float * uniform)v2, + (varying float * uniform)v3); } static inline void @@ -765,7 +767,7 @@ static unsigned int64 exclusive_scan_or(unsigned int64 v) { static inline uniform int packed_load_active(uniform unsigned int a[], - unsigned int * uniform vals) { + varying unsigned int * uniform vals) { return __packed_load_active(a, vals, (UIntMaskType)__mask); } @@ -776,7 +778,7 @@ packed_store_active(uniform unsigned int a[], } static inline uniform int -packed_load_active(uniform int a[], int * uniform vals) { +packed_load_active(uniform int a[], varying int * uniform vals) { return __packed_load_active(a, vals, (IntMaskType)__mask); } diff --git a/tests/ptr-21.ispc b/tests/ptr-21.ispc index 6d162682..5abcf3ed 100644 --- a/tests/ptr-21.ispc +++ b/tests/ptr-21.ispc @@ -6,7 +6,7 @@ struct Foo { uniform float b; }; -void update(Foo * uniform fp) { +void update(varying Foo * uniform fp) { fp->a += 1; fp->b = 1; } diff --git a/tests/struct-nested-4.ispc b/tests/struct-nested-4.ispc index 5c2432f8..872a3296 100644 --- a/tests/struct-nested-4.ispc +++ b/tests/struct-nested-4.ispc @@ -17,7 +17,7 @@ void init(uniform Ray rays[], uniform int count, float v) { } } -void zero_dx(Ray * uniform r) { +void zero_dx(varying Ray * uniform r) { r->d.x = 0; } diff --git a/tests_errors/new-delete-6.ispc b/tests_errors/new-delete-6.ispc index 0462cbca..250441c2 100644 --- a/tests_errors/new-delete-6.ispc +++ b/tests_errors/new-delete-6.ispc @@ -1,4 +1,4 @@ -// Can't convert from type "uniform int32 * varying" to type "varying int32 * uniform" for return +// Can't convert from type "uniform int32 * varying" to type "uniform int32 * uniform" for return int * uniform func(int x) { return new int[x]; diff --git a/tests_errors/ptrcast-lose-info.ispc b/tests_errors/ptrcast-lose-info.ispc index eb564482..a8776206 100644 --- a/tests_errors/ptrcast-lose-info.ispc +++ b/tests_errors/ptrcast-lose-info.ispc @@ -1,4 +1,4 @@ -// Pointer type cast of type "varying int32 * uniform" to integer type "uniform int32" may lose information. +// Pointer type cast of type "uniform int32 * uniform" to integer type "uniform int32" may lose information. int32 foo(int * uniform x) { return (int32) x; diff --git a/type.cpp b/type.cpp index cabcc41b..cb863a01 100644 --- a/type.cpp +++ b/type.cpp @@ -986,10 +986,8 @@ PointerType::ResolveUnboundVariability(Variability v) const { Assert(v != Unbound); Variability ptrVariability = (variability == Unbound) ? v : variability; - Variability childVariability = (ptrVariability == Varying) ? - Uniform : Varying; - return new PointerType(baseType->ResolveUnboundVariability(childVariability), - ptrVariability, isConst); + const Type *resolvedBaseType = baseType->ResolveUnboundVariability(Uniform); + return new PointerType(resolvedBaseType, ptrVariability, isConst); }