-/test

-| F

-

-- Remove type specifier from version macro;

-- Add mathematical functions abs and fma;

-- Update documentation;

-- Remove nothrw attribute from foreach;

-- Remove UB from foreach test;

-- Fix parameter mismatch in foreach test;

-- Use unsigned char instead of uint_least8_t;

-- Remove unnecessary casts;

-- Add new headers: 'zap/math.h' (for mathematical functions), 'zap/mem.h' (for memory sequence functions);

-- Restructure makefile;

-- Fix not using INT_LEAST8_MAX and INT_LEAST8_MIN instead of INT8_MAX and INT8_MIN;

-- Remove '/build' from gitignore;

-

-| E

-

-- Fix incorrect version number;

-

-| D

-

-- Add function foreach: Run function on each element;

-- Use directive globl instead of global in assembly;

-- Use SIZE_MAX instead of negative one;

-- Remove asflags from makefile;

-- Don't require GNU Make;

-- Change the type of fndbyte: (size_t (void const *,size_t,uint_least8_t)) => (size_t (void const *,size_t,unsigned char));

-- Change the type of memfill: (void (void *,size_t,uint_least8_t)) => (void (void *,size_t,unsigned char));

-- Update readme (add documentation for some functions);

-- Update susinfo symbol names;

-

-| C

-

-- Fix install target;

-- Remove type literals;

-

-| B

-

-- memdup: Use sus_unlikely instead of __builtin_expect;

-- Rename project to zap (from rgo);

-- Remove global license file (useless with MPL);

-- Migrate test to C++ (for reasons which will be revealed later);

-- Restructure headers;

-- Add include guards to the private header;

-- Add attribute useret to functions;

-- Require GNU Make;

-- Compile position independent code;

-- Update readme;

-

-| A

-

-- Installation script: Create installation directories if they don't already exist;

-- Don't use susinfo types;

-- Remove declarations for getbinver;

-- Add memcmp, strcmp;

-- Update makefile;

-- Reimplement fastimpl as a global variable;

-- Change type of fastimpl (uint_least8_t => _Bool);

-- Change the return types of memeq and streq (uint_least8_t => _Bool);

-- Enable compilation warnings;

-- Add type literals (like those from susinfo);

-- Use *int_leastN_t instead of *intN_t;

-- Remove restrict-qualifications;

-- Remove C++ version of memdup;

-

-| 9

-

-- Fix readme not reflecting that we now support all platforms;

-- Rename the 'Building' section in the readme to 'Building & Installing';

-

-| 8

-

-- Use susinfo;

-- Implement algorithms in C (with inline assembly on supported platforms);

-- Add comments;

-- Fix strcpy counting the null-terminator;

-- Fix strcpy taking a pointer-to-const as the output;

-- Implement strcpy, streq in IA-32;

-- Optimise streq: Only use the lower eight bytes for the return value;

-- Optimise strlen: Use fewer registers;

-- Fix memfill taking a pointer-to-const as the output;

-- Fix strfill taking a pointer-to-const as the output;

-- Update readme;

-- Add private header;

-- Remove assembly-specific version macro;

-

-| 7

-

-- Relicense under MPL2;

-- Instead of throwing an error, define a macro when the header is included on an unsupported platform;

-

-| 6

-

-- Remove stupid debug return from memcpy;

-

-| 5

-

-- Fix compile flags not indicating new relative header location;

-

-| 4

-

-- Add install target to makefile;

-- Merge makefiles;

-

-| 3

-

-- Enable compiler optimisations;

-- Optimise memfill;

-- Optimise memcpy: Use movdqu instead of movups (AMD64, i386 SSE2), add 256-bit copy (AMD64 AVX, i386 AVX);

-- Update makefile;

-- Implement fndbyte, fndchr, strlen in IA-32;

-- Fix bug in test;

-- Update readme;

-- Add new planned architectures: Motorola 68000, Power ISA, RISC-V, Sparc;

-

-| 2

-

-- Fix target purge in makefile not being labeled phony;

-- Add machien architecture check in header;

-- Implement memcpy, memeq, memfill in IA-32;

-- Fix some incorrect comments;

-- Use a different register order for temporaries and optimise register usage;

-- Fix bug in memeq: Should jump if zero, not if equal;

-- Update readme;

-

-| 1

-

-- Fix indentation in license notices;

-- Fix incorrect declaration for rgo_strcpy, rgo_streq;

-- Implement fndbyte,memeq,strcpy,streq;

-- Add new tests;

-- Fix bug in memcpy: Should jump if zero, not if equal;

-- Remove declaration for rgo_memcmp;

-- Add macro rgo_ver, defined to the current version number;

-- Add assembly declaration for rgo_fndchr, rgo_fndbyte;

-- Fix some incorrect comments;

-- Use movups instead of movdqu in memcpy;

-

-| 0

-

-- Initial.

-LIBZAP = zap/libzap.a

-

-.PHONY: clean install purge zap

-

-zap:

- $(MAKE) -Czap

-

-install: zap

- mkdir -pm755 $(HDRDIR)/zap

- mkdir -pm755 $(LIBDIR)

- install -Dm644 zap/include/zap/base.h $(HDRDIR)/zap

- install -Dm644 zap/include/zap/math.h $(HDRDIR)/zap

- install -Dm644 zap/include/zap/mem.h $(HDRDIR)/zap

- install -Dm755 $(LIBZAP) $(LIBDIR)

-

-clean:

- $(MAKE) -Czap clean

-

-purge:

- $(MAKE) -Czap purge

-<!DOCTYPE html>

-<html>

- <h1>zap</h1>

- <p>A library for algorithmics.</p>

- <p><i>Note: This library is still in it's early stages and is NOT anywhere near being fully optimised.</i></p>

- <br />

- <h2>Building and installation</h2>

- <p>The provided makefile has been tested to work with both GNU Make and BSD Make.</p>

- <p>The default target builds the static library file (located at <i>zap/libzap.a</i>). The target <i>clean</i> removes object files, whilst <i>purge</i> removes object files and the static library file.</p>

- <p>Currently, zap doesn't support being compiled as a shared library out of the box, but the makefile could be modified to allow this.</p>

- <p>The <i>install</i> target installs the headers to <i>$(HDRDIR)</i> and the library file to <i>$(LIBDIR)</i>.</p>

- <p>Instructions for building the test program may be found on the first line of <i>test.c</i>.</p>

- <h2>Documentation</h2>

- <h3>abs</h3>

- <h4>Synopsis</h4>

- <code>#include &ltzap/math.h&gt<br />signed char zap_abs_c(signed char val);<br />int zap_abs_i(int val);<br />long zap_abs_l(long val);<br />long long zap_abs_ll(long long val);<br />short zap_abs_s(short val);</code>

- <h4>Description</h4>

- <p>Returns the absolute value of <i>val</i>.</p>

- <br />

- <h3>fma</h3>

- <h4>Synopsis</h4>

- <code>#include &ltzap/math.h&gt<br />signed char zap_fma_c(signed char a,signed char b,signed char c);<br/>int zap_fma_i(int a,int b,int c);<br/>long zap_fma_l(long a,long b,long c);<br/>long long zap_fma_ll(long long a,long long b,long long c);<br/>short zap_fma_s(short a,short b,short c);<br/>unsigned char zap_fma_uc(unsigned char a,unsigned char b,unsigned char c);<br/>unsigned int zap_fma_ui(unsigned int a,unsigned int b,unsigned int c);<br/>unsigned long zap_fma_ul( unsigned long a,unsigned long b,unsigned long c);<br/>unsigned long long zap_fma_ull(unsigned long long a,unsigned long long b,unsigned long long c);<br/>unsigned short zap_fma_us( unsigned short a,unsigned short b,unsigned short c);</code>

- <h4>Description</h4>

- <p>Returns the the fused multiply-add of <i>a</i>, <i>b</i>, and <i>c</i>.</p>

- <br />

- <h3>fndbyte</h3>

- <h4>Synopsis</h4>

- <code>#include &ltzap/mem.h&gt<br />size_t zap_fndbtyte(void const * ptr,size_t num,unsigned char byte);</code>

- <h4>Description</h4>

- <p>Searches for the byte-value <i>byte</i> in the array pointed to by <i>ptr</i> within the bounds of <i>num</i>.</p>

- <p>If <i>ptr</i> is not a valid pointer to a null-terminated string, the behaviour is undefined.</p>

- <p>If <i>num</i> is larger (but not smaller) than the number of bytes in the array, the behaviour is undefined.</p>

- <p>If the byte-value is found within the domain, the position of it's first occurrence (starting at zero) is returned. Otherwise, <i>SIZE_MAX</i> is returned.</p>

- <br />

- <h3>fndchr</h3>

- <h4>Synopsis</h4>

- <code>#include &ltzap/mem.h&gt<br />size_t zap_fndchr(char const * str,char chr);</code>

- <h4>Description</h4>

- <p>Searches for the character <i>chr</i> in the string <i>str</i>.</p>

- <p>If the character is found in the string, the position of it's first occurrence (starting at zero) is returned. Otherwise, <i>SIZE_MAX</i> is returned.</p>

- <p>If <i>str</i> is not a valid pointer to a null-terminated string, the behaviour is undefined.</p>

- <br />

- <h3>foreach</h3>

- <h4>Synopsis</h4>

- <code>#include &ltzap/mem.h&gt<br />void zap_foreach(void * ptr,size_t sz,size_t num,void (* fn)(void *),void * * rem);</code>

- <h4>Description</h4>

- <p>Iterates through the array pointed to by <i>ptr</i>, invoking the function <i>fn</i> with a pointer to the current element. Each pointer value after the first is equal to the previous plus <i>sz</i>.</p>

- <p>If the pointed-to object of <i>rem</i> is not a null pointer, the iterations are started from that address. If <i>fn</i> throws an exception, the current position is written to the pointed-to object of <i>rem</i> (unless <i>rem</i> is a null pointer) and <i>foreach</i> returns the control-flow to the caller via this exception.</p>

- <p>If the expression <code>(sz * num)</code> is not a valid object size, the behaviour is undefined.</p>

- <p>If <i>fn</i> is not a valid pointer to a function with C language linkage, the behaviour is undefined.</p>

- <p>If <i>rem</i> is not a null pointer and the pointed-to object is not initialised to <i>NULL</i> before the call to <i>foreach</i>, the behaviour is undefined.</p>

- <br />

- <h3>memcmp</h3>

- <h4>Synopsis</h4>

- <code>#include &ltzap/mem.h&gt<br />int_least8_t zap_memcmp(void const * lptr,size_t num,void const * rptr);</code>

- <h4>Description</h4>

- <p>Compares <i>num</i>-bytes of the arrays pointed to by <i>lptr</i> and <i>rptr</i>.</p>

- <p>The returned value is determined by the first byte found to be different in the two arrays. If the byte has a larger value in <i>lptr</i>, a negative (less than zero) value is returned. If it's the other way, a positive (greater than zero) value is returned. Otherwise (the arrays where represented the same), zero is returned.</p>

- <p>If <i>lptr</i> or <i>rptr</i> (or both) are not valid pointers to arrays, the behaviour is undefined.</p>

- <p>If <i>num</i> is larger (but not smaller) than the number of bytes of the smallest array, the behaviour is undefined.</p>

- <br />

- <h3>memcpy</h3>

- <h4>Synopsis</h4>

- <code>#include &ltzap/mem.h&gt<br />void zap_memcpy(void const * in,size_t num,void * out);</code>

- <h4>Description</h4>

- <p>Copies <i>num</i>-bytes from the buffer pointed to by <i>in</i> into the same relative position in the buffer pointer to by <i>out</i>.</p>

- <p>If <i>in</i> or <i>out</i> (or both) are not valid pointers to arrays, the behaviour is undefined.</p>

- <p>If <i>num</i> is larger (but not smaller) than the number of bytes of the smallest array, the behaviour is undefined.</p>

- <br />

- <h3>memdup</h3>

- <h4>Synopsis</h4>

- <code>#include &ltzap/mem.h&gt<br />void * zap_memdup(void const * ptr,size_t num);</code>

- <h4>Description</h4>

- <p>Copies <i>num</i>-bytes from the array pointed to by <i>ptr</i> into a newly-allocated array. The new array is allocated by <i>malloc</i>.</p>

- <p>The returned value is a pointer to the new array.</p>

- <p>If <i>num</i> is larger (but not smaller) than the number of bytes in the array, the behaviour is undefined.</p>

- <br />

- <h3>memeq</h3>

- <h4>Synopsis</h4>

- <code>#include &ltzap/mem.h&gt<br />bool zap_memeq(void const * lptr,size_t num,void * rptr);</code>

- <h4>Description</h4>

- <p>Checks <i>num</i>-bytes of the buffers pointed to by <i>lptr</i> and <i>rptr</i> for equality.</p>

- <p>If any two bytes are found to be different in the two buffers, false is returned. Otherwise, true is returned.</p>

- <p>If <i>lptr</i> or <i>rptr</i> (or both) are not valid pointers to arrays, the behaviour is undefined.</p>

- <p>If <i>num</i> is larger (but not smaller) than the number of bytes of the smallest array, the behaviour is undefined.</p>

- <br />

- <h3>memfill</h3>

- <h4>Synopsis</h4>

- <code>#include &ltzap/mem.h&gt<br />void zap_memfill(void const * ptr,size_t num,unsigned char byte);</code>

- <h4>Description</h4>

- <p>Fills <i>num</i>-bytes of the buffer pointed to by <i>ptr</i> with the representation of <i>byte</i>.</p>

- <p>If <i>ptr</i> is not a valid pointer to an array, the behaviour is undefined.</p>

- <p>If <i>num</i> is larger (but not smaller) than the number of bytes of in the array, the behaviour is undefined.</p>

- <br />

- <h3>streq</h3>

- <h4>Synopsis</h4>

- <code>#include &ltzap/mem.h&gt<br />bool zap_streq(char const * lstr,char const * rstr);</code>

- <h4>Description</h4>

- <p>Checks the equality of the strings <i>lstr</i> and <i>rstr</i>.</p>

- <p>If one of the strings has a length different from the other, or if any character in the two strings is different from the other (at the same offset), true is returned. Otherwise, false is returned.</p>

- <p>If <i>lstr</i> or <i>rstr</i> (or both) are not valid pointers to null-terminated strings, the behaviour is undefined.</p>

- <br />

- <h3>strfill</h3>

- <h4>Synopsis</h4>

- <code>#include &ltzap/mem.h&gt<br />void zap_strfill(char * str,char chr);</code>

- <h4>Description</h4>

- <p>Writes the character <i>chr</i> to every valid position in the string <i>str</i>, excluding that of the null-terminator.</p>

- <p>If <i>str</i> is not a valid pointer to a null-terminated string, the behaviour is undefined.</p>

- <br />

- <h3>strlen</h3>

- <h4>Synopsis</h4>

- <code>#include &ltzap/mem.h&gt<br />size_t zap_strlen(char const * str);</code>

- <h4>Description</h4>

- <p>Counts the number of characters in the string <i>str</i>.</p>

- <p>Returns the number of characters (excluding the null-terminator) in the string.</p>

- <p>If <i>str</i> is not a valid pointer to a null-terminated string, the behaviour is undefined.</p>

-</html> \ No newline at end of file

-/* c++ -Izap/include -Lzap -otest test.cc -lzap */

-

-#include <cassert>

-#include <cinttypes>

-#include <cstddef>

-#include <cstdint>

-#include <cstdio>

-#include <stdexcept>

-#include <zap/math.h>

-#include <zap/mem.h>

-

-extern "C" auto zap_test_foreachfn(void * const _ptr) -> void { /* This function is passed to foreach, which requires C-linkage function pointers. I tried to overload the function to also accept C++-linkage function pointers, but that only made GCC moan. */

- auto const ptr {static_cast<int *>(_ptr)};

- auto val {*ptr};

- if (val == 0x45) {throw ::std::domain_error {"Damn!"};}

- val %= 0x2;

- *ptr = val;

-}

-

-int main(void) {

- ::std::fprintf(stderr,"zap test\n");

- ::std::fprintf(stderr,"arch: %s\n",sus_archstr);

- ::std::fprintf(stderr,"fast: %s\n",::zap_fastimpl ? "yes" : "no");

- ::std::fprintf(stderr,"\n");

- {

- {

- auto val {::zap_abs_c(-0x5D)};

- ::std::fprintf(stderr,"val: %hhi\n",val);

- assert(val == 0x5D);

- }

- {

- auto val {::zap_abs_i(-0xEF4)};

- ::std::fprintf(stderr,"val: %i\n",val);

- assert(val == 0xEF4);

- }

- {

- auto val {::zap_abs_l(-0x6666E67B)};

- ::std::fprintf(stderr,"val: %li\n",val);

- assert(val == 0x6666E67B);

- }

- {

- auto val {::zap_abs_ll(-0x7C91A4B244F0DC99)};

- ::std::fprintf(stderr,"val: %lli\n",val);

- assert(val == 0x7C91A4B244F0DC99);

- }

- {

- auto val {::zap_abs_s(-0xDC9)};

- ::std::fprintf(stderr,"val: %i\n",val);

- assert(val == 0xDC9);

- }

- }

- ::std::fprintf(stderr,"\n");

- {

- { /* Largest number for each signed parameter: (floor(cbrt(2^(x-1)-1))) */

- auto val {::zap_fma_c(0x5,0x2,0x2)};

- ::std::fprintf(stderr,"val: %hhi\n",val);

- assert(val == 0x9);

- }

- {

- auto val {::zap_fma_i(0x29,0x4AD,0x453)};

- ::std::fprintf(stderr,"val: %i\n",val);

- assert(val == 0x143840);

- }

- {

- auto val {::zap_fma_l(0x1BAA11,0x361DA,0x17462F)};

- ::std::fprintf(stderr,"val: %li\n",val);

- assert(val == 0x4EB8123D17);

- }

- {

- auto val {::zap_fma_ll(0x45,0x60,0x1A4)};

- ::std::fprintf(stderr,"val: %lli\n",val);

- assert(val == 0x9DC5);

- }

- {

- auto val {::zap_fma_s(0x7,0xE,0x1D)};

- ::std::fprintf(stderr,"val: %i\n",val);

- assert(val == 0x19D);

- }

- { /* Largest number for each unsigned parameter: (floor(cbrt(2^x-1))) */

- auto val {::zap_fma_uc(0x6u,0x6u,0x3u)};

- ::std::fprintf(stderr,"val: %hhu\n",val);

- assert(val == 0x18u);

- }

- {

- auto val {::zap_fma_ui(0x14u,0x17u,0x3u)};

- ::std::fprintf(stderr,"val: %u\n",val);

- assert(val == 0x59);

- }

- {

- auto val {::zap_fma_ul(0x5AAu,0x412u,0x16Du)};

- ::std::fprintf(stderr,"val: %lu\n",val);

- assert(val == 0x5D354u);

- }

- {

- auto val {::zap_fma_ull(0x10EFC7u,0x19FB63u,0x1133259u)};

- ::std::fprintf(stderr,"val: %llu\n",val);

- assert(val == 0x1BEE278BAB32u);

- }

- {

- auto val {::zap_fma_us(0x23u,0x19u,0x1Cu)};

- ::std::fprintf(stderr,"val: %u\n",val);

- assert(val == 0x2DF);

- }

- }

- ::std::fprintf(stderr,"\n");

- {

- constexpr ::std::size_t arrsz {0x8u};

- ::std::uint_least64_t arr0[arrsz] {0x0u};

- ::zap_memfill(arr0,arrsz * sizeof (::std::uint_least64_t),0x0u);

- ::std::fprintf(stderr,"arr0[0]: %" PRIXLEAST64 "\n",arr0[0x0u]);

- ::std::fprintf(stderr,"arr0[1]: %" PRIXLEAST64 "\n",arr0[0x1u]);

- ::std::fprintf(stderr,"arr0[2]: %" PRIXLEAST64 "\n",arr0[0x2u]);

- ::std::fprintf(stderr,"arr0[3]: %" PRIXLEAST64 "\n",arr0[0x3u]);

- ::std::fprintf(stderr,"arr0[4]: %" PRIXLEAST64 "\n",arr0[0x4u]);

- ::std::fprintf(stderr,"arr0[5]: %" PRIXLEAST64 "\n",arr0[0x5u]);

- ::std::fprintf(stderr,"arr0[6]: %" PRIXLEAST64 "\n",arr0[0x6u]);

- assert(arr0[0x0u] == 0x0u);

- assert(arr0[0x1u] == 0x0u);

- assert(arr0[0x2u] == 0x0u);

- assert(arr0[0x3u] == 0x0u);

- assert(arr0[0x4u] == 0x0u);

- assert(arr0[0x5u] == 0x0u);

- assert(arr0[0x6u] == 0x0u);

- ::zap_memfill(arr0,arrsz * sizeof (::std::uint_least64_t),0x7Fu);

- ::std::fprintf(stderr,"arr0[0]: %" PRIXLEAST64 "\n",arr0[0x0u]);

- ::std::fprintf(stderr,"arr0[1]: %" PRIXLEAST64 "\n",arr0[0x1u]);

- ::std::fprintf(stderr,"arr0[2]: %" PRIXLEAST64 "\n",arr0[0x2u]);

- ::std::fprintf(stderr,"arr0[3]: %" PRIXLEAST64 "\n",arr0[0x3u]);

- ::std::fprintf(stderr,"arr0[4]: %" PRIXLEAST64 "\n",arr0[0x4u]);

- ::std::fprintf(stderr,"arr0[5]: %" PRIXLEAST64 "\n",arr0[0x5u]);

- ::std::fprintf(stderr,"arr0[6]: %" PRIXLEAST64 "\n",arr0[0x6u]);

- assert(arr0[0x0u] == 0x7F7F7F7F7F7F7F7Fu);

- assert(arr0[0x1u] == 0x7F7F7F7F7F7F7F7Fu);

- assert(arr0[0x2u] == 0x7F7F7F7F7F7F7F7Fu);

- assert(arr0[0x3u] == 0x7F7F7F7F7F7F7F7Fu);

- assert(arr0[0x4u] == 0x7F7F7F7F7F7F7F7Fu);

- assert(arr0[0x5u] == 0x7F7F7F7F7F7F7F7Fu);

- assert(arr0[0x6u] == 0x7F7F7F7F7F7F7F7Fu);

- ::std::uint_least64_t arr1[arrsz] {0x0u};

- ::zap_memcpy(arr0,arrsz * sizeof (::std::uint_least64_t),arr1);

- ::std::fprintf(stderr,"arr1[0]: %" PRIXLEAST64 "\n",arr1[0x0u]);

- ::std::fprintf(stderr,"arr1[1]: %" PRIXLEAST64 "\n",arr1[0x1u]);

- ::std::fprintf(stderr,"arr1[2]: %" PRIXLEAST64 "\n",arr1[0x2u]);

- ::std::fprintf(stderr,"arr1[3]: %" PRIXLEAST64 "\n",arr1[0x3u]);

- ::std::fprintf(stderr,"arr1[4]: %" PRIXLEAST64 "\n",arr1[0x4u]);

- ::std::fprintf(stderr,"arr1[5]: %" PRIXLEAST64 "\n",arr1[0x5u]);

- ::std::fprintf(stderr,"arr1[6]: %" PRIXLEAST64 "\n",arr1[0x6u]);

- assert(arr1[0x0u] == arr0[0x0u]);

- assert(arr1[0x1u] == arr0[0x1u]);

- assert(arr1[0x2u] == arr0[0x2u]);

- assert(arr1[0x3u] == arr0[0x3u]);

- assert(arr1[0x4u] == arr0[0x4u]);

- assert(arr1[0x5u] == arr0[0x5u]);

- assert(arr1[0x6u] == arr0[0x6u]);

- auto const eq {::zap_memeq(arr1,arrsz,arr0)};

- ::std::fprintf(stderr,"eq: %u\n",eq);

- assert(eq);

- }

- ::std::fprintf(stderr,"\n");

- {

- auto const str {"Hello there! General Kenobi?"};

- ::std::fprintf(stderr,"str: \"%s\"\n",str);

- auto const strsz {::zap_strlen(str)};

- ::std::fprintf(stderr,"strsz: %zX\n",strsz);

- assert(strsz == 0x1Cu);

- }

- ::std::fprintf(stderr,"\n");

- {

- auto str {"Oh my science!"};

- ::std::fprintf(stderr,"str: \"%s\"\n",str);

- auto len {::zap_strlen(str)};

- ::std::fprintf(stderr,"len: %zX\n",len);

- ::std::size_t pos0 = ::zap_fndchr(str,' ');

- ::std::size_t pos1 = ::zap_fndbyte(str,len,(unsigned char)' ');

- ::std::fprintf(stderr,"pos0: %zX\n",pos0);

- ::std::fprintf(stderr,"pos1: %zX\n",pos1);

- assert(pos0 == 0x2u);

- assert(pos1 == pos0);

- str += pos0 + 0x1u;

- len = ::zap_strlen(str);

- pos0 = ::zap_fndchr(str,' ');

- pos1 = ::zap_fndbyte(str,len,(unsigned char)' ');

- ::std::fprintf(stderr,"pos0: %zX\n",pos0);

- ::std::fprintf(stderr,"pos1: %zX\n",pos1);

- assert(pos0 == 0x2u);

- assert(pos1 == pos0);

- str += pos0 + 0x1u;

- len = ::zap_strlen(str);

- pos0 = ::zap_fndchr(str,' ');

- pos1 = ::zap_fndbyte(str,len,(unsigned char)' ');

- ::std::fprintf(stderr,"pos0: %zX\n",pos0);

- ::std::fprintf(stderr,"pos1: %zX\n",pos1);

- assert(pos0 == SIZE_MAX);

- assert(pos1 == pos0);

- }

- ::std::fprintf(stderr,"\n");

- {

- char const str0[] = "What's up, my guy?";

- ::std::fprintf(stderr,"str0: \"%s\"\n",str0);

- char const str1[] = "What's up, my guy?";

- ::std::fprintf(stderr,"str1: \"%s\"\n",str1);

- char const str2[] = "I don't know you!";

- ::std::fprintf(stderr,"str2: \"%s\"\n",str2);

- bool const cmp0 = ::zap_streq(str0,str1);

- bool const cmp1 = ::zap_streq(str0,str2);

- bool const cmp2 = ::zap_streq(str1,str2);

- ::std::fprintf(stderr,"cmp0: %u\n",cmp0);

- ::std::fprintf(stderr,"cmp1: %u\n",cmp1);

- ::std::fprintf(stderr,"cmp2: %u\n",cmp2);

- assert(cmp0);

- assert(!cmp1);

- assert(!cmp2);

- }

- ::std::fprintf(stderr,"\n");

- {

- char const str0[] = "What in the world are you doing?";

- ::std::fprintf(stderr,"str0: \"%s\"\n",str0);

- char str1[sizeof (str0)];

- assert(::zap_strcpy(str0,str1) == 0x20u);

- ::std::fprintf(stderr,"str1: \"%s\"\n",str1);

- assert(::zap_streq(str0,str1));

- }

- ::std::fprintf(stderr,"\n");

- {

- char const str0[] {"Oej Moej Goejd"};

- char const str1[] {"Er jeg egentlig okay med AWP?"};

- ::std::fprintf(stderr,"str0: \"%s\"\n",str0);

- ::std::fprintf(stderr,"str1: \"%s\"\n",str1);

- auto const cmp0 {::zap_strcmp(str0,str1)};

- auto const cmp1 {::zap_strcmp(str0,str0)};

- auto const cmp2 {::zap_strcmp(str1,str0)};

- auto const leastsz {sizeof (str0) < sizeof (str1) ? sizeof (str0) : sizeof (str1)};

- auto const cmp3 {::zap_memcmp(str0,leastsz,str1)};

- auto const cmp4 {::zap_memcmp(str0,leastsz,str0)};

- auto const cmp5 {::zap_memcmp(str1,leastsz,str0)};

- ::std::fprintf(stderr,"cmp0: %i\n",cmp0);

- ::std::fprintf(stderr,"cmp1: %i\n",cmp1);

- ::std::fprintf(stderr,"cmp2: %i\n",cmp2);

- ::std::fprintf(stderr,"cmp3: %i\n",cmp3);

- ::std::fprintf(stderr,"cmp4: %i\n",cmp4);

- ::std::fprintf(stderr,"cmp5: %i\n",cmp5);

- assert(cmp0 > 0x0);

- assert(cmp1 == 0x0);

- assert(cmp2 < 0x0);

- assert(cmp3 > 0x0);

- assert(cmp4 == 0x0);

- assert(cmp5 < 0x0);

- }

- ::std::fprintf(stderr,"\n");

- {

- int arr[] {

- 0x0,

- 0x1,

- 0x2,

- 0x3,

- };

- void * rem {nullptr};

- ::zap_foreach(arr,sizeof (int),sizeof (arr) / sizeof (int),::zap_test_foreachfn);

- ::std::fprintf(stderr,"arr[0]: %i\n",arr[0x0u]);

- ::std::fprintf(stderr,"arr[1]: %i\n",arr[0x1u]);

- ::std::fprintf(stderr,"arr[2]: %i\n",arr[0x2u]);

- ::std::fprintf(stderr,"arr[3]: %i\n",arr[0x3u]);

- assert(arr[0x0u] == 0x0);

- assert(arr[0x1u] == 0x1);

- assert(arr[0x2u] == 0x0);

- assert(arr[0x3u] == 0x1);

- }

- ::std::fprintf(stderr,"\n");

- ::std::fprintf(stderr,"All tests have passed!\n");

-}

-# TOOLS

-

-#CC = clang

-#CC = gcc

-

-# TOOL FLAGS

-

-CFLAGS = \

- -Iinclude \

- -Iinclude-priv \

- -O3 \

- -fPIC \

- -g \

- -march=native \

- -std=c99 \

- -Wall \

- -Wextra \

- -Wpedantic

-

-# ARTIFACTS

-

-OBJS = \

- src/abs.o \

- src/fastimpl.o \

- src/fma.o \

- src/fndbyte.o \

- src/fndchr.o \

- src/foreach.o \

- src/memcmp.o \

- src/memcpy.o \

- src/memdup.o \

- src/memeq.o \

- src/memfill.o \

- src/strcmp.o \

- src/strdup.o \

- src/streq.o \

- src/strfill.o \

- src/strcpy.o \

- src/strlen.o

-

-LIB = libzap.a

-

-# OPTIONS

-

-# Uncomment to disable assembly algorithms:

-#CFLAGS += -Dzap_priv_noasm

-

-# Uncomment to enable freestanding mode (requries no runtime):

-#CFLAGS += \

- -Dzap_priv_nostdlib \

- -ffreestanding

-

-# TARGETS

-

-.PHONY: clean purge

-

-$(LIB): $(OBJS)

- ar r $@ $(OBJS)

-

-clean:

- rm -fr $(OBJS)

-

-purge: clean

- rm -fr $(LIB)

-#include <zap/base.h>

-#if (defined(sus_comp_gnu) || defined(sus_comp_llvm)) && defined(sus_os_unix) && !defined(zap_priv_noasm) && (defined(sus_arch_amd64) || defined(sus_arch_ia32))

-#define zap_priv_fastimpl (0x1u)

-#else

-#define zap_priv_fastimpl (0x0u)

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <stdbool.h>

-#include <susinfo.h>

-

-#if !defined(zap_priv_hdr_base)

-#define zap_priv_hdr_base

-

-#define zap_ver (0xFu)

-

-#if defined(sus_lang_cxx)

-extern "C" {

-#endif

-

-extern bool const zap_fastimpl;

-

-#if defined(sus_lang_cxx)

-}

-#endif

-

-#endif

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/base.h>

-

-#include <susinfo.h>

-

-#if !defined(zap_priv_hdr_math)

-#define zap_priv_hdr_math

-

-#if !defined(sus_langfeat_c_llng) && !defined(sus_langfeat_cxx_llng)

-#error The (long long) type is required but unsupported by the implementation !

-#endif

-

-#if defined(sus_lang_cxx)

-extern "C" {

-#endif

-

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret signed char zap_abs_c( signed char val);

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret int zap_abs_i( int val);

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret long zap_abs_l( long val);

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret long long zap_abs_ll( long long val);

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret short zap_abs_s( short val);

-

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret signed char zap_fma_c( signed char a,signed char b,signed char c);

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret int zap_fma_i( int a,int b,int c);

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret long zap_fma_l( long a,long b,long c);

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret long long zap_fma_ll( long long a,long long b,long long c);

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret short zap_fma_s( short a,short b,short c);

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret unsigned char zap_fma_uc( unsigned char a,unsigned char b,unsigned char c);

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret unsigned int zap_fma_ui( unsigned int a,unsigned int b,unsigned int c);

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret unsigned long zap_fma_ul( unsigned long a,unsigned long b,unsigned long c);

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret unsigned long long zap_fma_ull(unsigned long long a,unsigned long long b,unsigned long long c);

-sus_attr_const sus_attr_hot sus_attr_nothrw sus_attr_useret unsigned short zap_fma_us( unsigned short a,unsigned short b,unsigned short c);

-

-#if defined(sus_langfeat_c_generic)

-

-#define zap_abs_tg(_val) \

- (_Generic((_val), \

- signed char:zap_abs_c, \

- int: zap_abs_i, \

- long: zap_abs_l, \

- long long: zap_abs_ll,\

- short: zap_abs_s, \

- )((_val)))

-

-#define zap_fma_tg(_a,_b,_c) \

- (_Generic((_a), \

- signed char: zap_fma_c, \

- int: zap_fma_i, \

- long: zap_fma_l, \

- long long: zap_fma_ll, \

- short: zap_fma_s, \

- unsigned char: zap_fma_uc, \

- unsigned int: zap_fma_ui, \

- unsigned long: zap_fma_ul, \

- unsigned long long:zap_fma_ull,\

- unsigned short: zap_fma_us, \

- )((_a),(_b),(_c)))

-

-#elif defined(sus_lang_cxx)

-

-extern "C++" {

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline signed char zap_priv_cxxtg_abs(signed char const _val) {return ::zap_abs_c( _val);};

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline int zap_priv_cxxtg_abs(int const _val) {return ::zap_abs_i( _val);};

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline long zap_priv_cxxtg_abs(long const _val) {return ::zap_abs_l( _val);};

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline long long zap_priv_cxxtg_abs(long long const _val) {return ::zap_abs_ll(_val);};

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline short zap_priv_cxxtg_abs(short const _val) {return ::zap_abs_s( _val);};

-

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline signed char zap_priv_cxxtg_fma(signed char const _a,signed char const _b,signed char const _c) {return ::zap_fma_c( _a,_b,_c);};

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline int zap_priv_cxxtg_fma(int const _a,int const _b,int const _c) {return ::zap_fma_i( _a,_b,_c);};

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline long zap_priv_cxxtg_fma(long const _a,long const _b,long const _c) {return ::zap_fma_l( _a,_b,_c);};

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline long long zap_priv_cxxtg_fma(long long const _a,long long const _b,long long const _c) {return ::zap_fma_ll( _a,_b,_c);};

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline short zap_priv_cxxtg_fma(short const _a,short const _b,short const _c) {return ::zap_fma_s( _a,_b,_c);};

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline unsigned char zap_priv_cxxtg_fma(unsigned char const _a,unsigned char const _b,unsigned char const _c) {return ::zap_fma_uc( _a,_b,_c);};

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline unsigned int zap_priv_cxxtg_fma(unsigned int const _a,unsigned int const _b,unsigned int const _c) {return ::zap_fma_ui( _a,_b,_c);};

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline unsigned long zap_priv_cxxtg_fma(unsigned long const _a,unsigned long const _b,unsigned long const _c) {return ::zap_fma_ul( _a,_b,_c);};

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline unsigned long long zap_priv_cxxtg_fma(unsigned long long const _a,unsigned long long const _b,unsigned long long const _c) {return ::zap_fma_ull(_a,_b,_c);};

- sus_attr_const sus_attr_inline sus_attr_useret sus_inline unsigned short zap_priv_cxxtg_fma(unsigned short const _a,unsigned short const _b,unsigned short const _c) {return ::zap_fma_us( _a,_b,_c);};

-}

-

-#define zap_abs_tg(_val) (::zap_priv_cxxtg_abs( _val))

-#define zap_fma_tg(_a, _b,_c) (::zap_priv_cxxtg_fma(_a, _b,_c))

-

-#endif

-

-#if defined(sus_lang_cxx)

-}

-#endif

-

-#endif

-#include <zap/base.h>

-

-#include <stdbool.h>

-#include <stddef.h>

-#include <stdint.h>

-#include <susinfo.h>

-

-#if defined(sus_lang_asm)

-

-.extern zap_fndbyte

-.extern zap_fndchr

-.extern zap_foreach

-.extern zap_memcmp

-.extern zap_memcpy

-.extern zap_memeq

-.extern zap_memfill

-.extern zap_memfill

-.extern zap_strcmp

-.extern zap_strcpy

-.extern zap_streq

-.extern zap_strfill

-.extern zap_strlen

-

-#else

-sus_attr_hot sus_attr_nothrw sus_attr_useret size_t zap_fndbyte( void const * ptr, size_t num, unsigned char byte);

-sus_attr_hot sus_attr_nothrw sus_attr_useret size_t zap_fndchr( char const * str, char chr);

-sus_attr_hot void zap_foreach( void * ptr, size_t sz, size_t num, void (* fn)(void *));

-sus_attr_hot sus_attr_nothrw sus_attr_useret int_least8_t zap_memcmp( void const * lstr,size_t num, void const * rstr);

-sus_attr_hot sus_attr_nothrw void zap_memcpy( void const * in, size_t num, void * out);

-sus_attr_alloc sus_attr_allocsz(0x2) sus_attr_hot sus_attr_nothrw sus_attr_useret void * zap_memdup( void const * ptr, size_t num);

-sus_attr_hot sus_attr_nothrw sus_attr_useret bool zap_memeq( void const * lptr,size_t num, void const * rptr);

-sus_attr_hot sus_attr_nothrw void zap_memfill( void * ptr, size_t num, unsigned char val);

-sus_attr_hot sus_attr_nothrw sus_attr_useret int_least8_t zap_strcmp( char const * lstr,char const * rstr);

-sus_attr_hot sus_attr_nothrw sus_attr_useret size_t zap_strcpy( char const * in, char * out);

-sus_attr_alloc sus_attr_hot sus_attr_nothrw sus_attr_useret char * zap_strdup( char const * str);

-sus_attr_hot sus_attr_nothrw sus_attr_useret bool zap_streq( char const * lstr,char const * rstr);

-sus_attr_hot sus_attr_nothrw void zap_strfill( char * lstr,char chr);

-sus_attr_hot sus_attr_nothrw sus_attr_useret size_t zap_strlen( char const * str);

-#endif

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/priv.h>

-

-#include <zap/math.h>

-

-#include <stdint.h>

-

-#if zap_priv_fastimpl

-__asm__ (

- ".globl zap_abs_c\n"

- ".globl zap_abs_i\n"

- ".globl zap_abs_l\n"

- ".globl zap_abs_ll\n"

- ".globl zap_abs_s\n"

-

- "zap_abs_c:\n"

- /*

- signed char val

- */

-#if defined(sus_arch_amd64) || defined(sus_arch_ia32)

- "movb %dil,%al\n"

- "sarb $0x3F,%al\n"

- "xorb %al,%dil\n"

- "subb %al,%dil\n"

- "movb %dil,%al\n"

- "ret\n"

-#endif

-

- "zap_abs_i:\n"

- /*

- int val

- */

-#if defined(sus_arch_amd64) || defined(sus_arch_ia32)

- "movl %edi,%eax\n"

- "sarl $0x3F,%eax\n"

- "xorl %eax,%edi\n"

- "subl %eax,%edi\n"

- "movl %edi,%eax\n"

- "ret\n"

-#endif

-

- "zap_abs_l:\n"

- /*

- long val

- */

-#if defined(sus_arch_amd64)

- "movq %rdi,%rax\n"

- "sarq $0x3F,%rax\n"

- "xorq %rax,%rdi\n"

- "subq %rax,%rdi\n"

- "movq %rdi,%rax\n"

- "ret\n"

-#endif

-

- "zap_abs_ll:\n"

- /*

- long long val

- */

-#if defined(sus_arch_amd64)

- "movq %rdi,%rax\n"

- "sarq $0x3F,%rax\n"

- "xorq %rax,%rdi\n"

- "subq %rax,%rdi\n"

- "movq %rdi,%rax\n"

- "ret\n"

-#endif

-

- "zap_abs_s:\n"

- /*

- short val

- */

-#if defined(sus_arch_amd64) || defined(sus_arch_ia32)

- "movw %di,%ax\n"

- "sarw $0x3F,%ax\n"

- "xorw %ax,%di\n"

- "subw %ax,%di\n"

- "movw %di,%ax\n"

- "ret\n"

-#endif

-);

-#else

-#define zap_local_abs(_typ,_sufx) \

- _typ zap_abs_ ## _sufx (_typ const _val) {return _val > (_typ)0x0 ? _val : -_val;}

-

-zap_local_abs(signed char,c)

-zap_local_abs(int,i)

-zap_local_abs(long,l)

-zap_local_abs(long long,ll)

-zap_local_abs(short,s)

-

-#endif

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/priv.h>

-

-#include <stdbool.h>

-#include <stdint.h>

-

-bool const zap_fastimpl = zap_priv_fastimpl;

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/priv.h>

-

-#include <zap/math.h>

-

-#include <stdint.h>

-

-#if zap_priv_fastimpl

-__asm__ (

- ".globl zap_fma_c\n"

- ".globl zap_fma_i\n"

- ".globl zap_fma_l\n"

- ".globl zap_fma_ll\n"

- ".globl zap_fma_s\n"

- ".globl zap_fma_uc\n"

- ".globl zap_fma_ui\n"

- ".globl zap_fma_ul\n"

- ".globl zap_fma_ull\n"

- ".globl zap_fma_us\n"

-

- "zap_fma_c:\n"

- /*

- signed char a

- signed char b

- signed char c

- */

-#if defined(sus_arch_amd64)

- "movb %sil,%al\n"

- "imulb %dl\n"

- "addb %dil,%al\n"

- "ret\n"

-#endif

-

- "zap_fma_i:\n"

- /*

- int a

- int b

- int c

- */

-#if defined(sus_arch_amd64)

- "movl %edx,%eax\n"

- "imull %esi\n"

- "addl %edi,%eax\n"

- "ret\n"

-#endif

-

- "zap_fma_l:\n"

- /*

- long a

- long b

- long c

- */

-#if defined(sus_arch_amd64)

- "movq %rdx,%rax\n"

- "imulq %rsi\n"

- "addq %rdi,%rax\n"

- "ret\n"

-#endif

-

- "zap_fma_ll:\n"

- /*

- long long a

- long long b

- long long c

- */

-#if defined(sus_arch_amd64)

- "movq %rdx,%rax\n"

- "imulq %rsi\n"

- "addq %rdi,%rax\n"

- "ret\n"

-#endif

-

- "zap_fma_s:\n"

- /*

- short a

- short b

- short c

- */

-#if defined(sus_arch_amd64)

- "movw %dx,%ax\n"

- "imulw %si\n"

- "addw %di,%ax\n"

- "ret\n"

-#endif

-

- "zap_fma_uc:\n"

- /*

- unsigned char a

- unsigned char b

- unsigned char c

- */

-#if defined(sus_arch_amd64)

- "movb %sil,%al\n" /* mulb uses ax instead of al:dl (like the other variants), so we don't need to worry about it overwritting dl. */

- "mulb %dl\n"

- "addb %dil,%al\n"

- "ret\n"

-#endif

-

- "zap_fma_ui:\n"

- /*

- unsigned int a

- unsigned int b

- unsigned int c

- */

-#if defined(sus_arch_amd64)

- "movl %edx,%eax\n"

- "mull %esi\n"

- "addl %edi,%eax\n"

- "ret\n"

-#endif

-

- "zap_fma_ul:\n"

- /*

- unsigned long a

- unsigned long b

- unsigned long c

- */

-#if defined(sus_arch_amd64)

- "movq %rdx,%rax\n"

- "mulq %rsi\n"

- "addq %rdi,%rax\n"

- "ret\n"

-#endif

-

- "zap_fma_ull:\n"

- /*

- unsigned long long a

- unsigned long long b

- unsigned long long c

- */

-#if defined(sus_arch_amd64)

- "movq %rdx,%rax\n" /* rdx get overwritten by mulq, so might as well just make it the first operand (in multiplication, the order is meaningless). */

- "mulq %rsi\n"

- "addq %rdi,%rax\n"

- "ret\n"

-#endif

-

- "zap_fma_us:\n"

- /*

- unsigned short a

- unsigned short b

- unsigned short c

- */

-#if defined(sus_arch_amd64)

- "movw %dx,%ax\n"

- "mulw %si\n"

- "addw %di,%ax\n"

- "ret\n"

-#endif

-);

-#else

-#define zap_local_fma(_typ,_sufx) \

- _typ zap_fma_ ## _sufx (_typ const _a,_typ const _b,_typ const _c) {return _a + _b * _c;}

-

-zap_local_fma(signed char,c)

-zap_local_fma(int,i)

-zap_local_fma(long,l)

-zap_local_fma(long long,ll)

-zap_local_fma(short,s)

-zap_local_fma(unsigned char,uc)

-zap_local_fma(unsigned int,ui)

-zap_local_fma(unsigned long,ul)

-zap_local_fma(unsigned long long,ull)

-zap_local_fma(unsigned short,us)

-

-#endif

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/priv.h>

-

-#include <zap/mem.h>

-

-#include <stddef.h>

-#include <stdint.h>

-

-#if zap_priv_fastimpl

-__asm__ (

- ".globl zap_fndbyte\n"

-

- "zap_fndbyte:\n"

- /*

- void const * pos

- size_t num

- unsigned char byte

- */

-#if defined(sus_arch_amd64)

- /* rax: Address of the current element. */

- "movq %rdi,%rax\n"

- /* rsi: Address of the element after the last element. */

- "addq %rdi,%rsi\n"

- /* rcx: Current element. */

- ".loop:\n"

- "cmpq %rax,%rsi\n"

- "je .nfnd\n" /* We have went through the entire array without finding the byte. */

- "movb (%rax),%cl\n"

- "cmpb %cl,%dl\n"

- "je .fnd\n" /* We have found the byte. */

- "incq %rax\n"

- "jmp .loop\n"

- ".fnd:\n"

- "subq %rdi,%rax\n"

- "ret\n"

- ".nfnd:\n"

- "movq $0xFFFFFFFFFFFFFFFF,%rax\n"

- "ret\n"

-#elif defined(sus_arch_ia32)

- /* eax: Address of the current element. */

- "movl 0x4(%esp),%eax\n"

- /* ecx: Address of the element after the last element. */

- "movl 0x8(%esp),%ecx\n"

- "addl %eax,%ecx\n"

- /* edx: Byte value. */

- "movb 0xC(%esp),%dl\n"

- /* ebx: Current element. */

- "pushl %ebx\n"

- ".loop:\n"

- "cmpl %eax,%ecx\n"

- "je .nfnd\n" /* We have went through the entire array without finding the byte. */

- "movb (%eax),%bl\n"

- "cmpb %bl,%dl\n"

- "je .fnd\n" /* We have found the byte. */

- "incl %eax\n"

- "jmp .loop\n"

- ".fnd:\n"

- "popl %ebx\n"

- "subl 0x4(%esp),%eax\n"

- "ret\n"

- ".nfnd:\n"

- "popl %ebx\n"

- "movl $0xFFFFFFFF,%eax\n"

- "ret\n"

-#endif

-);

-#else

-size_t zap_fndbyte(void const * const _ptr,size_t const _num,unsigned char const _byte) {

- unsigned char const * startpos = _ptr;

- unsigned char const * pos = startpos;

- unsigned char const * const afterbuf = pos + _num;

- for (;pos != afterbuf;++pos) {sus_unlikely (*pos == _byte) {return pos - startpos;}}

- return SIZE_MAX;

-}

-#endif

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/priv.h>

-

-#include <zap/mem.h>

-

-#include <stddef.h>

-#include <stdint.h>

-

-#if zap_priv_fastimpl

-__asm__ (

- ".globl zap_fndchr\n"

-

- "zap_fndchr:\n"

- /*

- char const * str

- char chr

- */

-#if defined(sus_arch_amd64)

- /* rax: Address of the current character. */

- "movq %rdi,%rax\n"

- /* rdx: Current character. */

- ".loop:\n"

- "movb (%rax),%dl\n"

- "cmpb %dl,%sil\n"

- "je .fnd\n" /* Exit loop if we have found the character. */

- "testb %dl,%dl\n"

- "je .nfnd\n" /* We encountered the null-terminator but not the specified character. */

- "incq %rax\n"

- "jmp .loop\n"

- ".fnd:\n"

- "subq %rdi,%rax\n"

- "ret\n"

- ".nfnd:\n"

- "movq $0xFFFFFFFFFFFFFFFF,%rax\n"

- "ret\n"

-#elif defined(sus_arch_ia32)

- /* eax: Address of the current character. */

- "movl 0x4(%esp),%eax\n"

- /* ecx: Character. */

- "movb 0x8(%esp),%cl\n"

- /* edx: Current character. */

- ".loop:\n"

- "movb (%eax),%dl\n"

- "cmpb %dl,%cl\n"

- "je .fnd\n" /* Exit loop if we have found the character. */

- "testb %dl,%dl\n"

- "je .nfnd\n" /* We encountered the null-terminator but not the specified character. */

- "incl %eax\n"

- "jmp .loop\n"

- ".fnd:\n"

- "subl 0x4(%esp),%eax\n"

- "ret\n"

- ".nfnd:\n"

- "movl $0xFFFFFFFF,%eax\n"

- "ret\n"

-#endif

-);

-#else

-size_t zap_fndchr(char const * const _str,char const _chr) {

- char const * pos = _str;

- for (;;++pos) {

- char const chr = *pos;

- sus_unlikely (chr == _chr) {return (size_t)(pos - _str);}

- sus_unlikely (chr == '\x0') {return SIZE_MAX;}

- }

- sus_unreach();

-}

-#endif

-#include <stdlib.h>

-char * zap_strdup(sus_attr_unused char const * const _str) {

-#if !defined(zap_priv_nostdlib)

- return zap_memdup(_str,zap_strlen(_str) + 0x1u);

-#else

- return NULL;

-#endif

-#include <stddef.h>

-

-int_least8_t zap_memcmp(void const * const _lstr,size_t const _num,void const * const _rstr) {

- sus_likely (lbyte != rbyte) {return lbyte < rbyte ? INT_LEAST8_MIN : INT_LEAST8_MAX;}

- return 0x0;

-void zap_foreach(void * const _ptr,size_t const _sz,size_t const _num,void (* const _fn)(void *)) {

- unsigned char * pos = _ptr;

- size_t const numbyte = _sz * _num;

- unsigned char * const afterbuf = pos + numbyte;

- for (;pos != afterbuf;pos += _sz) {_fn(pos);}

-int_least8_t zap_strcmp(char const * const _lstr,char const * const _rstr) {

- sus_likely (lchr != rchr) {return lchr < rchr ? INT_LEAST8_MIN : INT_LEAST8_MAX;}

- sus_unlikely (lchr == (unsigned char)0x0) {return 0x0;}

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/priv.h>

-

-#include <zap/mem.h>

-

-#include <stddef.h>

-#include <stdint.h>

-

-#if zap_priv_fastimpl

-__asm__ (

- ".globl zap_memcpy\n"

-

- "zap_memcpy:\n"

- /*

- void const * in

- size_t num

- void * out

- */

-#if defined(sus_arch_amd64)

- /* rdi: Address of the current input element. */

- /* rsi: Number of remaining elements. */

- /* rdx: Address of the current output element. */

- /* rcx: Current element. */

- /* xmm0: Current element. */

- /* ymm0: Current element. */

-#if defined(sus_archfeat_avx)

- ".big256cpy:\n"

- "cmpq $0x20,%rsi\n"

- "jl .big128cpy\n"

- "vmovups (%rdi),%ymm0\n"

- "vmovups %ymm0,(%rdx)\n"

- "addq $0x20,%rdi\n"

- "addq $0x20,%rdx\n"

- "subq $0x20,%rsi\n"

- "jmp .big256cpy\n"

-#endif

- ".big128cpy:\n"

- "cmpq $0x10,%rsi\n"

- "jl .wrdcpy\n"

- "movdqu (%rdi),%xmm0\n"

- "movdqu %xmm0,(%rdx)\n"

- "addq $0x10,%rdi\n"

- "addq $0x10,%rdx\n"

- "subq $0x10,%rsi\n"

- "jmp .big128cpy\n"

- ".wrdcpy:\n"

- "cmpq $0x8,%rsi\n"

- "jl .bytecpy\n"

- "movq (%rdi),%rcx\n"

- "movq %rcx,(%rdx)\n"

- "addq $0x8,%rdi\n"

- "addq $0x8,%rdx\n"

- "subq $0x8,%rsi\n"

- "jmp .wrdcpy\n"

- ".bytecpy:\n"

- "testq %rsi,%rsi\n"

- "jz .done\n"

- "movb (%rdi),%cl\n"

- "movb %cl,(%rdx)\n"

- "incq %rdi\n"

- "incq %rdx\n"

- "decq %rsi\n"

- "jmp .bytecpy\n"

- ".done:\n"

- "ret\n"

-#elif defined(sus_arch_ia32)

- /* eax: Address of the current input element. */

- "movl 0x4(%esp),%eax\n"

- /* ecx: Number of remaining elements. */

- "movl 0x8(%esp),%ecx\n"

- /* edx: Address of the current output element. */

- "movl 0xC(%esp),%edx\n"

- /* ebx: Current element. */

- "pushl %ebx\n" /* ebx must be restored. */

- /* xmm0: Current element. */

- /* ymm0: Current element. */

-#if defined(sus_archfeat_avx)

- ".big256cpy:\n"

- "cmpl $0x20,%ecx\n"

-#if defined(sus_archfeat_sse)

- "jl .big128cpy\n"

-#else

- "jl .wrdcpy\n"

-#endif

- "vmovdqu (%eax),%ymm0\n"

- "vmovdqu %ymm0,(%edx)\n"

- "addl $0x20,%eax\n"

- "addl $0x20,%edx\n"

- "subl $0x20,%ecx\n"

- "jmp .big256cpy\n"

-#endif

-#if defined(sus_archfeat_sse)

- ".big128cpy:\n"

- "cmpl $0x10,%ecx\n"

- "jl .wrdcpy\n"

-#if defined(sus_archfeat_sse2)

- "movdqu (%eax),%xmm0\n"

- "movdqu %xmm0,(%edx)\n"

-#else

- "movups (%eax),%xmm0\n"

- "movups %xmm0,(%edx)\n"

-#endif

- "addl $0x10,%eax\n"

- "addl $0x10,%edx\n"

- "subl $0x10,%ecx\n"

- "jmp .big128cpy\n"

-#endif

- ".wrdcpy:\n"

- "cmpl $0x4,%ecx\n"

- "jl .bytecpy\n"

- "movl (%eax),%ebx\n"

- "movl %ebx,(%edx)\n"

- "addl $0x4,%eax\n"

- "addl $0x4,%edx\n"

- "subl $0x4,%ecx\n"

- "jmp .wrdcpy\n"

- ".bytecpy:\n"

- "testl %ecx,%ecx\n"

- "jz .done\n"

- "movb (%eax),%bl\n"

- "movb %bl,(%edx)\n"

- "incl %eax\n"

- "incl %edx\n"

- "decl %ecx\n"

- "jmp .bytecpy\n"

- ".done:\n"

- "popl %ebx\n"

- "ret\n"

-#endif

-);

-#else

-void zap_memcpy(void const * const _in,size_t const _num,void * const _out) {

- unsigned char const * in = _in;

- unsigned char * out = _out;

- unsigned char const * const afterbuf = in + _num;

- for (;in != afterbuf;++in,++out) {*out = *in;}

-}

-#endif

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/priv.h>

-

-#include <zap/mem.h>

-

-#include <stdlib.h>

-

-void * zap_memdup(sus_attr_unused void const * const _ptr,sus_attr_unused size_t const _num) {

-#if !defined(zap_priv_nostdlib)

- void * const dup = malloc(_num);

- sus_unlikely (dup == NULL) {return NULL;}

- zap_memcpy(_ptr,_num,dup);

- return dup;

-#else

- return NULL;

-#endif

-}

-

-

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/priv.h>

-

-#include <zap/mem.h>

-

-#include <stdbool.h>

-#include <stddef.h>

-#include <stdint.h>

-

-#if zap_priv_fastimpl

-__asm__ (

- ".globl zap_memeq\n"

-

- "zap_memeq:\n"

- /*

- void const * lptr

- size_t num

- void const * rptr

- */

-#if defined(sus_arch_amd64)

- /* rdi: Address of the current left element. */

- /* rsi: Number of remaining elements. */

- /* rdx: Address of the current right element. */

- /* rax: Current left element. */

- /* rcx: Current right element. */

- ".wrdcmp:\n"

- "cmpq $0x8,%rsi\n"

- "jl .bytecmp\n"

- "movq (%rdi),%rax\n"

- "movq (%rdx),%rcx\n"

- "cmpq %rax,%rcx\n"

- "jne .neq\n"

- "addq $0x8,%rdi\n"

- "addq $0x8,%rdx\n"

- "subq $0x8,%rsi\n"

- "jmp .wrdcmp\n"

- ".bytecmp:\n"

- "testq %rsi,%rsi\n"

- "jne .eq\n" /* If we have reached the final element, all previous elements have compared equal, and the memory sequences are equal. */

- "movb (%rdi),%al\n"

- "movb (%rdx),%cl\n"

- "cmpb %al,%cl\n"

- "jne .neq\n"

- "incq %rdi\n"

- "incq %rdx\n"

- "decq %rsi\n"

- "jmp .bytecmp\n"

- ".eq:\n"

- "movb $0x1,%al\n"

- "ret\n"

- ".neq:\n"

- "movb $0x0,%al\n"

- "ret\n"

-#elif defined(sus_arch_ia32)

- /* eax: Address of the current left element. */

- "movl 0x4(%esp),%eax\n"

- /* ecx: Number of remaining elements. */

- "movl 0x8(%esp),%ecx\n"

- /* edx: Address of the current right element. */

- "movl 0xC(%esp),%edx\n"

- /* ebx: Current left element. */

- "pushl %ebx\n"

- /* ebx/esi: Current right element. */

- "pushl %esi\n"

- ".wrdcmp:\n"

- "cmpl $0x4,%ecx\n"

- "jl .bytecmp\n"

- "movl (%eax),%ebx\n"

- "movl (%edx),%esi\n"

- "cmpl %ebx,%esi\n"

- "jne .neq\n"

- "addl $0x4,%eax\n"

- "addl $0x4,%edx\n"

- "subl $0x4,%ecx\n"

- "jmp .wrdcmp\n"

- ".bytecmp:\n"

- "testl %ecx,%ecx\n"

- "jne .eq\n" /* If we have reached the final element, all previous elements have compared equal, and the memory sequences are equal. */

- "movb (%eax),%bl\n"

- "movb (%edx),%bh\n"

- "cmpb %bl,%bh\n"

- "jne .neq\n"

- "incl %eax\n"

- "incl %edx\n"

- "decl %ecx\n"

- "jmp .bytecmp\n"

- ".eq:\n"

- "popl %ebx\n"

- "popl %esi\n"

- "movb $0x1,%al\n"

- "ret\n"

- ".neq:\n"

- "popl %ebx\n"

- "popl %esi\n"

- "movb $0x0,%al\n"

- "ret\n"

-#endif

-);

-#else

-bool zap_memeq(void const * const _lptr,size_t const _num,void const * const _rptr) {

- unsigned char const * lpos = _lptr;

- unsigned char const * rpos = _rptr;

- unsigned char const * const afterbuf = lpos + _num;

- for (;lpos != afterbuf;++lpos,++rpos) {sus_likely (*lpos != *rpos) {return false;}}

- return true;

-}

-#endif

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/priv.h>

-

-#include <zap/mem.h>

-

-#include <stddef.h>

-#include <stdint.h>

-

-#if zap_priv_fastimpl

-__asm__ (

- ".globl zap_memfill\n"

-

- "zap_memfill:\n"

- /*

- void const * ptr

- size_t num

- unsigned char val

- */

-#if defined(sus_arch_amd64)

- /* rdi: Address of the current element. */

- /* rsi: Address of the element after the last element. */

- "addq %rdi,%rsi\n"

- ".loop:\n"

- "cmpq %rdi,%rsi\n"

- "je .done\n" /* Exit loop if we have reached the final element. */

- "movb %dl,(%rdi)\n"

- "incq %rdi\n"

- "jmp .loop\n" /* Continue to next element. */

- ".done:\n"

- "ret\n"

-#elif defined(sus_arch_ia32)

- /* eax: Address of the current element. */

- "movl 0x4(%esp),%eax\n"

- /* ecx: Address of the element after the last element. */

- "movl 0x4(%esp),%ecx\n"

- "addl 0x8(%esp),%ecx\n"

- /* edx: Byte value. */

- "movb 0xC(%esp),%dl\n"

- ".loop:\n"

- "cmpl %eax,%ecx\n"

- "je .done\n" /* Exit loop if we have reached the final element. */

- "movb %dl,(%eax)\n"

- "incl %eax\n"

- "jmp .loop\n" /* Continue to next element. */

- ".done:\n"

- "ret\n"

-#endif

-);

-#else

-void zap_memfill(void * const _ptr,size_t const _num,unsigned char const _byte) {

- unsigned char * pos = _ptr;

- unsigned char * const afterbuf = pos + _num;

- for (;pos != afterbuf;++pos) {*pos = _byte;}

-}

-#endif

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/priv.h>

-

-#include <zap/mem.h>

-

-#include <stddef.h>

-

-#if zap_priv_fastimpl

-__asm__ (

- ".globl zap_strcpy\n"

-

- "zap_strcpy:\n"

- /*

- char const * in

- char const * out

- */

-#if defined(sus_arch_amd64)

- /* rax: Address of the current input character. */

- "movq %rdi,%rax\n"

- /* rsi: Address of the current output character. */

- "movq %rsi,%rsi\n"

- /* rdx: Current character. */

- ".loop:\n"

- "movb (%rax),%dl\n" /* Move current the character into a register... */

- "movb %dl,(%rsi)\n" /* ... and then back into memory. */

- "testb %dl,%dl\n" /* Check if we have reached the null-terminator... */

- "jz .done\n" /* ... and if so, we are finished copying. */

- "incq %rax\n" /* Increment the positions. */

- "incq %rsi\n"

- "jmp .loop\n" /* Restart the loop. */

- ".done:\n"

- "subq %rdi,%rax\n" /* Get the length of the string we copyied. */

- "decq %rdi\n" /* We do not count the null-terminator in the string length. */

- "ret\n"

-#elif defined(sus_arch_ia32)

- /* eax: Address of the current input character. */

- "movl 0x4(%esp),%eax\n"

- /* ecx: Address of the current output character. */

- "movl 0x8(%esp),%ecx\n"

- /* edx: Current character. */

- ".loop:\n"

- "movb (%eax),%dl\n" /* Move current the character into a register... */

- "movb %dl,(%ecx)\n" /* ... and then back into memory. */

- "testb %dl,%dl\n" /* Check if we have reached the null-terminator... */

- "jz .done\n" /* ... and if so, we are finished copying. */

- "incl %eax\n" /* Increment the positions. */

- "incl %ecx\n"

- "jmp .loop\n" /* Restart the loop. */

- ".done:\n"

- "subl 0x4(%esp),%eax\n" /* Get the length of the string we copyied. */

- "decl %ecx \n" /* We do not count the null-terminator in the string length. */

- "ret\n"

-#endif

-);

-#else

-size_t zap_strcpy(char const * const _in,char * const _out) {

- char const * inpos = _in;

- char * outpos = _out;

- for (;;++inpos,++outpos) {

- char const chr = *inpos;

- *outpos = chr;

- if (chr == '\x0') {return inpos - _in;}

- }

- sus_unreach();

-}

-#endif

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/priv.h>

-

-#include <zap/mem.h>

-

-#include <stdbool.h>

-#include <stdint.h>

-

-#if zap_priv_fastimpl

-__asm__ (

- ".globl zap_streq\n"

-

- "zap_streq:\n"

- /*

- char const * lstr

- char const * rstr

- */

-#if defined(sus_arch_amd64)

- /* rax: Address of the current input character. */

- "movq %rdi,%rax\n"

- /* rsi: Address of the current output character. */

- "movq %rsi,%rsi\n"

- /* rdx: Current input character. */

- /* rcx: Current output character. */

- ".loop:\n"

- "movb (%rax),%dl\n" /* Move the characters into registers. */

- "movb (%rsi),%cl\n"

- "cmpb %dl,%cl\n" /* Check if the characters are equal... */

- "jne .neq\n" /* ... indicate inequality if they are not. */

- "testb %dl,%dl\n" /* Check if we have reached the null-terminator... */

- "jz .eq\n" /* ... indicate equality if we have. */

- "incq %rax\n" /* Increment positions. */

- "incq %rsi\n"

- "jmp .loop\n" /* Restart loop. */

- ".eq:\n" /* Indicate equality. */

- "movb $0x1,%al\n"

- "ret\n"

- ".neq:\n" /* Indicate inequality. */

- "movb $0x0,%al\n"

- "ret\n"

-#elif defined(sus_arch_ia32)

- /* eax: Address of the current input character. */

- "movl 0x4(%esp),%eax\n"

- /* ecx: Address of the current output character. */

- "movl 0x8(%esp),%ecx\n"

- /* edx: Current input character. */

- /* edx: Current output character. */

- ".loop:\n"

- "movb (%eax),%dl\n" /* Move the characters into registers. */

- "movb (%ecx),%dh\n"

- "cmpb %dl,%dh\n" /* Check if the characters are equal... */

- "jne .neq\n" /* ... indicate inequality if they are not. */

- "testb %dl,%dl\n" /* Check if we have reached the null-terminator... */

- "jz .eq\n" /* ... indicate equality if we have. */

- "incl %eax\n" /* Increment positions. */

- "incl %ecx\n"

- "jmp .loop\n" /* Restart loop. */

- ".eq:\n" /* Indicate equality. */

- "movb $0x1,%al\n"

- "ret\n"

- ".neq:\n" /* Indicate inequality. */

- "movb $0x0,%al\n"

- "ret\n"

-#endif

-);

-#else

-bool zap_streq(char const * const _lstr,char const * const _rstr) {

- char const * lpos = _lstr;

- char const * rpos = _rstr;

- for (;;++lpos,++rpos) {

- char const lchr = *lpos;

- char const rchr = *rpos;

- sus_likely (lchr != rchr) {return false;}

- if (lchr == '\x0') {return true;}

- }

- sus_unreach();

-}

-#endif

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/priv.h>

-

-#include <zap/mem.h>

-

-#include <stdint.h>

-

-void zap_strfill(char * const _str,char const _chr) {zap_memfill(_str,zap_strlen(_str),(unsigned char)_chr);}

-/*

- Copyright 2022 Gabriel Jensen.

- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

- If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

-*/

-

-#include <zap/priv.h>

-

-#include <zap/mem.h>

-

-#include <stddef.h>

-

-#if zap_priv_fastimpl

-__asm__ (

- ".globl zap_strlen\n"

-

- "zap_strlen:\n"

- /*

- char const * str

- */

-#if defined(sus_arch_amd64)

- /* rax: Address of the current character. */

- "movq %rdi,%rax\n"

- /* rdx: Current character. */

- ".loop:\n"

- "movb (%rax),%dl\n"

- "testb %dl,%dl\n"

- "jz .done\n" /* Exit loop if we have reached the null-terminator. */

- "incq %rax\n" /* Continue to the next character. */

- "jmp .loop\n"

- ".done:\n"

- "subq %rdi,%rax\n"

- "ret\n"

-#elif defined(sus_arch_ia32)

- /* eax: Address of the current character. */

- "movl 0x4(%esp),%eax\n"

- /* ecx: Current character. */

- ".loop:\n"

- "movb (%eax),%cl\n"

- "testb %cl,%cl\n"

- "jz .done\n" /* Exit loop if we have reached the null-terminator. */

- "incl %eax\n" /* Continue to the next character. */

- "jmp .loop\n"

- ".done:\n"

- "subl 0x4(%esp),%eax\n"

- "ret\n"

-#endif

-);

-#else

-size_t zap_strlen(char const * const _str) {

- char const * pos = _str;

- for (;;++pos) {

- char const chr = *pos;

- sus_unlikely (chr == '\x0') {return (size_t)(pos - _str);}

- }

- sus_unreach();

-}

-#endif