maple_enum: Leverage builtins to simplify enum matching.

The use of the byteswap is straightforward. The algorithm for
determining which `function_data` element contains the data
relevant to the function at hand used to go bit by bit counting
how many bits are above the function bit, as the elements of
`function_data` map from MSB down to up to 3 functions. Instead
of looping over the bits, build a mask to mask out everything but
bits that would appear above the desired function bit, then count
how many there are left with popcount.

Author: QuzarDC

kernel/arch/dreamcast/hardware/maple/maple_enum.c

@@ -7,6 +7,8 @@
 
 #include <dc/maple.h>
 #include <kos/thread.h>
+#include <kos/regfield.h>
+#include <assert.h>
 
 /* Return the number of connected devices */
 int maple_enum_count(void) {
@@ -22,15 +24,15 @@ int maple_enum_count(void) {
 }
 
 /* Return a raw device info struct for the given device */
-maple_device_t * maple_enum_dev(int p, int u) {
+maple_device_t *maple_enum_dev(int p, int u) {
     maple_device_t *rv = maple_state.ports[p].units[u];
     if(rv && rv->valid)
         return rv;
     return NULL;
 }
 
 /* Return the Nth device of the requested type (where N is zero-indexed) */
-maple_device_t * maple_enum_type(int n, uint32_t func) {
+maple_device_t *maple_enum_type(int n, uint32_t func) {
     int p, u;
     maple_device_t *dev;
 
@@ -51,10 +53,16 @@ maple_device_t * maple_enum_type(int n, uint32_t func) {
 
 /* Return the Nth device that is of the requested type and supports the list of
    capabilities given. */
-maple_device_t * maple_enum_type_ex(int n, uint32_t func, uint32_t cap) {
+maple_device_t *maple_enum_type_ex(int n, uint32_t func, uint32_t cap) {
     int p, u, d;
     maple_device_t *dev;
-    uint32_t f, tmp;
+    uint32_t funcmask;
+
+    /* If func is 0, there can be no match (and it's UB for clz below) */
+    if(!func) return NULL;
+
+    /* Create a mask that leaves only the bits above func. */
+    funcmask = ~GENMASK(31 - __builtin_clz(func), 0);
 
     for(p = 0; p < MAPLE_PORT_COUNT; ++p) {
         for(u = 0; u < MAPLE_UNIT_COUNT; ++u) {
@@ -63,28 +71,18 @@ maple_device_t * maple_enum_type_ex(int n, uint32_t func, uint32_t cap) {
             /* If the device supports the function code we passed in, check
                if it supports the capabilities that the user requested. */
             if(dev != NULL && (dev->info.functions & func)) {
-                f = dev->info.functions;
-                d = 0;
-                tmp = func;
 
                 /* Figure out which function data we want to look at. Function
                    data entries are arranged by the function code, most
-                   significant bit first. This is really not pretty, and is
-                   rather inefficient, but its the best I could think of off the
-                   top of my head (i.e, replace me later). */
-                while(tmp != 0x80000000) {
-                    if(f & 0x80000000) {
-                        ++d;
-                    }
-
-                    f <<= 1;
-                    tmp <<= 1;
-                }
+                   significant bit first. So we count the bits above func. */
+                d = __builtin_popcount(dev->info.functions & funcmask);
+
+                /* Ensure that the result is in-bounds */
+                assert((d >= 0) && (d < 3));
 
                 /* Check if the function data for the function type checks out
                    with what it should be. */
-                cap = ((cap >> 24) & 0xFF) | ((cap >> 8) & 0xFF00) |
-                      ((cap & 0xFF00) << 8) | ((cap & 0xFF) << 24);
+                cap = __builtin_bswap32(cap);
 
                 if((dev->info.function_data[d] & cap) == cap) {
                     if(!n)