Function load_archive

compute/universal_binary.cpp:43–251

	static constexpr const uint32_t min_required_toolchain_version_v2 { 140000u };
	
	unique_ptr<archive> load_archive(const string& file_name) {
		string data;
		if (!file_io::file_to_string(file_name, data)) {
			return {};
		}
		const auto data_size = data.size();
		auto cur_size = (decltype(data_size))0;
		const uint8_t* data_ptr = (const uint8_t*)data.data();
		
		auto ar = make_unique<archive>();
		
		// parse header
		cur_size += sizeof(header_v2);
		if (cur_size > data_size) {
			log_error("universal binary $: invalid header size, expected $, got $",
					  file_name, cur_size, data_size);
			return {};
		}
		const header_v2& header = *(const header_v2*)data_ptr;
		data_ptr += sizeof(header_v2);
		
		if (memcmp(header.magic, "FUBA", 4) != 0) {
			log_error("universal binary $: invalid header magic", file_name);
			return {};
		}
		if (header.binary_format_version != binary_format_version) {
			log_error("universal binary $: unsupported binary version $", file_name, header.binary_format_version);
			return {};
		}
		memcpy(&ar->header.static_header, &header, sizeof(header_v2));
		
		const auto& bin_count = ar->header.static_header.binary_count;
		if (bin_count == 0) {
			// no binaries -> return early
			return ar;
		}
		
		// parse dynamic header
		ar->header.targets.resize(bin_count);
		ar->header.offsets.resize(bin_count);
		ar->header.toolchain_versions.resize(bin_count);
		ar->header.hashes.resize(bin_count);
		
		const auto targets_size = sizeof(target_v2) * bin_count;
		const auto offsets_size = sizeof(typename decltype(header_dynamic_v2::offsets)::value_type) * bin_count;
		const auto toolchain_versions_size = sizeof(typename decltype(header_dynamic_v2::toolchain_versions)::value_type) * bin_count;
		const auto hashes_size = sizeof(typename decltype(header_dynamic_v2::hashes)::value_type) * bin_count;
		const auto dyn_header_size = targets_size + offsets_size + toolchain_versions_size + hashes_size;
		cur_size += dyn_header_size;
		if (cur_size > data_size) {
			log_error("universal binary $: invalid dynamic header size, expected $, got $",
					  file_name, cur_size, data_size);
			return {};
		}
		
		memcpy(ar->header.targets.data(), data_ptr, targets_size);
		data_ptr += targets_size;