Add API for building attribute getter free functions.

CMakeLists.txt

@@ -289,6 +289,15 @@ configure_package_config_file ("${PROJECT_SOURCE_DIR}/src/cmake/Config.cmake.in"
 install (FILES "${OSL_PROJECT_CONFIG}" "${OSL_VERSION_CONFIG}"
         DESTINATION "${OSL_CONFIG_INSTALL_DIR}")
 
+install (FILES src/cmake/llvm_macros.cmake DESTINATION cmake)
+
+set (PERMISSION_FLAGS OWNER_EXECUTE OWNER_READ OWNER_WRITE
+                      GROUP_EXECUTE GROUP_READ
+                      WORLD_EXECUTE WORLD_READ)
+install (FILES src/build-scripts/serialize-bc.py
+         DESTINATION build-scripts
+         PERMISSIONS ${PERMISSION_FLAGS})
+
 # install targets files
 install (EXPORT OSL_EXPORTED_TARGETS
         DESTINATION ${OSL_CONFIG_INSTALL_DIR}

src/cmake/llvm_macros.cmake

@@ -2,8 +2,10 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # https://github.com/AcademySoftwareFoundation/OpenShadingLanguage
 
+# TODO: Use CMAKE_CURRENT_FUNCTION_LIST_DIR in cmake-3.17
+set(_THIS_MODULE_BASE_DIR "${CMAKE_CURRENT_LIST_DIR}")
 
-function ( EMBED_LLVM_BITCODE_IN_CPP src_list suffix output_name list_to_append_cpp extra_clang_args)
+function ( EMBED_LLVM_BITCODE_IN_CPP src_list suffix output_name list_to_append_cpp extra_clang_args include_dirs)
 
     if (VERBOSE)
         message (STATUS "EMBED_LLVM_BITCODE_IN_CPP src_list=${src_list}")
@@ -75,12 +77,8 @@ function ( EMBED_LLVM_BITCODE_IN_CPP src_list suffix output_name list_to_append_
         #    endif ()
         #endif ()
 
-        list (TRANSFORM IMATH_INCLUDES PREPEND -I
-            OUTPUT_VARIABLE ALL_IMATH_INCLUDES)
-        list (TRANSFORM OPENEXR_INCLUDES PREPEND -I
-            OUTPUT_VARIABLE ALL_OPENEXR_INCLUDES)
-        list (TRANSFORM OpenImageIO_INCLUDES PREPEND -I
-            OUTPUT_VARIABLE ALL_OpenImageIO_INCLUDES)
+        list (TRANSFORM include_dirs PREPEND -I
+            OUTPUT_VARIABLE ALL_INCLUDE_DIRS)
 
         if (${LLVM_VERSION} VERSION_GREATER_EQUAL 15.0)
             # Until we fully support opaque pointers, we need to disable
@@ -93,13 +91,7 @@ function ( EMBED_LLVM_BITCODE_IN_CPP src_list suffix output_name list_to_append_
         add_custom_command ( OUTPUT ${src_bc}
         COMMAND ${LLVM_BC_GENERATOR}
             ${LLVM_COMPILE_FLAGS}
-            "-I${CMAKE_CURRENT_SOURCE_DIR}"
-            "-I${CMAKE_SOURCE_DIR}/src/include"
-            "-I${CMAKE_BINARY_DIR}/include"
-            ${ALL_OpenImageIO_INCLUDES}
-            ${ALL_IMATH_INCLUDES}
-            #"-isystem ${Boost_INCLUDE_DIRS}" #Does not pick up usr installed boost/thread/tss.hpp for oslexec_pvt.h
-            "-I${Boost_INCLUDE_DIRS}"
+            ${ALL_INCLUDE_DIRS}
             -DOSL_COMPILING_TO_BITCODE=1
             -Wno-deprecated-register
             # the following 2 warnings can be restored when all 3rd parties have fixed their export macros
@@ -131,9 +123,9 @@ function ( EMBED_LLVM_BITCODE_IN_CPP src_list suffix output_name list_to_append_
      # Serialize the linked bitcode into a CPP file 
     set ( src_bc_cpp "${CMAKE_CURRENT_BINARY_DIR}/${output_name}.bc.cpp" )
     add_custom_command ( OUTPUT ${src_bc_cpp}
-        COMMAND ${Python_EXECUTABLE} "${CMAKE_SOURCE_DIR}/src/build-scripts/serialize-bc.py"
+        COMMAND ${Python_EXECUTABLE} "${_THIS_MODULE_BASE_DIR}/../build-scripts/serialize-bc.py"
             ${linked_src_bc} ${src_bc_cpp} ${output_name}
-        DEPENDS "${CMAKE_SOURCE_DIR}/src/build-scripts/serialize-bc.py" ${linked_src_bc}
+        DEPENDS "${_THIS_MODULE_BASE_DIR}/../build-scripts/serialize-bc.py" ${linked_src_bc}
         ${exec_headers} ${PROJECT_PUBLIC_HEADERS}
         WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" )
 

src/include/OSL/oslexec.h

@@ -1031,6 +1031,18 @@ class OSLEXECPUBLIC ShadingSystem {
     void add_symlocs(cspan<SymLocationDesc> symlocs);
     void add_symlocs(ShaderGroup* group, cspan<SymLocationDesc> symlocs);
 
+    // Find the SymLocationDesc for this named param, returning its pointer
+    // or nullptr if that name is not found.
+    const SymLocationDesc* find_symloc(ustring name) const;
+    const SymLocationDesc* find_symloc(ShaderGroup* group, ustring name) const;
+
+    // Find the SymLocationDesc for this named param but only if it matches
+    // the arena type, returning its pointer or nullptr if that name is not
+    // found.
+    const SymLocationDesc* find_symloc(ustring name, SymArena arena) const;
+    const SymLocationDesc* find_symloc(ShaderGroup* group, ustring name,
+                                       SymArena arena) const;
+
     /// Ensure that the group has been optimized and optionally JITed. The ctx pointer
     /// supplies a ShadingContext to use.
     void optimize_group(ShaderGroup* group, ShadingContext* ctx,

src/include/OSL/rendererservices.h

@@ -14,6 +14,7 @@ class RendererServices;
 template<int WidthT> class BatchedRendererServices;
 class ShadingContext;
 struct ShaderGlobals;
+class ShaderGroup;
 
 // Tags for polymorphic dispatch
 template<int SimdWidthT> class WidthOf {
@@ -29,6 +30,125 @@ typedef const void* TransformationPtr;
 typedef void (*PrepareClosureFunc)(RendererServices*, int id, void* data);
 typedef void (*SetupClosureFunc)(RendererServices*, int id, void* data);
 
+enum class AttributeSpecBuiltinArg {
+    ShaderGlobalsPointer,  // void* (ideally ShaderGlobals*)
+    ShadeIndex,            // int
+    Derivatives,           // int (ideally bool)
+    Type,                  // long long (ideally TypeDesc)
+    ArrayIndex,            // int, Always zero for non-indexed array lookups.
+    ArrayLookup,           // int (ideally bool)
+    ObjectName,            // const char* (ideally ustring)
+    AttributeName,         // const char* (ideally ustring)
+};
+
+// TODO: replace with std::variant
+class AttributeSpecArg {
+    union {
+        AttributeSpecBuiltinArg m_builtin;
+        int32_t m_int32;
+        float m_float;
+        uint64_t m_uint64;
+        void* m_ptr;
+    };
+    uint32_t m_type;
+
+public:
+    AttributeSpecArg() : m_type(0) {}
+    AttributeSpecArg(AttributeSpecBuiltinArg arg) : m_builtin(arg), m_type(1) {}
+    AttributeSpecArg(int32_t arg) : m_int32(arg), m_type(2) {}
+    AttributeSpecArg(float arg) : m_float(arg), m_type(3) {}
+    AttributeSpecArg(uint64_t arg) : m_uint64(arg), m_type(4) {}
+    AttributeSpecArg(void* arg) : m_ptr(arg), m_type(5) {}
+
+    template<typename T> bool is_holding() const
+    {
+        if (std::is_same<T, AttributeSpecBuiltinArg>::value)
+            return m_type == 1;
+        if (std::is_same<T, int32_t>::value)
+            return m_type == 2;
+        if (std::is_same<T, float>::value)
+            return m_type == 3;
+        if (std::is_same<T, uint64_t>::value)
+            return m_type == 4;
+        if (std::is_same<T, void*>::value)
+            return m_type == 5;
+        return false;
+    }
+
+    template<typename T> T get() const
+    {
+        assert(false);
+        return T();
+    }
+};
+
+template<>
+inline AttributeSpecBuiltinArg
+AttributeSpecArg::get() const
+{
+    assert(is_holding<AttributeSpecBuiltinArg>());
+    return m_builtin;
+}
+
+template<>
+inline int32_t
+AttributeSpecArg::get() const
+{
+    assert(is_holding<int32_t>());
+    return m_int32;
+}
+
+template<>
+inline float
+AttributeSpecArg::get() const
+{
+    assert(is_holding<float>());
+    return m_float;
+}
+
+template<>
+inline uint64_t
+AttributeSpecArg::get() const
+{
+    assert(is_holding<uint64_t>());
+    return m_uint64;
+}
+
+template<>
+inline void*
+AttributeSpecArg::get() const
+{
+    assert(is_holding<void*>());
+    return m_ptr;
+}
+
+// The AttributeGetterSpec is never in device code, so it can be a bit more
+// complex and have dynamic allocations.  Although we do want to
+// use an interface and not allow direct data member access
+class AttributeGetterSpec {
+    ustring m_function_name;
+    std::vector<AttributeSpecArg> m_args;
+
+public:
+    template<typename... ArgListT>
+    void set(ustring function_name, ArgListT... args)
+    {
+        m_function_name = function_name;
+        m_args.clear();
+        m_args.insert(m_args.end(), std::initializer_list<AttributeSpecArg> {
+                                        AttributeSpecArg { args }... });
+    }
+
+    const ustring& function_name() const { return m_function_name; }
+    size_t arg_count() const { return m_args.size(); }
+    const AttributeSpecArg& arg(size_t i) const
+    {
+        assert(i < m_args.size());
+        return m_args[i];
+    }
+};
+
+
 // Turn off warnings about unused params for this file, since we have lots
 // of declarations with stub function bodies.
 OSL_PRAGMA_WARNING_PUSH
@@ -156,6 +276,26 @@ class OSLEXECPUBLIC RendererServices {
                                   Vec3* Pout, int npoints,
                                   TypeDesc::VECSEMANTICS vectype);
 
+    /// @brief Builds a free function to provide a value for a given attribute.
+    /// @param group The shader group currently requesting the attribute.
+    /// @param object_name The object name. An empty string will be provided if
+    /// the value is not specified or it is not known at compile time.
+    /// @param attribute_name The attribute name. An empty string will be
+    /// provided if the value is not known at compile time.
+    /// @param type The type of the value being requested.
+    /// @param derivatives True if derivatives are also being requested.
+    /// @param object_lookup True if an object name was specified, even if the
+    /// value is not known at compile time.
+    /// @param array_lookup True if the attribute lookup provides an index.
+    /// @param spec The built attribute getter.
+    /// @return True if an attribute builder was provided. If false, the
+    /// existing get_attribute or get_array_attribute functions will be
+    /// used as the fallback.
+    virtual bool build_attribute_getter(ShaderGroup& group, ustring object_name,
+                                        ustring attribute_name, TypeDesc type,
+                                        bool derivatives, bool object_lookup,
+                                        bool array_lookup,
+                                        AttributeGetterSpec& spec);
 
     /// Get the named attribute from the renderer and if found then
     /// write it into 'val'.  Otherwise, return false.  If no object is

src/liboslexec/CMakeLists.txt

@@ -220,7 +220,16 @@ endmacro ( )
 
 if (USE_LLVM_BITCODE)
     set (llvm_ops_srcs llvm_ops.cpp)
-    EMBED_LLVM_BITCODE_IN_CPP ( "${llvm_ops_srcs}" "_host" "osl_llvm_compiled_ops" lib_src "")
+
+    set(include_dirs ${CMAKE_CURRENT_SOURCE_DIR})
+    list(APPEND include_dirs ${CMAKE_SOURCE_DIR}/src/include)
+    list(APPEND include_dirs ${CMAKE_BINARY_DIR}/include)
+    list(APPEND include_dirs ${IMATH_INCLUDES})
+    list(APPEND include_dirs ${OPENEXR_INCLUDES})
+    list(APPEND include_dirs ${OpenImageIO_INCLUDES})
+    list(APPEND include_dirs ${Boost_INCLUDE_DIRS})
+
+    EMBED_LLVM_BITCODE_IN_CPP ( "${llvm_ops_srcs}" "_host" "osl_llvm_compiled_ops" lib_src "" "${include_dirs}")
 
     set (rs_dependent_ops_srcs
          opmatrix.cpp
@@ -229,7 +238,7 @@ if (USE_LLVM_BITCODE)
     # sources to rs_dependent_ops_srcs which avoids having to do it at runtime.
     list (APPEND rs_dependent_ops_srcs ${llvm_ops_srcs})
 
-    EMBED_LLVM_BITCODE_IN_CPP ( "${rs_dependent_ops_srcs}" "_host_rs" "osl_llvm_compiled_rs_dependent_ops" lib_src "")
+    EMBED_LLVM_BITCODE_IN_CPP ( "${rs_dependent_ops_srcs}" "_host_rs" "osl_llvm_compiled_rs_dependent_ops" lib_src "" "${include_dirs}")
 
     # Optionally repeat the bitcode compilation with CUDA-specific options
     if (CUDA_FOUND)

src/liboslexec/llvm_gen.cpp

@@ -3019,6 +3019,69 @@ LLVMGEN(llvm_gen_getattribute)
                                                : rop.llvm_load_string(ustring());
     llvm::Value* attr_name_arg = rop.llvm_load_value(Attribute);
 
+    ustring object_name    = (object_lookup && ObjectName.is_constant())
+                                 ? ObjectName.get_string()
+                                 : ustring();
+    ustring attribute_name = Attribute.is_constant() ? Attribute.get_string()
+                                                     : ustring();
+
+    AttributeGetterSpec spec;
+    if (rop.renderer()->build_attribute_getter(
+            rop.group(), object_name, attribute_name, dest_type,
+            Destination.has_derivs(), object_lookup, array_lookup, spec)
+        && !spec.function_name().empty()) {
+        std::vector<llvm::Value*> args;
+        for (int arg_index = 0; arg_index < spec.arg_count(); ++arg_index) {
+            const auto& arg = spec.arg(arg_index);
+            if (arg.is_holding<AttributeSpecBuiltinArg>()) {
+                switch (arg.get<AttributeSpecBuiltinArg>()) {
+                case AttributeSpecBuiltinArg::ShaderGlobalsPointer:
+                    args.push_back(rop.sg_void_ptr());
+                    break;
+                case AttributeSpecBuiltinArg::ShadeIndex:
+                    args.push_back(rop.shadeindex());
+                    break;
+                case AttributeSpecBuiltinArg::Derivatives:
+                    args.push_back(
+                        rop.ll.constant((int)Destination.has_derivs()));
+                    break;
+                case AttributeSpecBuiltinArg::Type:
+                    args.push_back(rop.ll.constant(dest_type));
+                    break;
+                case AttributeSpecBuiltinArg::ArrayIndex:
+                    if (array_lookup)
+                        args.push_back(rop.llvm_load_value(Index));
+                    else
+                        args.push_back(rop.ll.constant((int)0));
+                    break;
+                case AttributeSpecBuiltinArg::ArrayLookup:
+                    args.push_back(rop.ll.constant((int)array_lookup));
+                    break;
+                case AttributeSpecBuiltinArg::ObjectName:
+                    args.push_back(obj_name_arg);
+                    break;
+                case AttributeSpecBuiltinArg::AttributeName:
+                    args.push_back(attr_name_arg);
+                    break;
+                default: assert(false); break;
+                }
+            } else if (arg.is_holding<int32_t>()) {
+                args.push_back(rop.ll.constant(arg.get<int32_t>()));
+            } else if (arg.is_holding<float>()) {
+                args.push_back(rop.ll.constant(arg.get<float>()));
+            } else if (arg.is_holding<uint64_t>()) {
+                args.push_back(rop.ll.constant64(arg.get<uint64_t>()));
+            } else if (arg.is_holding<void*>()) {
+                args.push_back(rop.ll.constant_ptr(arg.get<void*>()));
+            } else {
+                assert(false);
+            }
+        }
+        args.push_back(rop.llvm_void_ptr(Destination));
+        llvm::Value* r = rop.ll.call_function(spec.function_name().c_str(),
+                                              args);
+        rop.llvm_store_value(r, Result);
+    } else {
     llvm::Value* args[] = {
         rop.sg_void_ptr(),
         rop.ll.constant((int)Destination.has_derivs()),
@@ -3031,6 +3094,7 @@ LLVMGEN(llvm_gen_getattribute)
     };
     llvm::Value* r = rop.ll.call_function("osl_get_attribute", args);
     rop.llvm_store_value(r, Result);
+    }
 
     return true;
 }

src/liboslexec/oslexec_pvt.h

@@ -793,6 +793,20 @@ class ShadingSystemImpl {
         for (auto& s : symlocs)
             m_symlocs.push_back(s);
     }
+    const SymLocationDesc* find_symloc(ustring name) const
+    {
+        auto f = std::lower_bound(m_symlocs.begin(), m_symlocs.end(), name);
+        return (f == m_symlocs.end() || f->name != name) ? nullptr : &(*f);
+    }
+    const SymLocationDesc* find_symloc(ustring name, SymArena arena) const
+    {
+        auto f = std::lower_bound(m_symlocs.begin(), m_symlocs.end(), name);
+        if (f != m_symlocs.end() && f->name == name && f->arena == arena
+            && f->offset != -1)
+            return &(*f);
+        else
+            return nullptr;
+    }
 
 private:
     void printstats() const;

src/liboslexec/rendservices.cpp

@@ -126,6 +126,19 @@ RendererServices::transform_points(ShaderGlobals* sg, ustringhash from,
 
 
 
+bool
+RendererServices::build_attribute_getter(ShaderGroup& group,
+                                         ustring object_name,
+                                         ustring attribute_name, TypeDesc type,
+                                         bool derivatives, bool object_lookup,
+                                         bool array_lookup,
+                                         AttributeGetterSpec& spec)
+{
+    return false;
+}
+
+
+
 bool
 RendererServices::get_attribute(ShaderGlobals* sg, bool derivatives,
                                 ustringhash object, TypeDesc type,