Merge "[frameworks][native][vulkan] fix -Walloca" (64d53671) · Commits · e / os / android_frameworks_native-old

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;
		}