README.md                                    |   26 
 configure.ac                                 |   35 
 include/EGL/egl.h                            |  303 +++
 include/EGL/eglext.h                         |  913 ++++++++++
 include/EGL/eglplatform.h                    |  125 +
 include/KHR/khrplatform.h                    |  282 +++
 include/Makefile.am                          |    3 
 include/glvnd/GLdispatchABI.h                |    7 
 include/glvnd/libeglabi.h                    |  436 ++++
 libglvnd.pc.in                               |    2 
 src/EGL/Makefile.am                          |  105 +
 src/EGL/egldispatchstubs.c                   |  113 +
 src/EGL/egldispatchstubs.h                   |   27 
 src/EGL/libegl.c                             | 1221 +++++++++++++
 src/EGL/libeglabipriv.h                      |  105 +
 src/EGL/libeglcurrent.c                      |  201 ++
 src/EGL/libeglcurrent.h                      |  126 +
 src/EGL/libeglerror.c                        |  257 ++
 src/EGL/libeglerror.h                        |   78 
 src/EGL/libeglmapping.c                      |  366 ++++
 src/EGL/libeglmapping.h                      |  128 +
 src/EGL/libeglvendor.c                       |  525 +++++
 src/EGL/libeglvendor.h                       |   50 
 src/GLX/Makefile.am                          |    2 
 src/GLX/libglx.c                             |  125 -
 src/GLX/libglxmapping.c                      |   29 
 src/GLX/libglxstring.c                       |   63 
 src/GLX/libglxstring.h                       |   44 
 src/GLdispatch/GLdispatch.c                  |   43 
 src/GLdispatch/GLdispatch.h                  |    9 
 src/GLdispatch/export_list.sym               |    1 
 src/GLdispatch/vnd-glapi/entry_aarch64_tsd.c |  207 ++
 src/GLdispatch/vnd-glapi/entry_armv7_tsd.c   |   47 
 src/GLdispatch/vnd-glapi/entry_files.mk      |    5 
 src/Makefile.am                              |    1 
 src/generate/eglFunctionList.py              |  148 +
 src/generate/genCommon.py                    |    2 
 src/generate/gen_egl_dispatch.py             |  223 ++
 src/generate/gen_gldispatch_mapi.py          |    6 
 src/generate/gl_inittable.py                 |    2 
 src/generate/xml/egl.xml                     | 2412 +++++++++++++++++++++++++++
 src/util/Makefile.am                         |    8 
 src/util/cJSON.c                             |  750 ++++++++
 src/util/cJSON.h                             |  149 +
 src/util/cJSON/LICENSE                       |   20 
 src/util/cJSON/README                        |  247 ++
 src/util/cJSON/test.c                        |  162 +
 src/util/cJSON/tests/test1                   |   22 
 src/util/cJSON/tests/test2                   |   11 
 src/util/cJSON/tests/test3                   |   26 
 src/util/cJSON/tests/test4                   |   88 
 src/util/cJSON/tests/test5                   |   27 
 src/util/glvnd_genentry.c                    |   44 
 src/util/glvnd_pthread.c                     |   47 
 src/util/glvnd_pthread.h                     |    3 
 src/util/utils_misc.c                        |  169 +
 src/util/utils_misc.h                        |   89 
 tests/GLX_dummy/GLX_dummy.c                  |  827 ---------
 tests/GLX_dummy/GLX_dummy.h                  |   84 
 tests/GLX_dummy/Makefile.am                  |   34 
 tests/GLX_dummy/README                       |    3 
 tests/Makefile.am                            |  101 -
 tests/dummy/EGL_dummy.c                      |  811 +++++++++
 tests/dummy/EGL_dummy.h                      |  118 +
 tests/dummy/GLX_dummy.c                      |  677 +++++++
 tests/dummy/GLX_dummy.h                      |   84 
 tests/dummy/Makefile.am                      |   58 
 tests/dummy/README                           |    3 
 tests/dummy/patchentrypoints.c               |  210 ++
 tests/dummy/patchentrypoints.h               |   47 
 tests/egl_test_utils.c                       |   48 
 tests/egl_test_utils.h                       |   71 
 tests/eglenv.sh                              |    4 
 tests/fini_test_env.sh                       |   16 
 tests/glxenv.sh                              |    4 
 tests/init_test_env.sh                       |   20 
 tests/json/10_egldummy0.json                 |    6 
 tests/json/20_egldummy1.json                 |    6 
 tests/testegldebug.c                         |  276 +++
 tests/testegldebug.sh                        |    5 
 tests/testegldevice.c                        |  139 +
 tests/testegldevice.sh                       |    5 
 tests/testegldisplay.c                       |  128 +
 tests/testegldisplay.sh                      |    5 
 tests/testeglerror.c                         |  109 +
 tests/testeglerror.sh                        |    5 
 tests/testeglgetprocaddress.c                |  140 +
 tests/testeglgetprocaddress.sh               |    5 
 tests/testeglmakecurrent.c                   |  241 ++
 tests/testeglmakecurrent.sh                  |    5 
 tests/testglxgetclientstr.sh                 |    3 
 tests/testglxgetprocaddress.c                |   90 -
 tests/testglxgetprocaddress.sh               |    3 
 tests/testglxgetprocaddress_genentry.sh      |   11 
 tests/testglxmakecurrent.c                   |    2 
 tests/testglxmcbasic.sh                      |    3 
 tests/testglxmclate.sh                       |    4 
 tests/testglxmcloop.sh                       |    3 
 tests/testglxmcoldlink.sh                    |    3 
 tests/testglxmcthreads.sh                    |    3 
 tests/testglxnscreens.c                      |  308 ---
 tests/testglxnscreens.sh                     |   10 
 tests/testglxnscrthreads.sh                  |   13 
 tests/testglxqueryversion.c                  |    9 
 tests/testglxqueryversion.sh                 |    3 
 tests/testpatchentrypoints.c                 |   15 
 tests/testpatchentrypoints.sh                |    3 
 tests/testpatchentrypoints_gldispatch.c      |  185 ++
 tests/testpatchentrypoints_gldispatch.sh     |    4 
 tests/testx11glvndproto.c                    |   86 
 tests/testx11glvndproto.sh                   |    7 
 tests/xorg.2screens.conf                     |  115 -
 tests/xorg.conf                              |   60 
 113 files changed, 13974 insertions(+), 1929 deletions(-)

New commits:
commit 522c6017999b87f1662a669b487078c83504f946
Author: Kyle Brenneman <kbrenne...@nvidia.com>
Date:   Thu May 26 11:52:37 2016 -0600

    Add support for aarch64.
    
    Add assembly code and stub generation for TSD stubs on aarch64.

diff --git a/configure.ac b/configure.ac
index 7227f5a..73cafe8 100644
--- a/configure.ac
+++ b/configure.ac
@@ -70,6 +70,9 @@ if test "x$enable_asm" = xyes; then
     armv7l)
         asm_arch=armv7l
         ;;
+    aarch64)
+        asm_arch=aarch64
+        ;;
     esac
 
     case "$asm_arch" in
@@ -85,6 +88,10 @@ if test "x$enable_asm" = xyes; then
         DEFINES="$DEFINES -DUSE_ARMV7_ASM"
         AC_MSG_RESULT([yes, armv7l])
         ;;
+    aarch64)
+        DEFINES="$DEFINES -DUSE_AARCH64_ASM"
+        AC_MSG_RESULT([yes, aarch64])
+        ;;
     *)
         AC_MSG_RESULT([no, platform not supported])
         ;;
@@ -153,6 +160,11 @@ xarmv7l)
     gldispatch_entry_type=armv7_tsd
     gldispatch_use_tls=no
     ;;
+xaarch64)
+    # For aarch64, only the TSD stubs have been implemented yet.
+    gldispatch_entry_type=aarch64_tsd
+    gldispatch_use_tls=no
+    ;;
 *)
     # The C stubs will work with either TLS or TSD.
     gldispatch_entry_type=pure_c
@@ -170,6 +182,7 @@ AM_CONDITIONAL([GLDISPATCH_TYPE_X86_TSD], [test 
"x$gldispatch_entry_type" = "xx8
 AM_CONDITIONAL([GLDISPATCH_TYPE_X86_64_TLS], [test "x$gldispatch_entry_type" = 
"xx86_64_tls"])
 AM_CONDITIONAL([GLDISPATCH_TYPE_X86_64_TSD], [test "x$gldispatch_entry_type" = 
"xx86_64_tsd"])
 AM_CONDITIONAL([GLDISPATCH_TYPE_ARMV7_TSD], [test "x$gldispatch_entry_type" = 
"xarmv7_tsd"])
+AM_CONDITIONAL([GLDISPATCH_TYPE_AARCH64_TSD], [test "x$gldispatch_entry_type" 
= "xaarch64_tsd"])
 AM_CONDITIONAL([GLDISPATCH_TYPE_PURE_C], [test "x$gldispatch_entry_type" = 
"xpure_c"])
 
 
diff --git a/include/glvnd/GLdispatchABI.h b/include/glvnd/GLdispatchABI.h
index 25d593a..9b4c43d 100644
--- a/include/glvnd/GLdispatchABI.h
+++ b/include/glvnd/GLdispatchABI.h
@@ -82,7 +82,12 @@ enum {
     /*!
      * Used for stubs on ARMv7, using the normal ARM instruction set.
      */
-    __GLDISPATCH_STUB_ARMV7_ARM
+    __GLDISPATCH_STUB_ARMV7_ARM,
+
+    /*!
+     * Used for stubs on ARMv8/aarch64.
+     */
+    __GLDISPATCH_STUB_AARCH64,
 };
 
 /*!
diff --git a/src/GLdispatch/vnd-glapi/entry_aarch64_tsd.c 
b/src/GLdispatch/vnd-glapi/entry_aarch64_tsd.c
new file mode 100644
index 0000000..7fbcb39
--- /dev/null
+++ b/src/GLdispatch/vnd-glapi/entry_aarch64_tsd.c
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) 2016, NVIDIA CORPORATION.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * unaltered in all copies or substantial portions of the Materials.
+ * Any additions, deletions, or changes to the original source files
+ * must be clearly indicated in accompanying documentation.
+ *
+ * If only executable code is distributed, then the accompanying
+ * documentation must state that "this software is based in part on the
+ * work of the Khronos Group."
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ */
+
+#include "entry.h"
+#include "entry_common.h"
+
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include "glapi.h"
+#include "u_macros.h"
+#include "u_current.h"
+#include "utils_misc.h"
+#include "glvnd/GLdispatchABI.h"
+
+/*
+ * See: https://sourceware.org/binutils/docs/as/ARM-Directives.html
+ */
+
+/*
+ * u_execmem_alloc() allocates 128 bytes per stub.
+ */
+#define AARCH64_ENTRY_SIZE 128
+
+#define STUB_ASM_ENTRY(func)                        \
+    ".balign " U_STRINGIFY(AARCH64_ENTRY_SIZE) "\n\t" \
+    ".global " func "\n\t"                          \
+    ".type " func ", %function\n\t"                 \
+    func ":\n\t"
+
+/*
+ * Looks up the current dispatch table, finds the stub address at the given 
slot
+ * then jumps to it.
+ *
+ * First tries to find a dispatch table in 
_glapi_Current[GLAPI_CURRENT_DISPATCH],
+ * if not found then it jumps to the 'lookup_dispatch' and calls
+ * _glapi_get_current() then jumps back to the 'found_dispatch' label.
+ *
+ * The 'found_dispatch' section computes the correct offset in the dispatch
+ * table then does a branch without link to the function address.
+ */
+#define STUB_ASM_CODE(slot)                           \
+    "stp x1, x0, [sp, #-16]!\n\t"                     \
+    "adrp x0, :got:_glapi_Current\n\t"                \
+    "ldr x0, [x0, #:got_lo12:_glapi_Current]\n\t"     \
+    "ldr x0, [x0]\n\t"                                \
+    "cbz x0, 10f\n\t"                                 \
+    "11:\n\t"        /* found dispatch */             \
+    "ldr x1, 3f\n\t"                                  \
+    "ldr x16, [x0, x1]\n\t"                           \
+    "ldp x1, x0, [sp], #16\n\t"                       \
+    "br x16\n\t"                                      \
+    "10:\n\t"        /* lookup dispatch */            \
+    "str x30, [sp, #-16]!\n\t"                        \
+    "stp x7, x6, [sp, #-16]!\n\t"                     \
+    "stp x5, x4, [sp, #-16]!\n\t"                     \
+    "stp x3, x2, [sp, #-16]!\n\t"                     \
+    "adrp x0, :got:_glapi_get_current\n\t"            \
+    "ldr x0, [x0, #:got_lo12:_glapi_get_current]\n\t" \
+    "blr x0\n\t"                                      \
+    "ldp x3, x2, [sp], #16\n\t"                       \
+    "ldp x5, x4, [sp], #16\n\t"                       \
+    "ldp x7, x6, [sp], #16\n\t"                       \
+    "ldr x30, [sp], #16\n\t"                          \
+    "b 11b\n\t"                                       \
+    "3:\n\t"                                          \
+    ".xword " slot " * 8\n\t" /* size of (void *) */
+
+/*
+ * Bytecode for STUB_ASM_CODE()
+ */
+static const uint32_t BYTECODE_TEMPLATE[] =
+{
+    0xa9bf03e1, // <ENTRY>:    stp     x1, x0, [sp,#-16]!
+    0x58000240, // <ENTRY+4>:  ldr     x0, <ENTRY+76>
+    0xf9400000, // <ENTRY+8>:  ldr     x0, [x0]
+    0xb40000a0, // <ENTRY+12>: cbz     x0, <ENTRY+32>
+    0x58000261, // <ENTRY+16>: ldr     x1, <ENTRY+92>
+    0xf8616810, // <ENTRY+20>: ldr     x16, [x0,x1]
+    0xa8c103e1, // <ENTRY+24>: ldp     x1, x0, [sp],#16
+    0xd61f0200, // <ENTRY+28>: br      x16
+    0xf81f0ffe, // <ENTRY+32>: str     x30, [sp,#-16]!
+    0xa9bf1be7, // <ENTRY+36>: stp     x7, x6, [sp,#-16]!
+    0xa9bf13e5, // <ENTRY+40>: stp     x5, x4, [sp,#-16]!
+    0xa9bf0be3, // <ENTRY+44>: stp     x3, x2, [sp,#-16]!
+    0x58000120, // <ENTRY+48>: ldr     x0, <ENTRY+84>
+    0xd63f0000, // <ENTRY+52>: blr     x0
+    0xa8c10be3, // <ENTRY+56>: ldp     x3, x2, [sp],#16
+    0xa8c113e5, // <ENTRY+60>: ldp     x5, x4, [sp],#16
+    0xa8c11be7, // <ENTRY+64>: ldp     x7, x6, [sp],#16
+    0xf84107fe, // <ENTRY+68>: ldr     x30, [sp],#16
+    0x17fffff2, // <ENTRY+72>: b       <ENTRY+16>
+
+    // Offsets that need to be patched
+    0x00000000, 0x00000000, // <ENTRY+76>: _glapi_Current
+    0x00000000, 0x00000000, // <ENTRY+84>: _glapi_get_current
+    0x00000000, 0x00000000, // <ENTRY+92>: slot * sizeof(void*)
+};
+
+#define AARCH64_BYTECODE_SIZE sizeof(BYTECODE_TEMPLATE)
+
+__asm__(".section wtext,\"ax\"\n"
+        ".balign 4096\n"
+       ".globl public_entry_start\n"
+       ".hidden public_entry_start\n"
+        "public_entry_start:\n");
+
+#define MAPI_TMP_STUB_ASM_GCC
+#include "mapi_tmp.h"
+
+__asm__(".balign 4096\n"
+       ".globl public_entry_end\n"
+       ".hidden public_entry_end\n"
+        "public_entry_end:\n"
+        ".text\n\t");
+
+const int entry_type = __GLDISPATCH_STUB_AARCH64;
+const int entry_stub_size = AARCH64_ENTRY_SIZE;
+
+// The offsets in BYTECODE_TEMPLATE that need to be patched.
+static const int TEMPLATE_OFFSET_CURRENT_TABLE     = AARCH64_BYTECODE_SIZE - 
3*8;
+static const int TEMPLATE_OFFSET_CURRENT_TABLE_GET = AARCH64_BYTECODE_SIZE - 
2*8;
+static const int TEMPLATE_OFFSET_SLOT              = AARCH64_BYTECODE_SIZE - 8;
+
+void
+entry_init_public(void)
+{
+    STATIC_ASSERT(AARCH64_BYTECODE_SIZE <= AARCH64_ENTRY_SIZE);
+}
+
+void entry_generate_default_code(char *entry, int slot)
+{
+    char *writeEntry;
+
+    // Get the pointer to the writable mapping.
+    writeEntry = (char *) u_execmem_get_writable(entry);
+
+    memcpy(writeEntry, BYTECODE_TEMPLATE, AARCH64_BYTECODE_SIZE);
+
+    // Patch the slot number and whatever addresses need to be patched.
+    *((uint64_t *)(writeEntry + TEMPLATE_OFFSET_SLOT)) = (uint64_t)(slot * 
sizeof(mapi_func));
+    *((uint64_t *)(writeEntry + TEMPLATE_OFFSET_CURRENT_TABLE)) =
+        (uint64_t)_glapi_Current;
+    *((uint64_t *)(writeEntry + TEMPLATE_OFFSET_CURRENT_TABLE_GET)) =
+        (uint64_t)_glapi_get_current;
+
+    // See 
http://community.arm.com/groups/processors/blog/2010/02/17/caches-and-self-modifying-code
+    __builtin___clear_cache(writeEntry, writeEntry + AARCH64_BYTECODE_SIZE);
+}
+
+// Note: The rest of these functions could also be used for aarch64 TLS stubs,
+// once those are implemented.
+
+mapi_func
+entry_get_public(int index)
+{
+    return (mapi_func)(public_entry_start + (index * entry_stub_size));
+}
+
+void entry_get_patch_addresses(mapi_func entry, void **writePtr, const void 
**execPtr)
+{
+    // Get the actual beginning of the stub allocation
+    *execPtr = (const void *) entry;
+    *writePtr = u_execmem_get_writable((void *) entry);
+}
+
+#if !defined(STATIC_DISPATCH_ONLY)
+mapi_func entry_generate(int slot)
+{
+    void *code = u_execmem_alloc(entry_stub_size);
+    if (!code) {
+        return NULL;
+    }
+
+    entry_generate_default_code(code, slot);
+
+    return (mapi_func) code;
+}
+#endif // !defined(STATIC_DISPATCH_ONLY)
diff --git a/src/GLdispatch/vnd-glapi/entry_files.mk 
b/src/GLdispatch/vnd-glapi/entry_files.mk
index 628c2cd..38b6bf3 100644
--- a/src/GLdispatch/vnd-glapi/entry_files.mk
+++ b/src/GLdispatch/vnd-glapi/entry_files.mk
@@ -30,6 +30,11 @@ MAPI_GLDISPATCH_ENTRY_FILES = entry_armv7_tsd.c
 MAPI_GLDISPATCH_ENTRY_FILES += entry_common.c
 endif
 
+if GLDISPATCH_TYPE_AARCH64_TSD
+MAPI_GLDISPATCH_ENTRY_FILES = entry_aarch64_tsd.c
+MAPI_GLDISPATCH_ENTRY_FILES += entry_common.c
+endif
+
 if GLDISPATCH_TYPE_PURE_C
 MAPI_GLDISPATCH_ENTRY_FILES = entry_pure_c.c
 endif
diff --git a/src/util/glvnd_genentry.c b/src/util/glvnd_genentry.c
index d0483ca..4763633 100644
--- a/src/util/glvnd_genentry.c
+++ b/src/util/glvnd_genentry.c
@@ -39,7 +39,8 @@
 
 #define USE_ASM (defined(USE_X86_ASM) ||    \
                  defined(USE_X86_64_ASM) || \
-                 defined(USE_ARMV7_ASM))
+                 defined(USE_ARMV7_ASM) ||  \
+                 defined(USE_AARCH64_ASM))
 
 #if defined(__GNUC__) && USE_ASM
 
@@ -47,7 +48,7 @@
 #define GENERATED_ENTRYPOINT_MAX 4096
 
 /// The size of each generated entrypoint.
-static const int STUB_ENTRY_SIZE = 16;
+static const int STUB_ENTRY_SIZE = 32;
 
 #if defined(USE_X86_ASM)
 /// A template used to generate an entrypoint.
@@ -87,6 +88,23 @@ static const uint16_t STUB_TEMPLATE[] =
 
 static const int DISPATCH_FUNC_OFFSET = 8;
 
+#elif defined(USE_AARCH64_ASM)
+
+static const uint32_t STUB_TEMPLATE[] =
+{
+    // ldr x16, 1f
+    0x58000070,
+    // br x16
+    0xd61f0200,
+    // nop
+    0xd503201f,
+    // Offset that needs to be patched
+    // 1:
+    0x00000000, 0x00000000,
+};
+
+static const int DISPATCH_FUNC_OFFSET = 12;
+
 #else
 #error "Can't happen -- not implemented"
 #endif
@@ -263,6 +281,12 @@ void SetDispatchFuncPointer(GLVNDGenEntrypoint *entry,
     // See 
http://community.arm.com/groups/processors/blog/2010/02/17/caches-and-self-modifying-code
     __builtin___clear_cache((char *)entry->entrypointExec - 1,
                             (char *)entry->entrypointExec - 1 + 
sizeof(STUB_TEMPLATE));
+#elif defined(USE_AARCH64_ASM)
+    *((uintptr_t *)(code + DISPATCH_FUNC_OFFSET)) = (uintptr_t)dispatch;
+
+    // See 
http://community.arm.com/groups/processors/blog/2010/02/17/caches-and-self-modifying-code
+    __builtin___clear_cache((char *)entry->entrypointExec - 1,
+                            (char *)entry->entrypointExec - 1 + 
sizeof(STUB_TEMPLATE));
 #else
 #error "Can't happen -- not implemented"
 #endif
diff --git a/tests/dummy/patchentrypoints.c b/tests/dummy/patchentrypoints.c
index a8cf348..a822cc7 100644
--- a/tests/dummy/patchentrypoints.c
+++ b/tests/dummy/patchentrypoints.c
@@ -128,12 +128,47 @@ static void patch_armv7_thumb(char *writeEntry, const 
char *execEntry,
 #endif
 }
 
+static void patch_aarch64(char *writeEntry, const char *execEntry,
+        int stubSize, void *incrementPtr)
+{
+#if defined(__aarch64__)
+    const uint32_t tmpl[] = {
+        // ldr x0, 1f
+        0x580000a0,
+        // ldr x1, [x0]
+        0xf9400001,
+        // add x1, x1, #1
+        0x91000421,
+        // str x1, [x0]
+        0xf9000001,
+        // br x30
+        0xd61f03c0,
+        // 1:
+        0x00000000, 0x00000000,
+    };
+
+    static const int offsetAddr = sizeof(tmpl) - 8;
+
+    if (stubSize < sizeof(tmpl)) {
+        return;
+    }
+
+    memcpy(writeEntry, tmpl, sizeof(tmpl));
+    *((uint64_t *)(writeEntry + offsetAddr)) = (uint64_t) incrementPtr;
+
+    __builtin___clear_cache((char *) execEntry, (char *) (execEntry + 
sizeof(tmpl)));
+#else
+    assert(0); // Should not be calling this
+#endif
+}
+
 GLboolean dummyCheckPatchSupported(int type, int stubSize)
 {
     switch (type) {
         case __GLDISPATCH_STUB_X86_64:
         case __GLDISPATCH_STUB_X86:
         case __GLDISPATCH_STUB_ARMV7_THUMB:
+        case __GLDISPATCH_STUB_AARCH64:
             return GL_TRUE;
         default:
             return GL_FALSE;
@@ -162,6 +197,9 @@ GLboolean commonInitiatePatch(int type, int stubSize,
             case __GLDISPATCH_STUB_ARMV7_THUMB:
                 patch_armv7_thumb(writeAddr, execAddr, stubSize, incrementPtr);
                 break;
+            case __GLDISPATCH_STUB_AARCH64:
+                patch_aarch64(writeAddr, execAddr, stubSize, incrementPtr);
+                break;
             default:
                 assert(0);
         }

commit 260a54606c584183052f2496fb4d5f6335e59d26
Author: Kyle Brenneman <kbrenne...@nvidia.com>
Date:   Wed Oct 26 13:59:10 2016 -0600

    tests: Add a test for EGL_KHR_debug.

diff --git a/tests/Makefile.am b/tests/Makefile.am
index 5a3bacc..29eab01 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -53,7 +53,8 @@ TESTS = \
        testegldevice.sh \
        testeglgetprocaddress.sh \
        testeglmakecurrent.sh \
-       testeglerror.sh
+       testeglerror.sh \
+       testegldebug.sh
 
 EXTRA_DIST = $(TESTS) \
        glxenv.sh \
@@ -72,7 +73,8 @@ check_PROGRAMS = \
        testegldevice \
        testeglgetprocaddress \
        testeglmakecurrent \
-       testeglerror
+       testeglerror \
+       testegldebug
 
 # The *_oldlink variant tests that linking against legacy libGL.so works
 
@@ -163,3 +165,8 @@ testeglerror_SOURCES = \
        egl_test_utils.c
 testeglerror_LDADD = $(top_builddir)/src/EGL/libEGL.la
 testeglerror_LDADD += $(top_builddir)/src/OpenGL/libOpenGL.la
+
+testegldebug_SOURCES = \
+       testegldebug.c \
+       egl_test_utils.c
+testegldebug_LDADD = $(top_builddir)/src/EGL/libEGL.la
diff --git a/tests/dummy/EGL_dummy.c b/tests/dummy/EGL_dummy.c
index 18c6211..372e0a0 100644
--- a/tests/dummy/EGL_dummy.c
+++ b/tests/dummy/EGL_dummy.c
@@ -61,6 +61,7 @@ static const EGLint DUMMY_EGL_CONFIG_COUNT = 2;
 typedef struct DummyEGLDisplayRec {
     EGLenum platform;
     void *native_display;
+    EGLLabelKHR label;
 
     struct glvnd_list entry;
 } DummyEGLDisplay;
@@ -68,6 +69,7 @@ typedef struct DummyEGLDisplayRec {
 typedef struct DummyThreadStateRec {
     EGLint lastError;
     EGLContext currentContext;
+    EGLLabelKHR label;
 } DummyThreadState;
 
 static const __EGLapiExports *apiExports = NULL;
@@ -75,6 +77,9 @@ static glvnd_key_t threadStateKey;
 static struct glvnd_list displayList;
 static EGLint failNextMakeCurrentError = EGL_NONE;
 
+static EGLDEBUGPROCKHR debugCallbackFunc = NULL;
+static EGLBoolean debugCallbackEnabled = EGL_TRUE;
+
 static DummyThreadState *GetThreadState(void)
 {
     DummyThreadState *thr = (DummyThreadState *)
@@ -102,10 +107,16 @@ static void CommonEntrypoint(void)
     thr->lastError = EGL_SUCCESS;
 }
 
-static void SetLastError(EGLint error)
+static void SetLastError(const char *command, EGLLabelKHR label, EGLint error)
 {
     DummyThreadState *thr = GetThreadState();
+
     thr->lastError = error;
+
+    if (error != EGL_SUCCESS && debugCallbackFunc != NULL && 
debugCallbackEnabled) {
+        debugCallbackFunc(error, command, EGL_DEBUG_MSG_ERROR_KHR, thr->label,
+                label, DUMMY_VENDOR_NAME);
+    }
 }
 
 static DummyEGLDisplay *LookupEGLDisplay(EGLDisplay dpy)
@@ -189,7 +200,7 @@ static EGLDisplay dummyGetPlatformDisplay(EGLenum platform, 
void *native_display
         }
     } else {
         // We don't support this platform.
-        SetLastError(EGL_BAD_PARAMETER);
+        SetLastError("eglGetPlatformDisplay", NULL, EGL_BAD_PARAMETER);
         return EGL_NO_DISPLAY;
     }
 
@@ -258,15 +269,16 @@ static EGLContext EGLAPIENTRY 
dummy_eglCreateContext(EGLDisplay dpy,
         EGLConfig config, EGLContext share_context, const EGLint *attrib_list)
 {
     DummyEGLContext *dctx;
+    DummyEGLDisplay *disp;
 
     CommonEntrypoint();
-    LookupEGLDisplay(dpy);
+    disp = LookupEGLDisplay(dpy);
 
     if (attrib_list != NULL) {
         int i;
         for (i=0; attrib_list[i] != EGL_NONE; i += 2) {
             if (attrib_list[i] == EGL_CREATE_CONTEXT_FAIL) {
-                SetLastError(attrib_list[i + 1]);
+                SetLastError("eglCreateContext", disp->label, attrib_list[i + 
1]);
                 return EGL_NO_CONTEXT;
             } else {
                 printf("Invalid attribute 0x%04x in eglCreateContext\n", 
attrib_list[i]);
@@ -355,7 +367,7 @@ static EGLBoolean EGLAPIENTRY 
dummy_eglMakeCurrent(EGLDisplay dpy, EGLSurface dr
     LookupEGLDisplay(dpy);
 
     if (failNextMakeCurrentError != EGL_NONE) {
-        SetLastError(failNextMakeCurrentError);
+        SetLastError("eglMakeCurrent", NULL, failNextMakeCurrentError);
         failNextMakeCurrentError = EGL_NONE;
         return EGL_FALSE;
     }
@@ -495,6 +507,51 @@ static EGLBoolean EGLAPIENTRY 
dummy_eglQueryDevicesEXT(EGLint max_devices, EGLDe
     return EGL_TRUE;
 }
 
+static EGLint EGLAPIENTRY dummy_eglDebugMessageControlKHR(EGLDEBUGPROCKHR 
callback, const EGLAttrib *attrib_list)
+{
+    CommonEntrypoint();
+
+    if (callback != NULL) {
+        if (attrib_list != NULL) {
+            int i;
+            for (i=0; attrib_list[i] != EGL_NONE; i += 2) {
+                if (EGL_DEBUG_MSG_ERROR_KHR) {
+                    debugCallbackEnabled = (attrib_list[i + 1] != 0);
+                }
+            }
+        }
+    } else {
+        debugCallbackEnabled = EGL_TRUE;
+    }
+    debugCallbackFunc = callback;
+
+    return EGL_SUCCESS;
+}
+
+static EGLBoolean EGLAPIENTRY dummy_eglQueryDebugKHR(EGLint attribute, 
EGLAttrib *value)
+{
+    // eglQueryDebugKHR should never be called, because libEGL keeps track of
+    // all of the debug state.
+    printf("eglQueryDebugKHR should never be called\n");
+    abort();
+    return EGL_FALSE;
+}
+
+static EGLint EGLAPIENTRY dummy_eglLabelObjectKHR(EGLDisplay dpy,
+        EGLenum objectType, EGLObjectKHR object, EGLLabelKHR label)
+{
+    CommonEntrypoint();
+
+    if (objectType == EGL_OBJECT_THREAD_KHR) {
+        DummyThreadState *thr = GetThreadState();
+        thr->label = label;
+    } else if (objectType == EGL_OBJECT_DISPLAY_KHR) {
+        DummyEGLDisplay *disp = LookupEGLDisplay(dpy);
+        disp->label = label;
+    }
+    return EGL_SUCCESS;
+}
+
 static const GLubyte *dummy_glGetString(GLenum name)
 {
     if (name == GL_VENDOR) {
@@ -666,6 +723,9 @@ static const struct {
     PROC_ENTRY(eglGetError),
 
     PROC_ENTRY(eglQueryDevicesEXT),
+    PROC_ENTRY(eglDebugMessageControlKHR),
+    PROC_ENTRY(eglQueryDebugKHR),
+    PROC_ENTRY(eglLabelObjectKHR),
 
     PROC_ENTRY(glGetString),
 #undef PROC_ENTRY
diff --git a/tests/egl_test_utils.c b/tests/egl_test_utils.c
index 583e4ed..cfc32e1 100644
--- a/tests/egl_test_utils.c
+++ b/tests/egl_test_utils.c
@@ -9,6 +9,9 @@ const char *DUMMY_VENDOR_NAMES[DUMMY_VENDOR_COUNT] = {
 };
 
 PFNEGLQUERYDEVICESEXTPROC ptr_eglQueryDevicesEXT;
+PFNEGLDEBUGMESSAGECONTROLKHRPROC ptr_eglDebugMessageControlKHR;
+PFNEGLQUERYDEBUGKHRPROC ptr_eglQueryDebugKHR;
+PFNEGLLABELOBJECTKHRPROC ptr_eglLabelObjectKHR;
 
 pfn_eglTestDispatchDisplay ptr_eglTestDispatchDisplay;
 pfn_eglTestDispatchDevice ptr_eglTestDispatchDevice;
@@ -28,6 +31,12 @@ void loadEGLExtensions(void)
 {
     ptr_eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC)
         loadEGLFunction("eglQueryDevicesEXT");
+    ptr_eglDebugMessageControlKHR = (PFNEGLDEBUGMESSAGECONTROLKHRPROC)
+        loadEGLFunction("eglDebugMessageControlKHR");
+    ptr_eglQueryDebugKHR = (PFNEGLQUERYDEBUGKHRPROC)
+        loadEGLFunction("eglQueryDebugKHR");
+    ptr_eglLabelObjectKHR = (PFNEGLLABELOBJECTKHRPROC)
+        loadEGLFunction("eglLabelObjectKHR");
 
     ptr_eglTestDispatchDisplay = (pfn_eglTestDispatchDisplay)
         loadEGLFunction("eglTestDispatchDisplay");
diff --git a/tests/egl_test_utils.h b/tests/egl_test_utils.h
index aad4c71..9703994 100644
--- a/tests/egl_test_utils.h
+++ b/tests/egl_test_utils.h
@@ -48,6 +48,9 @@
 extern const char *DUMMY_VENDOR_NAMES[DUMMY_VENDOR_COUNT];
 
 extern PFNEGLQUERYDEVICESEXTPROC ptr_eglQueryDevicesEXT;
+extern PFNEGLDEBUGMESSAGECONTROLKHRPROC ptr_eglDebugMessageControlKHR;
+extern PFNEGLQUERYDEBUGKHRPROC ptr_eglQueryDebugKHR;
+extern PFNEGLLABELOBJECTKHRPROC ptr_eglLabelObjectKHR;
 
 extern pfn_eglTestDispatchDisplay ptr_eglTestDispatchDisplay;
 extern pfn_eglTestDispatchDevice ptr_eglTestDispatchDevice;
diff --git a/tests/testegldebug.c b/tests/testegldebug.c
new file mode 100644
index 0000000..729cde3
--- /dev/null
+++ b/tests/testegldebug.c
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2016, NVIDIA CORPORATION.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * unaltered in all copies or substantial portions of the Materials.
+ * Any additions, deletions, or changes to the original source files
+ * must be clearly indicated in accompanying documentation.
+ *
+ * If only executable code is distributed, then the accompanying
+ * documentation must state that "this software is based in part on the
+ * work of the Khronos Group."
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ */
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GL/gl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "dummy/EGL_dummy.h"
+#include "egl_test_utils.h"
+
+/**
+ * \file
+ *
+ * Tests for EGL_KHR_debug.
+ *
+ * This test works by recording the parameters that we expect the debug
+ * callback function to get, and then calling an EGL function that generates an
+ * error.
+ *
+ * The debug callback checks its parameters against the expected values, and
+ * exits if any of them don't match.
+ */
+
+static const EGLLabelKHR THREAD_LABEL = (EGLLabelKHR) "THREAD_LABEL";
+static const EGLLabelKHR DISPLAY_LABEL = (EGLLabelKHR) "DISPLAY_LABEL";
+
+static void testCallback(EGLDisplay dpy, EGLBoolean callbackEnabled);
+
+static void EGLAPIENTRY debugCallback(EGLenum error, const char *command,
+        EGLint messageType, EGLLabelKHR threadLabel, EGLLabelKHR objectLabel,
+        const char *message);
+
+/**
+ * Records the expected parameters for the next call to the debug callback.
+ */
+static void setCallbackExpected(const char *command, EGLenum error,
+    EGLLabelKHR objectLabel, const char *message);
+static void setCallbackNotExpected(void);
+static void checkError(EGLint expectedError);
+
+/**
+ * True if the debug callback has been called since the last call to
+ * \c setCallbackExpected. This is used to make sure that the debug callback
+ * is called exactly once when a function generates an error.
+ */
+static EGLBoolean callbackWasCalled = EGL_FALSE;
+
+// These are the expected values for the next call to the debug callback, set
+// from setCallbackExpected and setCallbackNotExpected.
+static EGLBoolean shouldExpectCallback = EGL_FALSE;
+static const char *nextExpectedCommand = NULL;
+static EGLint nextExpectedError = EGL_NONE;
+static EGLLabelKHR nextExpectedObject = NULL;
+static const char *nextExpectedMessage = NULL;
+
+int main(int argc, char **argv)
+{
+    EGLDisplay dpy;
+    EGLAttrib callbackAttribs[] = {
+        EGL_DEBUG_MSG_ERROR_KHR, EGL_TRUE,
+        EGL_NONE
+    };
+
+    // We shouldn't get a callback for anything yet.
+    setCallbackNotExpected();
+
+    loadEGLExtensions();
+    dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+    checkError(EGL_SUCCESS);
+
+    ptr_eglLabelObjectKHR(EGL_NO_DISPLAY, EGL_OBJECT_THREAD_KHR, NULL, 
THREAD_LABEL);
+    ptr_eglLabelObjectKHR(dpy, EGL_OBJECT_DISPLAY_KHR, (EGLObjectKHR) dpy, 
DISPLAY_LABEL);
+
+    // Start by enabling the callback and generating some EGL errors. Make sure
+    // that the callback gets called with the correct parameters.
+    printf("Testing with callback\n");
+    ptr_eglDebugMessageControlKHR(debugCallback, NULL);
+    testCallback(dpy, EGL_TRUE);
+
+    // Disable the callback and try again. This time, the callback should not
+    // be called, but we should still get the same errors from eglGetError.
+    printf("Testing with no callback\n");
+    ptr_eglDebugMessageControlKHR(NULL, NULL);
+    testCallback(dpy, EGL_FALSE);
+
+    // Set a callback, but disable error messages. Again, the callback should
+    // not be called.
+    printf("Testing with callback and error messages disabled\n");
+    callbackAttribs[1] = EGL_FALSE;
+    ptr_eglDebugMessageControlKHR(debugCallback, callbackAttribs);
+    testCallback(dpy, EGL_FALSE);
+
+    return 0;
+}
+
+void testCallback(EGLDisplay dpy, EGLBoolean callbackEnabled)
+{
+    static const EGLint ERROR_ATTRIBS[] = {
+        EGL_CREATE_CONTEXT_FAIL, EGL_BAD_MATCH,
+        EGL_NONE
+    };
+
+    if (!callbackEnabled) {
+        setCallbackNotExpected();
+    }
+
+    // Generate an error from libEGL.so.
+    printf("Checking eglGetCurrentSurface\n");
+    if (callbackEnabled) {
+        setCallbackExpected("eglGetCurrentSurface", EGL_BAD_PARAMETER,
+                THREAD_LABEL, NULL);
+    }
+    eglGetCurrentSurface(EGL_NONE);
+    checkError(EGL_BAD_PARAMETER);
+
+    // Generate an error from a dispatch stub that expects a display. This
+    // should go through the same error reporting as eglGetCurrentSurface did.
+    printf("Checking eglCreateContext with invalid display\n");
+    if (callbackEnabled) {
+        setCallbackExpected("eglCreateContext", EGL_BAD_DISPLAY,
+                NULL, NULL);
+    }
+    eglCreateContext(EGL_NO_DISPLAY, NULL, EGL_NO_CONTEXT, NULL);
+    checkError(EGL_BAD_DISPLAY);
+
+    // Generate an error from the vendor library, to make sure that all of the
+    // EGL_KHR_debug calls got passed through correctly. The vendor library
+    // should pass the display label to the callback, and it uses the vendor
+    // name as the message.
+    printf("Checking eglCreateContext with valid display\n");
+    if (callbackEnabled) {
+        setCallbackExpected("eglCreateContext", EGL_BAD_MATCH,
+                DISPLAY_LABEL, DUMMY_VENDOR_NAMES[0]);
+    }
+    eglCreateContext(dpy, NULL, EGL_NO_CONTEXT, ERROR_ATTRIBS);
+    checkError(EGL_BAD_MATCH);
+}
+
+void setCallbackExpected(const char *command, EGLenum error,
+    EGLLabelKHR objectLabel, const char *message)
+{
+    shouldExpectCallback = EGL_TRUE;
+    nextExpectedCommand = command;
+    nextExpectedError = error;
+    nextExpectedObject = objectLabel;
+    nextExpectedMessage = message;
+    callbackWasCalled = EGL_FALSE;
+}
+
+void setCallbackNotExpected(void)
+{
+    shouldExpectCallback = EGL_FALSE;
+    callbackWasCalled = EGL_FALSE;
+}
+
+void EGLAPIENTRY debugCallback(EGLenum error, const char *command,
+        EGLint messageType, EGLLabelKHR threadLabel, EGLLabelKHR objectLabel,
+        const char *message)
+{
+    // First, make sure the debug callback was supposed to be called at all.
+    if (!shouldExpectCallback) {
+        printf("Unexpected callback from \"%s\"\n", command);
+        exit(1);
+    }
+
+    // Make sure the callback only gets called once.
+    if (callbackWasCalled) {
+        printf("Callback called multiple times from \"%s\"\n", command);
+        exit(1);
+    }
+    callbackWasCalled = EGL_TRUE;
+
+    if (messageType != EGL_DEBUG_MSG_ERROR_KHR) {
+        printf("Unexpected callback type: Expected 0x%04x, got 0x%04x\n",
+                EGL_DEBUG_MSG_ERROR_KHR, messageType);
+        exit(1);
+    }
+
+    if (error != nextExpectedError) {
+        printf("Unexpected callback error: Expected 0x%04x, got 0x%04x\n",
+                nextExpectedError, error);
+        exit(1);
+    }
+
+    if (command == NULL) {
+        printf("Command is NULL\n");
+        exit(1);
+    }
+
+    if (nextExpectedCommand != NULL) {
+        if (strcmp(nextExpectedCommand, command) != 0) {
+            printf("Unexpected command: Expected \"%s\", got \"%s\"\n",
+                    nextExpectedCommand, command);
+            exit(1);
+        }
+    }
+
+    if (nextExpectedMessage != NULL) {

Reply via email to