vendor/processor-trace/892e12c5a27bda5806d1e63269986bb4171b5a8b

5 files changed, 698 insertions, 0 deletions

diff --git a/include/posix/threads.h b/include/posix/threads.h
new file mode 100644
index 0000000000000..758865c5815c9
--- /dev/null
+++ b/include/posix/threads.h
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) 2014-2019, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * It looks like there is still no support for C11's threads.h.
+ *
+ * We implement the few features we actually need hoping that this file will
+ * soon go away.
+ */
+
+#ifndef THREADS_H
+#define THREADS_H
+
+#include <pthread.h>
+
+#ifndef PTHREAD_MUTEX_NORMAL
+#  define PTHREAD_MUTEX_NORMAL PTHREAD_MUTEX_TIMED_NP
+#endif
+
+#include <stdint.h>
+#include <stdlib.h>
+
+enum {
+	thrd_success	= 1,
+	thrd_error
+};
+
+struct pt_thread {
+	pthread_t thread;
+};
+typedef struct pt_thread thrd_t;
+
+typedef int (*thrd_start_t)(void *);
+
+
+struct thrd_args {
+	thrd_start_t fun;
+	void *arg;
+};
+
+static void *thrd_routine(void *arg)
+{
+	struct thrd_args *args;
+	int result;
+
+	args = arg;
+	if (!args)
+		return (void *) (intptr_t) -1;
+
+	result = -1;
+	if (args->fun)
+		result = args->fun(args->arg);
+
+	free(args);
+
+	return (void *) (intptr_t) result;
+}
+
+static inline int thrd_create(thrd_t *thrd, thrd_start_t fun, void *arg)
+{
+	struct thrd_args *args;
+	int errcode;
+
+	if (!thrd || !fun)
+		return thrd_error;
+
+	args = malloc(sizeof(*args));
+	if (!args)
+		return thrd_error;
+
+	args->fun = fun;
+	args->arg = arg;
+
+	errcode = pthread_create(&thrd->thread, NULL, thrd_routine, args);
+	if (errcode) {
+		free(args);
+		return thrd_error;
+	}
+
+	return thrd_success;
+}
+
+static inline int thrd_join(thrd_t *thrd, int *res)
+{
+	void *result;
+	int errcode;
+
+	if (!thrd)
+		return thrd_error;
+
+	errcode = pthread_join(thrd->thread, &result);
+	if (errcode)
+		return thrd_error;
+
+	if (res)
+		*res = (int) (intptr_t) result;
+
+	return thrd_success;
+}
+
+
+struct pt_mutex {
+	pthread_mutex_t mutex;
+};
+typedef struct pt_mutex mtx_t;
+
+enum {
+	mtx_plain = PTHREAD_MUTEX_NORMAL
+};
+
+static inline int mtx_init(mtx_t *mtx, int type)
+{
+	int errcode;
+
+	if (!mtx || type != mtx_plain)
+		return thrd_error;
+
+	errcode = pthread_mutex_init(&mtx->mutex, NULL);
+	if (errcode)
+		return thrd_error;
+
+	return thrd_success;
+}
+
+static inline void mtx_destroy(mtx_t *mtx)
+{
+	if (mtx)
+		(void) pthread_mutex_destroy(&mtx->mutex);
+}
+
+static inline int mtx_lock(mtx_t *mtx)
+{
+	int errcode;
+
+	if (!mtx)
+		return thrd_error;
+
+	errcode = pthread_mutex_lock(&mtx->mutex);
+	if (errcode)
+		return thrd_error;
+
+	return thrd_success;
+}
+
+static inline int mtx_unlock(mtx_t *mtx)
+{
+	int errcode;
+
+	if (!mtx)
+		return thrd_error;
+
+	errcode = pthread_mutex_unlock(&mtx->mutex);
+	if (errcode)
+		return thrd_error;
+
+	return thrd_success;
+}
+
+
+struct pt_cond {
+	pthread_cond_t cond;
+};
+typedef struct pt_cond cnd_t;
+
+static inline int cnd_init(cnd_t *cnd)
+{
+	int errcode;
+
+	if (!cnd)
+		return thrd_error;
+
+	errcode = pthread_cond_init(&cnd->cond, NULL);
+	if (errcode)
+		return thrd_error;
+
+	return thrd_success;
+}
+
+static inline int cnd_destroy(cnd_t *cnd)
+{
+	int errcode;
+
+	if (!cnd)
+		return thrd_error;
+
+	errcode = pthread_cond_destroy(&cnd->cond);
+	if (errcode)
+		return thrd_error;
+
+	return thrd_success;
+}
+
+static inline int cnd_signal(cnd_t *cnd)
+{
+	int errcode;
+
+	if (!cnd)
+		return thrd_error;
+
+	errcode = pthread_cond_signal(&cnd->cond);
+	if (errcode)
+		return thrd_error;
+
+	return thrd_success;
+}
+
+static inline int cnd_broadcast(cnd_t *cnd)
+{
+	int errcode;
+
+	if (!cnd)
+		return thrd_error;
+
+	errcode = pthread_cond_broadcast(&cnd->cond);
+	if (errcode)
+		return thrd_error;
+
+	return thrd_success;
+}
+
+static inline int cnd_wait(cnd_t *cnd, mtx_t *mtx)
+{
+	int errcode;
+
+	if (!cnd || !mtx)
+		return thrd_error;
+
+	errcode = pthread_cond_wait(&cnd->cond, &mtx->mutex);
+	if (errcode)
+		return thrd_error;
+
+	return thrd_success;
+}
+
+#endif /* THREADS_H */
diff --git a/include/pt_compiler.h b/include/pt_compiler.h
new file mode 100644
index 0000000000000..67cf40c517244
--- /dev/null
+++ b/include/pt_compiler.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2017-2019, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef PT_COMPILER_H
+#define PT_COMPILER_H
+
+
+/* Both the relevant Clang and GCC versions support this. */
+#if !defined(__has_attribute)
+#  define __has_attribute(attr) 0
+#endif
+
+#if !defined(fallthrough)
+#  if (__has_attribute(fallthrough))
+#    define fallthrough __attribute__((fallthrough))
+#  else
+#    define fallthrough /* Fall through. */
+#  endif
+#endif /* !defined(fallthrough) */
+
+
+#endif /* PT_COMPILER_H */
diff --git a/include/pt_version.h b/include/pt_version.h
new file mode 100644
index 0000000000000..be6beb751177f
--- /dev/null
+++ b/include/pt_version.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2018-2019, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef PT_VERSION_H
+#define PT_VERSION_H
+
+#include "intel-pt.h"
+
+#include <stdio.h>
+#include <inttypes.h>
+
+
+static inline int pt_fprint_version(FILE *file, struct pt_version version)
+{
+	if (version.build) {
+		if (version.ext && version.ext[0])
+			return fprintf(file, "%" PRIu8 ".%" PRIu8 ".%" PRIu16
+				       "-%" PRIu32 "-%s", version.major,
+				       version.minor, version.patch,
+				       version.build, version.ext);
+		else
+			return fprintf(file, "%" PRIu8 ".%" PRIu8 ".%" PRIu16
+				       "-%" PRIu32 "", version.major,
+				       version.minor, version.patch,
+				       version.build);
+	} else {
+		if (version.ext && version.ext[0])
+			return fprintf(file, "%" PRIu8 ".%" PRIu8 ".%" PRIu16
+				       "-%s", version.major, version.minor,
+				       version.patch, version.ext);
+		else
+			return fprintf(file, "%" PRIu8 ".%" PRIu8 ".%" PRIu16,
+				       version.major, version.minor,
+				       version.patch);
+	}
+}
+
+static inline int pt_print_version(struct pt_version version)
+{
+	return pt_fprint_version(stdout, version);
+}
+
+static inline void pt_print_tool_version(const char *name)
+{
+	struct pt_version v = {
+		/* .major = */ PT_VERSION_MAJOR,
+		/* .minor = */ PT_VERSION_MINOR,
+		/* .patch = */ PT_VERSION_PATCH,
+		/* .build = */ PT_VERSION_BUILD,
+		/* .ext = */ PT_VERSION_EXT
+	};
+
+	if (!name)
+		name = "<unknown>";
+
+	printf("%s-", name);
+	pt_print_version(v);
+	printf(" / libipt-");
+	pt_print_version(pt_library_version());
+	printf("\n");
+}
+
+#endif /* PT_VERSION_H */
diff --git a/include/windows/inttypes.h b/include/windows/inttypes.h
new file mode 100644
index 0000000000000..20777ae21702e
--- /dev/null
+++ b/include/windows/inttypes.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2013-2019, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifndef PRId64
+#  define PRId64 "lld"
+#endif
+#ifndef PRIu64
+#  define PRIu64 "llu"
+#endif
+#ifndef PRIx64
+#  define PRIx64 "llx"
+#endif
+
+#ifndef PRId32
+#  define PRId32 "d"
+#endif
+#ifndef PRIu32
+#  define PRIu32 "u"
+#endif
+#ifndef PRIx32
+#  define PRIx32 "x"
+#endif
+
+#ifndef PRIu16
+#  define PRIu16 "u"
+#endif
+
+#ifndef PRIu8
+#  define PRIu8 "u"
+#endif
+#ifndef PRIx8
+#  define PRIx8 "x"
+#endif
+
+#ifndef SCNx64
+#  define SCNx64 "llx"
+#endif
diff --git a/include/windows/threads.h b/include/windows/threads.h
new file mode 100644
index 0000000000000..9d74ca714b310
--- /dev/null
+++ b/include/windows/threads.h
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2014-2019, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * It looks like there is still no support for C11's threads.h.
+ *
+ * We implement the few features we actually need hoping that this file will
+ * soon go away.
+ */
+
+#ifndef THREADS_H
+#define THREADS_H
+
+#include "windows.h"
+
+
+enum {
+	thrd_success	= 1,
+	thrd_error
+};
+
+
+struct pt_thread {
+	HANDLE handle;
+};
+typedef struct pt_thread thrd_t;
+
+typedef int (*thrd_start_t)(void *);
+
+
+struct thrd_args {
+	thrd_start_t fun;
+	void *arg;
+};
+
+static DWORD WINAPI thrd_routine(void *arg)
+{
+	struct thrd_args *args;
+	int result;
+
+	args = (struct thrd_args *) arg;
+	if (!args)
+		return (DWORD) -1;
+
+	result = -1;
+	if (args->fun)
+		result = args->fun(args->arg);
+
+	free(args);
+
+	return (DWORD) result;
+}
+
+static inline int thrd_create(thrd_t *thrd, thrd_start_t fun, void *arg)
+{
+	struct thrd_args *args;
+	HANDLE handle;
+
+	if (!thrd || !fun)
+		return thrd_error;
+
+	args = malloc(sizeof(*args));
+	if (!args)
+		return thrd_error;
+
+	args->fun = fun;
+	args->arg = arg;
+
+	handle = CreateThread(NULL, 0, thrd_routine, args, 0, NULL);
+	if (!handle) {
+		free(args);
+		return thrd_error;
+	}
+
+	thrd->handle = handle;
+	return thrd_success;
+}
+
+static inline int thrd_join(thrd_t *thrd, int *res)
+{
+	DWORD status;
+	BOOL success;
+
+	if (!thrd)
+		return thrd_error;
+
+	status = WaitForSingleObject(thrd->handle, INFINITE);
+	if (status)
+		return thrd_error;
+
+	if (res) {
+		DWORD result;
+
+		success = GetExitCodeThread(thrd->handle, &result);
+		if (!success) {
+			(void) CloseHandle(thrd->handle);
+			return thrd_error;
+		}
+
+		*res = (int) result;
+	}
+
+	success = CloseHandle(thrd->handle);
+	if (!success)
+		return thrd_error;
+
+	return thrd_success;
+}
+
+struct pt_mutex {
+	CRITICAL_SECTION cs;
+};
+typedef struct pt_mutex mtx_t;
+
+enum {
+	mtx_plain
+};
+
+static inline int mtx_init(mtx_t *mtx, int type)
+{
+	if (!mtx || type != mtx_plain)
+		return thrd_error;
+
+	InitializeCriticalSection(&mtx->cs);
+
+	return thrd_success;
+}
+
+static inline void mtx_destroy(mtx_t *mtx)
+{
+	if (mtx)
+		DeleteCriticalSection(&mtx->cs);
+}
+
+static inline int mtx_lock(mtx_t *mtx)
+{
+	if (!mtx)
+		return thrd_error;
+
+	EnterCriticalSection(&mtx->cs);
+
+	return thrd_success;
+}
+
+static inline int mtx_unlock(mtx_t *mtx)
+{
+	if (!mtx)
+		return thrd_error;
+
+	LeaveCriticalSection(&mtx->cs);
+
+	return thrd_success;
+}
+
+
+struct pt_cond {
+	CONDITION_VARIABLE cond;
+};
+typedef struct pt_cond cnd_t;
+
+static inline int cnd_init(cnd_t *cnd)
+{
+	if (!cnd)
+		return thrd_error;
+
+	InitializeConditionVariable(&cnd->cond);
+
+	return thrd_success;
+}
+
+static inline int cnd_destroy(cnd_t *cnd)
+{
+	if (!cnd)
+		return thrd_error;
+
+	/* Nothing to do. */
+
+	return thrd_success;
+}
+
+static inline int cnd_signal(cnd_t *cnd)
+{
+	if (!cnd)
+		return thrd_error;
+
+	WakeConditionVariable(&cnd->cond);
+
+	return thrd_success;
+}
+
+static inline int cnd_broadcast(cnd_t *cnd)
+{
+	if (!cnd)
+		return thrd_error;
+
+	WakeAllConditionVariable(&cnd->cond);
+
+	return thrd_success;
+}
+
+static inline int cnd_wait(cnd_t *cnd, mtx_t *mtx)
+{
+	BOOL success;
+
+	if (!cnd || !mtx)
+		return thrd_error;
+
+	success = SleepConditionVariableCS(&cnd->cond, &mtx->cs, INFINITE);
+	if (!success)
+		return thrd_error;
+
+	return thrd_success;
+}
+
+#endif /* THREADS_H */