New method for discriminating between optimal implementations

This takes advantage of the change in behaviour of interworking branches
between ARMv6 and ARMv7 to distinguish which one we're running on. This makes
the test OS-independent (and in any case it's questionable how safe it is to
be making system calls when a function as fundamental as memcpy isn't
functional yet, so this is probably a safer approach).

The main downside here is that anyone trying the library on an ARMv7 platform
which lacks NEON (the usual example is nVidia Tegra 2) will find it doesn't
work. But then we're not pretending to offer an optimised implementation for
that anyway, and they might as well continue to use glibc.

Makefile

@@ -1,4 +1,4 @@
-OBJS = arm-mem.o memcmp.o memcpymove.o memcpymove-a7.o memset.o
+OBJS = architecture.o arm-mem.o memcmp.o memcpymove.o memcpymove-a7.o memset.o
 CFLAGS += -std=gnu99 -O2
 
 all: libarmmem.so libarmmem.a test

architecture.S

@@ -0,0 +1,44 @@
+/*
+Copyright (c) 2015, RISC OS Open Ltd
+All rights reserved.
+
+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 the copyright holder 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 HOLDER 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.
+*/
+
+/* Grubby, but completely OS-independent and USR-mode safe way to
+ * distinguish between ARMv6 and ARMv7 platforms at runtime
+ */
+
+.global architecture
+.hidden architecture
+.func   architecture
+.arm
+architecture:
+        sub     pc, pc, #1  @ is an interworking branch on ARMv7, not ARMv6
+        and     a1, a4, a1  @ second word interpreted as 'B .+0xA' if Thumb
+        mov     a1, #6
+        bx      lr
+.thumb
+        mov     a1, #7
+        bx      lr
+.endfunc

arm-mem.c

@@ -27,35 +27,23 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #define _GNU_SOURCE /* enable mempcpy */
 #include <string.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <elf.h>
 
-#define DISPATCH_ON_NEON(func,suffix0,suffix1)           \
-    typeof(func) func##_##suffix0;                       \
-    typeof(func) func##_##suffix1;                       \
+extern int architecture(void);
+
+#define DISPATCH_ON_V6V7(func,suffix6,suffix7)           \
+    typeof(func) func##_##suffix6;                       \
+    typeof(func) func##_##suffix7;                       \
     asm(".type " #func ", %gnu_indirect_function");      \
     typeof(func) *func##_dispatch(void) __asm__(#func);  \
     typeof(func) *func##_dispatch(void)                  \
     {                                                    \
-        Elf32_auxv_t aux;                                \
-        int fd = open("/proc/self/auxv", O_RDONLY);      \
-        if (fd < 0) /* Error? */                         \
-            return func##_##suffix0;                     \
-        while (read(fd, &aux, sizeof aux) == sizeof aux) \
-        {                                                \
-            if (aux.a_type == AT_HWCAP)                  \
-            {                                            \
-                close(fd);                               \
-                return aux.a_un.a_val & 4096 ?           \
-                    func##_##suffix1 : func##_##suffix0; \
-            }                                            \
-        }                                                \
-        close(fd);                                       \
-        return func##_##suffix0;                         \
+        if (architecture() >= 7)                         \
+            return func##_##suffix7;                     \
+        else                                             \
+            return func##_##suffix6;                     \
     }                                                    \
 
-DISPATCH_ON_NEON(memcpy,arm1176jzfs,cortexa7)
-DISPATCH_ON_NEON(memmove,arm1176jzfs,cortexa7)
-DISPATCH_ON_NEON(mempcpy,arm1176jzfs,cortexa7)
-DISPATCH_ON_NEON(__mempcpy,arm1176jzfs,cortexa7)
+DISPATCH_ON_V6V7(memcpy,arm1176jzfs,cortexa7)
+DISPATCH_ON_V6V7(memmove,arm1176jzfs,cortexa7)
+DISPATCH_ON_V6V7(mempcpy,arm1176jzfs,cortexa7)
+DISPATCH_ON_V6V7(__mempcpy,arm1176jzfs,cortexa7)