Function translate_function_info

compute/universal_binary.cpp:1540–1597

	}
	
	vector<llvm_toolchain::function_info> translate_function_info(const vector<function_info_dynamic_v2>& functions) {
		vector<llvm_toolchain::function_info> ret;
		
		for (const auto& func : functions) {
			llvm_toolchain::function_info entry {
				.name = func.name,
				.type = func.static_function_info.type,
				.flags = func.static_function_info.flags,
			};
			
			uint32_t arg_idx = 0u;
			if (entry.type != llvm_toolchain::FUNCTION_TYPE::ARGUMENT_BUFFER_STRUCT) {
				entry.required_local_size = func.static_function_info.details.local_size;
			} else {
				arg_idx = func.static_function_info.details.argument_buffer_index;
			}
			
			for (const auto& arg : func.args) {
				entry.args.emplace_back(llvm_toolchain::arg_info {
					.size = arg.argument_size,
					.address_space = arg.address_space,
					.image_type = arg.image_type,
					.image_access = arg.image_access,
					.special_type = arg.special_type,
				});
			}
			
			if (entry.type != llvm_toolchain::FUNCTION_TYPE::ARGUMENT_BUFFER_STRUCT) {
				ret.emplace_back(entry);
			} else {
				bool found_func = false;
				for (auto riter = ret.rbegin(); riter != ret.rend(); ++riter) {
					if (riter->name == entry.name) {
						found_func = true;
						if (arg_idx >= (uint32_t)riter->args.size()) {
							log_error("argument index $ is out-of-bounds for function $ with $ args", arg_idx, entry.name, riter->args.size());
							return {};
						}
						
						auto& arg = riter->args[arg_idx];
						if (arg.special_type != llvm_toolchain::SPECIAL_TYPE::ARGUMENT_BUFFER) {
							log_error("argument index $ in function $ is not an argument buffer", arg_idx, entry.name);
							return {};
						}
						
						arg.argument_buffer_info = std::move(entry);
						break;
					}
				}
				if (!found_func) {
					log_error("didn't find function $ for argument buffer", entry.name);
					return {};
				}
			}
		}
		
		return ret;
	}