-# Copyright 2022 Gabriel Jensen.

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

-ifneq "$(arch)" "amd64"

-$(error invalid architecture)

-# TOOLS

-

-#CC = clang

-#CC = gcc

-

-# TOOL FLAGS

-

-ASFLAGS := \

- -g \

- -march=native

-

-CFLAGS := \

- -Ofast \

- -Wall \

- -Wextra \

- -Wpedantic \

- -fPIC \

- -ffreestanding \

- -gdwarf-2 \

- -march=native \

- -std=c90

-

-CPPFLAGS := \

- -Iinclude \

- -Iinclude-private \

-

-# ARTEFACTS

-

-OBJS = \

- source/$(arch)/mem/memcnt.o \

- source/$(arch)/mem/memcp.o \

- source/$(arch)/mem/memeq.o \

- source/$(arch)/mem/memfill.o \

- source/$(arch)/mem/memfnd.o \

- source/$(arch)/mem/memfor.o \

- source/$(arch)/mem/memgen.o \

- source/$(arch)/mem/streq.o \

- source/$(arch)/mem/strfill.o \

- source/$(arch)/mem/strfnd.o \

- source/$(arch)/mem/strcp.o \

- source/$(arch)/mem/strlen.o \

- source/$(arch)/mem/utf20len.o \

- source/$(arch)/mem/utf8dec.o \

- source/$(arch)/mem/utf8declen.o \

- source/$(arch)/mem/utf8enc.o \

- source/$(arch)/mem/utf8enclen.o \

- source/$(arch)/mem/win1252dec.o \

- source/$(arch)/mem/win1252enc.o \

- source/$(arch)/mth/abs.o

-

-LIB = libzap.a

-

-# OPTIONS

-

-# TARGETS

-.PHONY: clean install purge

-install: $(LIB)

- mkdir -pm755 "$(HDRDIR)/zap"

- mkdir -pm755 "$(LIBDIR)"

- install -m644 "include/zap/"*".h" "$(HDRDIR)/zap"

- install -m755 "$(LIB)" "$(LIBDIR)"

-

-/*

- 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/.

-*/

-

-#if !defined(zap_priv_hdr_priv)

-#define zap_priv_hdr_priv

-

-#include <zap/bs.h>

-

-#endif

- Copyright 2022 Gabriel Jensen.

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

-extern "C" {

-typedef unsigned char zap_bool;

-#define zap_true ((zap_bool)+0xFFu)

-typedef unsigned short zap_chr10;

-typedef unsigned int zap_chr20;

-typedef unsigned char zap_chr8;

-typedef signed char zap_cmp;

-#define zap_eq ((zap_cmp)+0x0)

-#define zap_gt ((zap_cmp)+0x7F)

-#define zap_lt ((zap_cmp)-0x80)

-#define zap_nopos ((zap_sz)+0xFFFFFFFFFFFFFFFFu)

-#define zap_nullptr (0x0u)

-typedef unsigned long zap_sz;

-#define zap_ver ((unsigned long)+0x15u)

-#if defined(__cplusplus)

-}

- Copyright 2022 Gabriel Jensen.

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

-#if defined(__cplusplus)

-extern "C" {

-#endif

-typedef struct {

- void * ptr;

- zap_sz sz;

-} zap_mem;

-

-__attribute__ ((hot,warn_unused_result)) zap_sz zap_memcnt( void const * ptr, zap_sz sz, zap_sz num, zap_bool (* fn)(void const *));

-__attribute__ ((hot,nothrow)) zap_sz zap_memcp( void const * in, zap_sz num, void * out);

-__attribute__ ((hot,nothrow,warn_unused_result)) zap_bool zap_memeq( void const * lptr, zap_sz num, void const * rptr);

-__attribute__ ((hot,nothrow)) zap_sz zap_memfill( void * ptr, zap_sz num, unsigned char val);

-__attribute__ ((hot,nothrow,warn_unused_result)) zap_sz zap_memfnd( void const * ptr, zap_sz num, unsigned char byte);

-__attribute__ ((hot)) void zap_memfor( void * ptr, zap_sz sz, zap_sz num, void (* fn)(void *));

-__attribute__ ((hot)) void zap_memgen( void * ptr, zap_sz sz, zap_sz num, void (* fn)(zap_sz,void *));

-__attribute__ ((hot,nothrow)) zap_sz zap_strcp( char const * in, char * out);

-__attribute__ ((hot,nothrow,warn_unused_result)) zap_bool zap_streq( char const * lstr, char const * rstr);

-__attribute__ ((hot,nothrow)) zap_sz zap_strfill( char * lstr, char chr);

-__attribute__ ((hot,nothrow,warn_unused_result)) zap_sz zap_strfnd( char const * str, char chr);

-__attribute__ ((hot,nothrow,warn_unused_result)) zap_sz zap_strlen( char const * str);

-__attribute__ ((hot,nothrow,warn_unused_result)) zap_sz zap_utf20len( zap_chr20 const * utf20);

-__attribute__ ((hot,nothrow)) void zap_utf8dec( zap_chr8 const * in, zap_chr20 * out);

-__attribute__ ((hot,nothrow)) zap_sz zap_utf8declen(zap_chr8 const * utf8);

-__attribute__ ((hot,nothrow)) void zap_utf8enc( zap_chr20 const * in, zap_chr8 * out);

-__attribute__ ((hot,nothrow)) zap_sz zap_utf8enclen(zap_chr20 const * utf20);

-__attribute__ ((hot,nothrow)) void zap_win1252dec(zap_chr8 const * in, zap_chr20 * out);

-__attribute__ ((hot,nothrow)) void zap_win1252enc(zap_chr20 const * in, zap_chr8 * out);

-

-#if defined(__cplusplus)

-}

-#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/.

-*/

-

-#if !defined(zap_priv_hdr_mth)

-#define zap_priv_hdr_mth

-

-#include <zap/bs.h>

-

-#if defined(__cplusplus)

-extern "C" {

-#endif

-

-#define zap_minval_c ((char )-0x80)

-#define zap_minval_i ((int )-0x80000000)

-#define zap_minval_l ((long )-0x8000000000000000)

-#define zap_minval_ll ((long long )-0x8000000000000000)

-#define zap_minval_s ((short )-0x8000)

-#define zap_minval_sc ((signed char )-0x80)

-

-#define zap_maxval_sc ((char )+0x7F)

-#define zap_maxval_c ((int )+0x7FFFFFFF)

-#define zap_maxval_i ((int )+0x7FFFFFFF)

-#define zap_maxval_l ((long )+0x7FFFFFFFFFFFFFFF)

-#define zap_maxval_ll ((long long )+0x7FFFFFFFFFFFFFFF)

-#define zap_maxval_s ((short )+0x7FFF)

-#define zap_maxval_sc ((signed char )+0x7F)

-#define zap_maxval_uc ((unsigned char )+0xFFu)

-#define zap_maxval_ui ((unsigned int )+0xFFFFFFFFu)

-#define zap_maxval_ul ((unsigned long )+0xFFFFFFFFFFFFFFFFu)

-#define zap_maxval_ull ((unsigned long long)+0xFFFFFFFFFFFFFFFFu)

-#define zap_maxval_us ((unsigned short )+0xFFFFu)

-

-typedef struct {char div;char mod;} zap_divmod_c;

-typedef struct {int div;int mod;} zap_divmod_i;

-typedef struct {long div;long mod;} zap_divmod_l;

-typedef struct {long long div;long long mod;} zap_divmod_ll;

-typedef struct {short div;short mod;} zap_divmod_s;

-typedef struct {signed char div;signed char mod;} zap_divmod_sc;

-typedef struct {unsigned char div;unsigned char mod;} zap_divmod_uc;

-typedef struct {unsigned int div;unsigned int mod;} zap_divmod_ui;

-typedef struct {unsigned long div;unsigned long mod;} zap_divmod_ul;

-typedef struct {unsigned long long div;unsigned long long mod;} zap_divmod_ull;

-typedef struct {unsigned short div;unsigned short mod;} zap_divmod_us;

-

-typedef struct {char num;char den;} zap_frac_c;

-typedef struct {int num;int den;} zap_frac_i;

-typedef struct {long num;long den;} zap_frac_l;

-typedef struct {long long num;long long den;} zap_frac_ll;

-typedef struct {short num;short den;} zap_frac_s;

-typedef struct {signed char num;signed char den;} zap_frac_sc;

-typedef struct {unsigned char num;unsigned char den;} zap_frac_uc;

-typedef struct {unsigned int num;unsigned int den;} zap_frac_ui;

-typedef struct {unsigned long num;unsigned long den;} zap_frac_ul;

-typedef struct {unsigned long long num;unsigned long long den;} zap_frac_ull;

-typedef struct {unsigned short num;unsigned short den;} zap_frac_us;

-

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned char zap_abs_c( char val);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned int zap_abs_i( int val);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned long zap_abs_l( long val);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned long long zap_abs_ll(long long val);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned short zap_abs_s( short val);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned char zap_abs_sc(signed char val);

-

-__attribute__ ((const,hot,nothrow,warn_unused_result)) zap_divmod_c zap_div_c( char num,char den);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) zap_divmod_i zap_div_i( int num,int den);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) zap_divmod_l zap_div_l( long num,long den);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) zap_divmod_ll zap_div_ll( long long num,long long den);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) zap_divmod_s zap_div_s( short num,short den);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) zap_divmod_sc zap_div_sc( signed char num,signed char den);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) zap_divmod_uc zap_div_uc( unsigned char num,unsigned char den);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) zap_divmod_ui zap_div_ui( unsigned int num,unsigned int den);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) zap_divmod_ul zap_div_ul( unsigned long num,unsigned long den);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) zap_divmod_ull zap_div_ull(unsigned long long num,unsigned long long den);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) zap_divmod_us zap_div_us( unsigned short num,unsigned short den);

-

-__attribute__ ((const,hot,nothrow,warn_unused_result)) char zap_exp_c( char bs,unsigned char exp);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) int zap_exp_i( int bs,unsigned int exp);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) long zap_exp_l( long bs,unsigned long exp);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) long long zap_exp_ll( long long bs,unsigned long long exp);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) short zap_exp_s( short bs,unsigned short exp);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) signed char zap_exp_sc( signed char bs,unsigned char exp);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned char zap_exp_uc( unsigned char bs,unsigned char exp);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned int zap_exp_ui( unsigned int bs,unsigned int exp);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned long zap_exp_ul( unsigned long bs,unsigned long exp);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned long long zap_exp_ull(unsigned long long bs,unsigned long long exp);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned short zap_exp_us( unsigned short bs,unsigned short exp);

-

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned char zap_log_uc( unsigned char bs,unsigned char pow);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned int zap_log_ui( unsigned int bs,unsigned int pow);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned long zap_log_ul( unsigned long bs,unsigned long pow);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned long long zap_log_ull(unsigned long long bs,unsigned long long pow);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned short zap_log_us( unsigned short bs,unsigned short pow);

-

-__attribute__ ((const,hot,nothrow,warn_unused_result)) char zap_mul_c( char lfac,char rfac);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) int zap_mul_i( int lfac,int rfac);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) long zap_mul_l( long lfac,long rfac);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) long long zap_mul_ll( long long lfac,long long rfac);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) short zap_mul_s( short lfac,short rfac);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) signed char zap_mul_sc( signed char lfac,signed char rfac);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned char zap_mul_uc( unsigned char lfac,unsigned char rfac);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned int zap_mul_ui( unsigned int lfac,unsigned int rfac);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned long zap_mul_ul( unsigned long lfac,unsigned long rfac);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned long long zap_mul_ull(unsigned long long lfac,unsigned long long rfac);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned short zap_mul_us( unsigned short lfac,unsigned short rfac);

-

-__attribute__ ((const,hot,nothrow,warn_unused_result)) char zap_nrt_c( char deg,char rad);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) int zap_nrt_i( int deg,int rad);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) long zap_nrt_l( long deg,long rad);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) long long zap_nrt_ll( long long deg,long long rad);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) short zap_nrt_s( short deg,short rad);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) signed char zap_nrt_sc( signed char deg,signed char rad);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned char zap_nrt_uc( unsigned char deg,unsigned char rad);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned int zap_nrt_ui( unsigned int deg,unsigned int rad);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned long zap_nrt_ul( unsigned long deg,unsigned long rad);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned long long zap_nrt_ull(unsigned long long deg,unsigned long long rad);

-__attribute__ ((const,hot,nothrow,warn_unused_result)) unsigned short zap_nrt_us( unsigned short deg,unsigned short rad);

-

-#if defined(__cplusplus)

-}

-#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/.

-

-.globl zap_memcnt

-

-zap_memcnt:

-# Address of the current element:

-#define addr %rbx

-# Address of the element after the last input element:

-#define afterbuf %r12

-# Size of each input element:

-#define sz %r13

-# Address of the function:

-#define fn %r14

-# Count:

-#define cnt %r15

-

- # Push the callee-saved registers:

- pushq addr

- pushq afterbuf

- pushq sz

- pushq fn

- pushq cnt

-

- # Move registers into place:

- movq %rdi,addr

- movq %rsi,sz

- movq %rdx,afterbuf

- movq %rcx,fn

-

- # Get the one-past-the-end address:

- imulq sz,afterbuf # afterbuf *= sz

- addq addr,afterbuf # afterbuf += addr

-

- movq $0x0,cnt # cnt = 0x0

-

- # Iterate through the array:

-.loop:

-

- # Check if we have reached the one-past-the-end address:

- cmpq addr,afterbuf # if (addr == afterbuf)

- je .done # goto done

-

- # Call the provided function:

- movq addr,%rdi

- call *fn # fn(addr)

-

- # Check the return value of the function:

- testb %al,%al # if (fn(addr) == zap_false)

- jz .skip # goto skip

-

- incq cnt # ++cnt

-

- # Skip the incrementation:

-.skip:

-

- # Continue to the next element:

- addq sz,addr # addr += sz

- jmp .loop # goto loop

-

- # Finish:

-.done:

-

- # Move count into return register:

- movq cnt,%rax

-

- # Restore the callee-saved registers:

- popq cnt

- popq fn

- popq sz

- popq afterbuf

- popq addr

-

- ret # return cnt

-# 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/.

-

-.globl zap_memcp

-

-zap_memcp:

-# Address of the current input element:

-#define iaddr %rdi

-# Number of remaining bytes:

-#define rem %rsi

-# Address of the current output element:

-#define oaddr %rdx

-# Current element:

-#define val1 %cl

-#define val8 %rcx

-#define val01 %xmm0

-#define val02 %ymm0

-

-#if defined(__AVX__)

- # AVX support 256-bit moves.

-

- # Copy 32 bytes:

-.big02cp:

-

- # Check if there are at least 32 bytes remaining:

- cmpq $0x20,rem # if (rem < 20)

- jl .big01cp # goto big01cp // If not, skip to the 10 byte copying.

-

- # Copy:

- vmovups (iaddr),val02 # val02 = *iaddr

- vmovups val02,(oaddr) # *oaddr = val02

-

- # Continue:

- addq $0x20,iaddr # iaddr += 0x20

- addq $0x20,oaddr # oaddr += 0x20

- subq $0x20,rem # rem -= 0x20

- jmp .big02cp # goto big02cp

-

-#endif

-

- # AMD64 requires SSE(2), so we don't have to test it.

-

- # Copy 16 bytes:

-.big01cp:

-

- # Check if there are at least 16 bytes remaining:

- cmpq $0x10,rem # if (rem < 10)

- jl .wrdcp # goto wrdcp

-

- # Copy:

- movdqu (iaddr),val01 # val01 = *iaddr

- movdqu val01,(oaddr) # *oaddr = val01

-

- # Continue:

- addq $0x10,iaddr # iaddr += 0x10

- addq $0x10,oaddr # oaddr += 0x10

- subq $0x10,rem # rem -= 0x10

- jmp .big01cp # goto big01cp

-

- # Copy one word (8 bytes):

-.wrdcp:

-

- # Check if there are at least 8 bytes remaining:

- cmpq $0x8,rem # if (rem < 8)

- jl .bytecp # goto bytecp

-

- # Copy:

- movq (iaddr),val8 # val8 = *iaddr

- movq val8,(oaddr) # *oaddr = val8

-

- # Continue:

- addq $0x8,iaddr # iaddr += 0x8

- addq $0x8,oaddr # oaddr += 0x8

- subq $0x8,rem # rem -= 0x8

- jmp .wrdcp # goto wrdcp

-

- # Copy one byte:

-.bytecp:

-

- # Check if we have any bytes remaining:

- testq rem,rem # if (rem == 0x0)

- jz .done # goto done

-

- # Copy:

- movb (iaddr),val1 # val1 = *iaddr

- movb val1,(oaddr) # *oaddr = val1

-

- # Continue:

- incq iaddr # ++iaddr

- incq oaddr # ++oaddr

- decq rem # --rem

- jmp .bytecp # goto bytecp

-

- # Return:

-.done:

-

- ret # return

- \ No newline at end of file

-# 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/.

-

-.globl zap_memeq

-

-zap_memeq:

-# Left pointer:

-#define laddr %rdi

-# Number of remaining elements:

-#define rem %rsi

-# Right pointer:

-#define raddr %rdx

-# Current left element:

-#define lval8 %rax

-#define lval1 %al

-# Current right element:

-#define rval8 %rcx

-#define rval1 %cl

-

- # Compare words:

-.wrdcmp:

-

- # Check if there's at least one word left:

- cmpq $0x8,rem # if (rem == 8)

- jl .bytecmp # goto bytecmp

-

- # Copy the values into registers:

- movq (laddr),lval8 # lval8 = *laddr

- movq (raddr),rval8 # rval8 = *raddr

-

- # Check if the words are equal:

- cmpq lval8,rval8 # if (lval8 != rval8)

- jne .neq # goto neq

-

- # Mark eight more bytes as equal:

- addq $0x8,laddr # laddr += 0x8

- addq $0x8,raddr # raddr += 0x8

- subq $0x8,rem # rem -= 0x8

-

- # Continue to the next word:

- jmp .wrdcmp # goto wrdcmp

-

- # Compare bytes:

-.bytecmp:

-

- # Check if there are any bytes left:

- testq rem,rem # if (rem == 0x0)

- jz .eq # goto eq // If we have reached the final element, all previous elements have compared equal, and the memory sequences are equal.

-

- # Copy the values into registers:

- movb (laddr),lval1 # lval1 = *laddr

- movb (raddr),rval1 # rval1 = *raddr

-

- cmpb lval1,rval1 # if (lval1 != rval1)

- jne .neq # goto neq

-

- # Mark another byte as equal:

- incq laddr # ++laddr

- incq raddr # ++raddr

- decq rem # --rem

-

- # Continue to the next byte:

- jmp .bytecmp # goto bytecmp

-

- # The memory sequences have compared equal:

-.eq:

- movb $0xFF,%al

- ret # return FF

-

- # The memory sequences have compared NOT equal:

-.neq:

- movb $0x0,%al

- ret # return 0

-# 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/.

-

-.globl zap_memfill

-

-zap_memfill:

-# Address of the current element:

-#define addr %rdi

-# Address of the element after the last element:

-#define afterbuf %rsi

-# Byte value:

-#define val %dl

-

- addq addr,afterbuf # afterbuf += addr // afterbuf contains the number of bytes

-

- # Iterate over buffer:

-.loop:

-

- # Check if we have reached the final element:

- cmpq addr,afterbuf # if (addr == afterbuf)

- je .done # goto done

-

- # Set the value of the current element:

- movb val,(addr) # *addr = val

-

- # Continue to next element:

- incq addr # ++addr

- jmp .loop # goto loop

-

- # Finish:

-.done:

-

- ret # return

-# 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/.

-

-.globl zap_memfnd

-

-zap_memfnd:

-# Address of the current element:

-#define addr %rax

-# Address of the first element:

-#define start %rdi

-# Address of the element after the last element:

-#define afterbuf %rsi

-# Byte value:

-#define cmp %dl

-# Current byte:

-#define val %cl

-

- movq start,addr # addr = start

-

- addq start,afterbuf # afterbuf += start

-

- # Iterate over the array:

-.loop:

-

- # Check if we have reached the end of the array:

- cmpq addr,afterbuf # if (addr == afterbuf)

- je .nfnd # goto nfnd

-

- # Check if we have found the byte value:

- movb (addr),val # val = *addr

- cmpb val,cmp # if (val == cmp)

- je .fnd # goto fnd

-

- # Continue to the next byte:

- incq addr # ++addr

- jmp .loop # goto loop

-

- # Found:

-.fnd:

-

- # Get the offset of the byte:

- subq start,addr # addr -= start

- ret # return addr

-

- # Not found:

-.nfnd:

-

- movq $0xFFFFFFFFFFFFFFFF,addr # addr = 0xFFFFFFFFFFFFFFFF

- ret # return addr

-# 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/.

-

-.globl zap_memfor

-

-zap_memfor:

-# Address of the current element:

-#define addr %rbx

-# Address of the element after the last input element:

-#define afterbuf %r12

-# Size of each input element:

-#define sz %r13

-# Address of the function:

-#define fn %r14

-

- # We're gonna use callee-saved registers for storing values so they don't get overwritten with each function call.

-

- # Push the callee-saved registers:

- pushq addr

- pushq afterbuf

- pushq sz

- pushq fn

-

- # Move registers into place:

- movq %rdi,addr

- movq %rsi,sz

- movq %rdx,afterbuf

- movq %rcx,fn

-

- # Get the one-past-the-end address:

- imulq sz,afterbuf # afterbuf *= sz // Calculate the array size in bytes (sz * num). We're using signed multiply because the equivalent using the unsigned instruction would use more instructions.

- addq addr,afterbuf # afterbuf += addr

-

- # Iterate through the array:

-.loop:

-

- # Check if we have reached the one-past-the-end address:

- cmpq addr,afterbuf # if (addr == afterbuf)

- je .done # goto done

-

- # Call the provided function:

- movq addr,%rdi # // Provide the current address to the function.

- call *fn # fn(addr) // We don't need to save any registers for this as we only use callee-saved registers.

-

- # Continue to the next element:

- addq sz,addr # addr += sz

- jmp .loop # goto loop

-

- # Finish:

-.done:

-

- # Restore the callee-saved registers:

- popq fn

- popq sz

- popq afterbuf

- popq addr

-

- ret # return

-/*

- 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>

-

-void zap_memgen(void * const _ptr,zap_sz const _sz,zap_sz const _num,void (* const _fn)(zap_sz,void *)) {

- unsigned char * ptr = _ptr;

- unsigned char * const afterbuf = ptr + _sz * _num;

- for (;ptr != afterbuf;ptr += _sz) {_fn((ptr - (unsigned char *)_ptr) / _sz,ptr);}

-}

-

-# 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/.

-

-.globl zap_strcp

-

-zap_strcp:

-# Address of the current input character:

-#define iaddr %rax

-# Address of the first input character:

-#define start %rdi

-# Address of the current output character:

-#define oaddr %rsi

-# Current character:

-#define chr %dl

-

- movq start,iaddr

-

- # Iterate over the strings:

-.loop:

-

- # Copy character:

- movb (iaddr),chr # chr = *iaddr

- movb chr,(oaddr) # *oaddr = chr

-

- # Check if we have reached the null-terminator:

- testb chr,chr # if (chr == 0x0)

- jz .done # goto done

-

- # Continue to the next character:

-

- incq iaddr # ++iaddr

- incq oaddr # ++oaddr

- jmp .loop # goto loop

-

- # Finish:

-.done:

-

- # Get the length of the (input) string:

- subq start,iaddr # iaddr -= start

- decq iaddr # --iaddr // We do not count the null-terminator in the string length.

-

- ret # return iaddr

-# 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/.

-

-.globl zap_streq

-

-zap_streq:

-# Address of the current left character:

-#define laddr %rdi

-# Address of the current right character:

-#define raddr %rsi

-# Current left character:

-#define lchr %al

-# Current right character:

-#define rchr %dl

-

- # Iterate over the strings:

-.loop:

-

- # Copy the characters into registers:

- movb (laddr),lchr # lchr = *laddr

- movb (raddr),rchr # rchr = *raddr

-

- # Check if the characters are equal:

- cmpb lchr,rchr # if (lchr != rchr)

- jne .neq # goto neq // If not, the strings also aren't equal.

-

- # Check if we have reached the null-terminator:

- testb lchr,lchr # if (lchr == 0x0)

- jz .eq # goto eq // If so, all previous characters have compared equal, and the strings are equal.

-

- # Continue to the next characters:

- incq laddr # ++laddr

- incq raddr # ++raddr

- jmp .loop # goto loop

-

- # The strings have compared equal:

-.eq:

-

- movb $0xFF,%al

- ret # return FF

-

- # The strings have compared unequal:

-.neq:

-

- movb $0x0,%al

- ret # return 0

-# 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/.

-

-.globl zap_strfill

-

-zap_strfill:

-# Address of the current character:

-#define addr %rax

-# Address of the first character of the string:

-#define start %rdi

-# Fill character:

-#define chr %sil

-

- movq start,addr

-

- # Iterate over string:

-.loop:

-

- # Check if we have reached the null-terminator:

- cmpb $0x0,(addr) # if (*addr == 0x0)

- je .done # goto done

-

- # Set the value of the current element:

- movb chr,(addr) # *addr = chr

-

- # Continue to next character:

- incq addr # ++addr

- jmp .loop # goto loop

-

- # Finish:

-.done:

-

- # Get the length of the string:

- subq start,addr # addr -= start

-

- ret # return addr

-# 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/.

-

-.globl zap_strfnd

-

-zap_strfnd:

-# Address of the first character:

-#define start %rdi

-# Character to be found:

-#define cmp %sil

-# Address of the current character:

-#define addr %rax

-# Current character:

-#define chr %dl

-

- movq start,addr # addr = start

-

- # Iterate over the string:

-.loop:

-

- # Copy the character into a register:

- movb (addr),chr # chr = *addr

-

- # Check if we have found the character:

- cmpb chr,cmp # if (chr == cmp)

- je .fnd # goto fnd

-

- # Check if we have found the null-terminator:

- testb chr,chr # if (chr == 0x0)

- jz .nfnd # goto nfnd

-

- # Continue to the next character:

- incq addr # ++addr

- jmp .loop # goto loop

-

- # Found:

-.fnd:

-

- # Get the offset of the character:

- subq start,addr # addr -= start

- ret # return addr

-

- # Not found:

-.nfnd:

-

- movq $0xFFFFFFFFFFFFFFFF,addr # addr = 0xFFFFFFFFFFFFFFFF

- ret # return addr

-# 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/.

-

-.globl zap_strlen

-

-zap_strlen:

-# Address of the current character:

-#define addr %rax

-# Address of the first character:

-#define start %rdi

-# Current character:

-#define chr %dl

-

- movq start,addr

-

- # Iterate over the string:

-.loop:

-

- # Move the character into a register:

- movb (addr),chr # chr = *addr

-

- # Check if we have reached the null-terminator:

- testb chr,chr # if (chr == 0x0)

- jz .done # goto done

-

- # Continue to the next character:

- incq addr # ++addr

- jmp .loop # goto loop

-

- # Done:

-.done:

-

- # Get the length:

- subq start,addr # addr -= start

-

- ret # return addr

-# 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/.

-

-.globl zap_utf20len

-

-zap_utf20len:

-# Address of the current character:

-#define addr %rax

-# Address of the first character:

-#define start %rdi

-# Current character:

-#define chr %edx

-

- movq start,addr

-

- # Iterate over the string:

-.loop:

-

- # Move the character into a register:

- movl (addr),chr # chr = *addr

-

- # Check if we have reached the null-terminator:

- testl chr,chr # if (chr == 0x0)

- jz .done # goto done

-

- # Continue to the next character:

- addq $0x4,addr # addr += 0x4

- jmp .loop # goto loop

-

- # Done:

-.done:

-

- # Get the length:

- subq start,addr # addr -= start

- shrq $0x2,addr # addr /= 0x4 // Divide by four to get the number of doublewords rather than bytes.

-

- ret # return addr

-/*

- 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>

-

-void zap_utf8dec(zap_chr8 const * const _in,zap_chr20 * const _out) {

- zap_chr8 const * in = _in;

- zap_chr20 * out = _out;

- for (;;++out) {

- zap_chr8 const oct = *in;

- if (oct >= 0xF0u) { /* Four octets. */

- zap_chr20 chr = ((zap_chr20)oct ^ 0xF0u) << 0x12u;

- ++in;

- chr += ((zap_chr20)*in ^ 0x80u) << 0xCu;

- ++in;

- chr += ((zap_chr20)*in ^ 0x80u) << 0x6u;

- ++in;

- chr += (zap_chr20)*in ^ 0x80u;

- ++in;

- *out = chr;

- continue;

- }

- if (oct >= 0xE0u) { /* Three octets. */

- zap_chr20 chr = ((zap_chr20)oct ^ 0xE0u) << 0xCu;

- ++in;

- chr += ((zap_chr20)*in ^ 0x80u) << 0x6u;

- ++in;

- chr += (zap_chr20)*in ^ 0x80u;

- ++in;

- *out = chr;

- continue;

- }

- if (oct >= 0xC0u) { /* Two octets. */

- zap_chr20 chr = ((zap_chr20)oct ^ 0xC0u) << 0x6u;

- ++in;

- chr += (zap_chr20)*in ^ 0x80u;

- ++in;

- *out = chr;

- continue;

- }

- /* One octet. */

- *out = oct;

- ++in;

- if (oct == 0x0u) {break;}

- }

-}

-/*

- 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>

-

-zap_sz zap_utf8declen(zap_chr8 const * const _in) {

- zap_sz len = 0x0u;

- zap_chr8 const * in;

- for (in = _in;;++len) {

- zap_chr8 const oct = *in;

- if (oct == 0x0u) {break;}

- if (oct >= 0xF0u) {

- in += 0x4u;

- continue;

- }

- if (oct >= 0xE0u) {

- in += 0x3u;

- continue;

- }

- if (oct >= 0xC0u) {

- in += 0x2u;

- continue;

- }

- ++in;

- continue;

- }

- return len;

-}

-# 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/.

-

-.globl zap_utf8enc

-

-zap_utf8enc:

- # rdi: Current input codepoint.

- # rsi: Current output octet.

- # rax: Current codepoint.

- # rdx: Temporary.

-

- # Iterate over the input:

-.loop:

-

- movl (%rdi),%eax

-

- cmpl $0xFFFF,%eax

- jg .oct4

-

- cmpl $0x7FF,%eax

- jg .oct3

-

- cmpl $0x7F,%eax

- jg .oct2 # Otherwise, only one octet is needed.

-

- # One octet:

-.oct1:

-

- # Octet #0:

- movb %al,(%rsi) # No conversion needed:

-

- incq %rsi

-

- # Test if we have reached the null-terminator:

- testb %al,%al

- jz .done

-

- jmp .cnt

-

- # Two octets:

-.oct2:

-

- /* Octet #0: */

- movl %eax,%edx

- shrl $0x6,%edx

- orb $0xC0,%dl

- movb %dl,(%rsi)

-

- incq %rsi

-

- # Octet #1:

- movl %eax,%edx

- andb $0x3F,%dl

- orb $0x80,%dl

- movb %dl,(%rsi)

-

- incq %rsi

-

- jmp .cnt

-

- # Three octets:

-.oct3:

-

- # Octet #0:

- movl %eax,%edx

- shrl $0xC,%edx

- orb $0xE0,%dl

- movb %dl,(%rsi)

-

- incq %rsi

-

- # Octet #1:

- movl %eax,%edx

- shrl $0x6,%edx

- andb $0x3F,%dl

- orb $0x80,%dl

- movb %dl,(%rsi)

-

- incq %rsi

-

- # Octet #2:

- movl %eax,%edx

- andb $0x3F,%dl

- orb $0x80,%dl

- movb %dl,(%rsi)

-

- incq %rsi

-

- jmp .cnt

-

- # Four octets:

-.oct4:

-

- # Octet #0:

- movl %eax,%edx

- shrl $0x12,%edx

- orb $0xF0,%dl

- movb %dl,(%rsi)

-

- incq %rsi

-

- # Octet #1:

- movl %eax,%edx

- shrl $0xC,%edx

- andb $0x3F,%dl

- orb $0x80,%dl

- movb %dl,(%rsi)

-

- incq %rsi

-

- # Octet #2:

- movl %eax,%edx

- shrl $0x6,%edx

- andb $0x3F,%dl

- orb $0x80,%dl

- movb %dl,(%rsi)

-

- incq %rsi

-

- # Octet #3:

- movl %eax,%edx

- andb $0x3F,%dl

- orb $0x80,%dl

- movb %dl,(%rsi)

-

- incq %rsi

-

- # Continue to the next codepoint:

-.cnt:

-

- addq $0x4,%rdi

- jmp .loop

-

- # Done:

-.done:

-

- ret

- \ No newline at end of file

-# 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/.

-

-.globl zap_utf8enclen

-

-zap_utf8enclen:

- # rdi: Address of the current character.

- # rax: Length of the string.

- # rsi: Current character.

-

- movq $0x0,%rax

-

- # Iterate over the input:

-.loop:

-

- movl (%rdi),%esi

-

- # Test if we have reached the null-terminator:

- testl %esi,%esi

- jz .done

-

- cmpl $0xFFFF,%esi

- jg .oct4

-

- cmpl $0x7FF,%esi

- jg .oct3

-

- cmpl $0x7F,%esi

- jg .oct2

-

- # One octet:

-.oct1:

-

- incq %rax

-

- jmp .cnt

-

- # Two octets:

-.oct2:

-

- addq $0x2,%rax

-

- jmp .cnt

-

- # Three octets:

-.oct3:

-

- addq $0x3,%rax

-

- jmp .cnt

-

- # Four octets:

-.oct4:

-

- addq $0x4,%rax

-

- # Continue to the next codepoint:

-.cnt:

-

- addq $0x4,%rdi

- jmp .loop

-

- # Done:

-.done:

-

- ret

-# 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/.

-

-.globl zap_abs_c

-.globl zap_abs_i

-.globl zap_abs_l

-.globl zap_abs_ll

-.globl zap_abs_s

-.globl zap_abs_sc

-

-zap_abs_i:

-# The input value:

-#define val %edi

-# Inverted value of the input:

-#define inv %eax

- movl val,inv # inv = val

- negl inv # inv = -inv // Invert the copy of the input value. This also tests the sign of the value.

- # . if (inv > 0x0)

- cmovsl val,inv # val = inv // If it was positive, just return the unmodified input.

- ret # return val // Otherwise, return the inverted value.

-

-#undef val

-#undef inv

-

-zap_abs_l:

-zap_abs_ll:

-# The input value:

-#define val %rdi

-# Inverted value of the input:

-#define inv %rax

- movq val,inv # inv = val

- negq inv # inv = -inv

- # . if (inv > 0x0)

- cmovsq val,inv # val = inv

- ret # return val

-

-#undef val

-#undef inv

-

-zap_abs_s:

-# The input value:

-#define val %di

-# Inverted value of the input:

-#define inv %ax

- movw val,inv # inv = val

- negw inv # inv = -inv

- # . if (inv > 0x0)

- cmovsw val,inv # val = inv

- ret # return val

-

-#undef val

-#undef inv

-

-zap_abs_c:

-zap_abs_sc:

-# The input value:

-#define val %dil

-#define val2 %di

-# Inverted value of the input:

-#define inv %al

-#define inv2 %ax

- movb val,inv # inv = val

- negb inv # inv = -inv

- # . if (inv > 0x0)

- cmovsw val2,inv2 # val = inv

- ret # return val

-

-#undef val

-#undef inv

- Copyright 2022 Gabriel Jensen.

- 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>

-

-void zap_win1252dec(zap_chr8 const * const _in,zap_chr20 * const _out) {

- zap_chr8 const * in = _in;

- zap_chr20 * out = _out;

- for (;;++in,++out) {

- zap_chr8 const chr = *in;

- *out = *in;

- *out = 0xFFFDu; /* REPLACEMENT CHARACTER */

- *out = 0x20ACu;

- *out = 0x201Au;

- *out = 0x192u;

- *out = 0x201Eu;

- *out = 0x2026u;

- *out = 0x2020u;

- *out = 0x2021u;

- *out = 0x2C6u;

- *out = 0x2030u;

- *out = 0x160u;

- *out = 0x2039u;

- *out = 0x152u;

- *out = 0x17Du;

- *out = 0x2018u;

- *out = 0x2019u;

- *out = 0x201Cu;

- *out = 0x201Du;

- *out = 0x2022u;

- *out = 0x2013u;

- *out = 0x2014u;

- *out = 0x2DCu;

- *out = 0x2122u;

- *out = 0x161u;

- *out = 0x203Au;

- *out = 0x153u;

- *out = 0x17Eu;

- *out = 0x178u;

- if (chr == 0x0u) {break;}

- Copyright 2022 Gabriel Jensen.

- 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>

-

-void zap_win1252enc(zap_chr20 const * const _in,zap_chr8 * const _out) {

- zap_chr20 const * in = _in;

- zap_chr8 * out = _out;

- for (;;++in,++out) {

- zap_chr20 const chr = *in;

- zap_chr8 const bad = 0x3Fu;

- *out = bad;

- *out = bad;

- *out = *in;

- *out = 0x80u;

- *out = 0x82u;

- *out = 0x83u;

- *out = 0x84u;

- *out = 0x85u;

- *out = 0x86u;

- *out = 0x87u;

- *out = 0x88u;

- *out = 0x89u;

- *out = 0x8Au;

- *out = 0x8Bu;

- *out = 0x8Cu;

- *out = 0x8Eu;

- *out = 0x91u;

- *out = 0x92u;

- *out = 0x93u;

- *out = 0x94u;

- *out = 0x95u;

- *out = 0x96u;

- *out = 0x97u;

- *out = 0x98u;

- *out = 0x99u;

- *out = 0x9Au;

- *out = 0x9Bu;

- *out = 0x9Cu;

- *out = 0x9Eu;

- *out = 0x9Fu;

- if (chr == 0x0u) {break;}