haiku.git

/*
 * Copyright 2013, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <architecture_private.h>

#include <stdio.h>
#include <string.h>
#include <sys/stat.h>

#include <OS.h>

#include <directories.h>
#include <find_directory_private.h>
#include <runtime_loader.h>


static const char* const kArchitecture = B_HAIKU_ABI_NAME;
static const char* const kPrimaryArchitecture = __HAIKU_PRIMARY_PACKAGING_ARCH;

#ifdef __HAIKU_ARCH_X86
	static const char* const kSiblingArchitectures[] = {"x86_gcc2", "x86"};
#else
	static const char* const kSiblingArchitectures[] = {};
#endif

static const size_t kSiblingArchitectureCount
	= sizeof(kSiblingArchitectures) / sizeof(const char*);


static bool
has_secondary_architecture(const char* architecture)
{
	if (strcmp(architecture, kPrimaryArchitecture) == 0)
		return false;

	char path[B_PATH_NAME_LENGTH];
	snprintf(path, sizeof(path), kSystemLibDirectory "/%s/libroot.so",
		architecture);

	struct stat st;
	return lstat(path, &st) == 0;
}


// #pragma mark -


const char*
__get_architecture()
{
	return kArchitecture;
}


const char*
__get_primary_architecture()
{
	return kPrimaryArchitecture;
}


size_t
__get_secondary_architectures(const char** architectures, size_t count)
{
	size_t index = 0;

	// If this is an architecture that could be a primary or secondary
	// architecture, check for which architectures a libroot.so is present.
	if (kSiblingArchitectureCount > 0) {
		for (size_t i = 0; i < kSiblingArchitectureCount; i++) {
			const char* architecture = kSiblingArchitectures[i];
			if (!has_secondary_architecture(architecture))
				continue;

			if (index < count)
				architectures[index] = architecture;
			index++;
		}
	}

	return index;
}


size_t
__get_architectures(const char** architectures, size_t count)
{
	if (count == 0)
		return __get_secondary_architectures(NULL, 0) + 1;

	architectures[0] = __get_primary_architecture();
	return __get_secondary_architectures(architectures + 1, count -1) + 1;
}


const char*
__guess_architecture_for_path(const char* path)
{
	if (kSiblingArchitectureCount == 0)
		return kPrimaryArchitecture;

	// ask the runtime loader
	const char* architecture;
	if (__gRuntimeLoader->get_executable_architecture(path, &architecture)
			== B_OK) {
		// verify that it is one of the sibling architectures
		for (size_t i = 0; i < kSiblingArchitectureCount; i++) {
			if (strcmp(architecture, kSiblingArchitectures[i]) == 0)
				return kSiblingArchitectures[i];
		}
	}

	// guess from the given path
	architecture = __guess_secondary_architecture_from_path(path,
		kSiblingArchitectures, kSiblingArchitectureCount);

	return architecture != NULL && has_secondary_architecture(architecture)
		? architecture : kPrimaryArchitecture;
}


B_DEFINE_WEAK_ALIAS(__get_architecture, get_architecture);
B_DEFINE_WEAK_ALIAS(__get_primary_architecture, get_primary_architecture);
B_DEFINE_WEAK_ALIAS(__get_secondary_architectures, get_secondary_architectures);
B_DEFINE_WEAK_ALIAS(__get_architectures, get_architectures);
B_DEFINE_WEAK_ALIAS(__guess_architecture_for_path, guess_architecture_for_path);