Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a7044719 authored by Nick Desaulniers's avatar Nick Desaulniers
Browse files

[frameworks][native][vulkan] fix -Walloca 



Alloca cannot be checked for failure. Replace alloca with dynamic memory
allocations.

Bug: 139945549
Bug: 142475221
Test: mm
Merged-In: I1a154b479c8da66e25d20dced6bf9ae269b906f8
Change-Id: Ife0a599db7f85f0c324717f526050f276fe43445
Signed-off-by: default avatarNick Desaulniers <ndesaulniers@google.com>
parent 8ba0cadc

vulkan/libvulkan/driver.cpp

+10 −9
Original line number Diff line number Diff line
@@ -24,7 +24,10 @@ 
#include <dlfcn.h>

#include <algorithm>

#include <array>

#include <climits>

#include <new>

#include <sstream>

#include <string>



#include <log/log.h>
@@ -153,15 +156,12 @@ class CreateInfoWrapper { 
Hal Hal::hal_;



void* LoadLibrary(const android_dlextinfo& dlextinfo,

                  const char* subname,

                  int subname_len) {

                  const std::string_view subname) {

    ATRACE_CALL();



    const char kLibFormat[] = "vulkan.%*s.so";

    char* name = static_cast<char*>(

        alloca(sizeof(kLibFormat) + static_cast<size_t>(subname_len)));

    sprintf(name, kLibFormat, subname_len, subname);

    return android_dlopen_ext(name, RTLD_LOCAL | RTLD_NOW, &dlextinfo);

    std::stringstream ss;

    ss << "vulkan." << subname << ".so";

    return android_dlopen_ext(ss.str().c_str(), RTLD_LOCAL | RTLD_NOW, &dlextinfo);

}



const std::array<const char*, 2> HAL_SUBNAME_KEY_PROPERTIES = {{
@@ -181,8 +181,9 @@ int LoadDriver(android_namespace_t* library_namespace, 
    char prop[PROPERTY_VALUE_MAX];

    for (auto key : HAL_SUBNAME_KEY_PROPERTIES) {

        int prop_len = property_get(key, prop, nullptr);

        if (prop_len > 0) {

            so = LoadLibrary(dlextinfo, prop, prop_len);

        if (prop_len > 0 && prop_len <= UINT_MAX) {

            std::string_view lib_name(prop, static_cast<unsigned int>(prop_len));

            so = LoadLibrary(dlextinfo, lib_name);

            if (so)

                break;

        }

vulkan/libvulkan/layers_extensions.cpp

+13 −32
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include <string.h>

#include <sys/prctl.h>



#include <memory>

#include <mutex>

#include <string>

#include <vector>
@@ -101,9 +102,7 @@ class LayerLibrary { 
    bool EnumerateLayers(size_t library_idx,

                         std::vector<Layer>& instance_layers) const;



    void* GetGPA(const Layer& layer,

                 const char* gpa_name,

                 size_t gpa_name_len) const;

    void* GetGPA(const Layer& layer, const std::string_view gpa_name) const;



    const std::string GetFilename() { return filename_; }
@@ -226,17 +225,10 @@ bool LayerLibrary::EnumerateLayers(size_t library_idx, 
    }



    // get layer properties

    VkLayerProperties* properties = static_cast<VkLayerProperties*>(alloca(

        (num_instance_layers + num_device_layers) * sizeof(VkLayerProperties)));

    result = enumerate_instance_layers(&num_instance_layers, properties);

    if (result != VK_SUCCESS) {

        ALOGE("vkEnumerateInstanceLayerProperties failed for library '%s': %d",

              path_.c_str(), result);

        return false;

    }

    auto properties = std::make_unique<VkLayerProperties[]>(num_instance_layers + num_device_layers);

    if (num_device_layers > 0) {

        result = enumerate_device_layers(VK_NULL_HANDLE, &num_device_layers,

                                         properties + num_instance_layers);

                                         properties.get() + num_instance_layers);

        if (result != VK_SUCCESS) {

            ALOGE(

                "vkEnumerateDeviceLayerProperties failed for library '%s': %d",
@@ -321,21 +313,11 @@ bool LayerLibrary::EnumerateLayers(size_t library_idx, 
    return true;

}



void* LayerLibrary::GetGPA(const Layer& layer,

                           const char* gpa_name,

                           size_t gpa_name_len) const {

    void* gpa;

    size_t layer_name_len =

        std::max(size_t{2}, strlen(layer.properties.layerName));

    char* name = static_cast<char*>(alloca(layer_name_len + gpa_name_len + 1));

    strcpy(name, layer.properties.layerName);

    strcpy(name + layer_name_len, gpa_name);

    if (!(gpa = GetTrampoline(name))) {

        strcpy(name, "vk");

        strcpy(name + 2, gpa_name);

        gpa = GetTrampoline(name);

    }

void* LayerLibrary::GetGPA(const Layer& layer, const std::string_view gpa_name) const {

    std::string layer_name { layer.properties.layerName };

    if (void* gpa = GetTrampoline((layer_name.append(gpa_name).c_str())))

        return gpa;

    return GetTrampoline((std::string {"vk"}.append(gpa_name)).c_str());

}



// ----------------------------------------------------------------------------
@@ -470,10 +452,9 @@ const VkExtensionProperties* FindExtension( 
}



void* GetLayerGetProcAddr(const Layer& layer,

                          const char* gpa_name,

                          size_t gpa_name_len) {

                          const std::string_view gpa_name) {

    const LayerLibrary& library = g_layer_libraries[layer.library_idx];

    return library.GetGPA(layer, gpa_name, gpa_name_len);

    return library.GetGPA(layer, gpa_name);

}



}  // anonymous namespace
@@ -556,13 +537,13 @@ LayerRef::LayerRef(LayerRef&& other) noexcept : layer_(other.layer_) { 


PFN_vkGetInstanceProcAddr LayerRef::GetGetInstanceProcAddr() const {

    return layer_ ? reinterpret_cast<PFN_vkGetInstanceProcAddr>(

                        GetLayerGetProcAddr(*layer_, "GetInstanceProcAddr", 19))

                        GetLayerGetProcAddr(*layer_, "GetInstanceProcAddr"))

                  : nullptr;

}



PFN_vkGetDeviceProcAddr LayerRef::GetGetDeviceProcAddr() const {

    return layer_ ? reinterpret_cast<PFN_vkGetDeviceProcAddr>(

                        GetLayerGetProcAddr(*layer_, "GetDeviceProcAddr", 17))

                        GetLayerGetProcAddr(*layer_, "GetDeviceProcAddr"))

                  : nullptr;

}