Skip to content
This repository has been archived by the owner on Dec 1, 2021. It is now read-only.

Took forever to generate the goasm #30

Open
ii64 opened this issue Nov 30, 2021 · 2 comments
Open

Took forever to generate the goasm #30

ii64 opened this issue Nov 30, 2021 · 2 comments

Comments

@ii64
Copy link

ii64 commented Nov 30, 2021

Hi i am testing the c2goasm, for a simple function it works, but for bigger one it is took like forever, i wonder if there was a problem in my config or a bug?

image
image

build command: clang -S -O3 -masm=intel -mno-red-zone -mstackrealign -mllvm -inline-threshold=1000 -fno-asynchronous-unwind-tables -fno-exceptions -fno-rtti $1

Generated CLang ASM 
	.text
	.intel_syntax noprefix
	.file	"encoder.c"
	.globl	qoi_write_32            # -- Begin function qoi_write_32
	.p2align	4, 0x90
	.type	qoi_write_32,@function
qoi_write_32:                           # @qoi_write_32
# %bb.0:
	push	rbp
	mov	rbp, rsp
	and	rsp, -8
	mov	eax, edx
	shr	eax, 24
	movsxd	r8, dword ptr [rsi]
	lea	ecx, [r8 + 1]
	mov	dword ptr [rsi], ecx
	mov	byte ptr [rdi + r8], al
	mov	eax, edx
	shr	eax, 16
	movsxd	r8, dword ptr [rsi]
	lea	ecx, [r8 + 1]
	mov	dword ptr [rsi], ecx
	mov	byte ptr [rdi + r8], al
	movsxd	rax, dword ptr [rsi]
	lea	ecx, [rax + 1]
	mov	dword ptr [rsi], ecx
	mov	byte ptr [rdi + rax], dh
	movsxd	rax, dword ptr [rsi]
	lea	ecx, [rax + 1]
	mov	dword ptr [rsi], ecx
	mov	byte ptr [rdi + rax], dl
	mov	rsp, rbp
	pop	rbp
	ret
.Lfunc_end0:
	.size	qoi_write_32, .Lfunc_end0-qoi_write_32
                                        # -- End function
	.globl	qoi_read_32             # -- Begin function qoi_read_32
	.p2align	4, 0x90
	.type	qoi_read_32,@function
qoi_read_32:                            # @qoi_read_32
# %bb.0:
	push	rbp
	mov	rbp, rsp
	and	rsp, -8
	movsxd	rcx, dword ptr [rsi]
	lea	rax, [rcx + 1]
	mov	dword ptr [rsi], eax
	movzx	r8d, byte ptr [rdi + rcx]
	lea	rax, [rcx + 2]
	mov	dword ptr [rsi], eax
	movzx	r9d, byte ptr [rdi + rcx + 1]
	lea	rax, [rcx + 3]
	mov	dword ptr [rsi], eax
	movzx	eax, byte ptr [rdi + rcx + 2]
	lea	edx, [rcx + 4]
	mov	dword ptr [rsi], edx
	movzx	ecx, byte ptr [rdi + rcx + 3]
	shl	r8d, 24
	shl	r9d, 16
	or	r9d, r8d
	shl	eax, 8
	or	eax, r9d
	or	eax, ecx
	mov	rsp, rbp
	pop	rbp
	ret
.Lfunc_end1:
	.size	qoi_read_32, .Lfunc_end1-qoi_read_32
                                        # -- End function
	.globl	pixel_cpy               # -- Begin function pixel_cpy
	.p2align	4, 0x90
	.type	pixel_cpy,@function
pixel_cpy:                              # @pixel_cpy
# %bb.0:
	push	rbp
	mov	rbp, rsp
	and	rsp, -8
	test	rdx, rdx
	je	.LBB2_20
# %bb.1:
	cmp	rdx, 32
	jb	.LBB2_13
# %bb.2:
	lea	rax, [rsi + rdx]
	cmp	rax, rdi
	jbe	.LBB2_4
# %bb.3:
	lea	rax, [rdi + rdx]
	cmp	rax, rsi
	jbe	.LBB2_4
.LBB2_13:
	lea	r8, [rdx - 1]
	mov	r9, rdx
	and	r9, 7
	je	.LBB2_17
.LBB2_14:
	xor	ecx, ecx
	.p2align	4, 0x90
.LBB2_15:                               # =>This Inner Loop Header: Depth=1
	movzx	eax, byte ptr [rsi + rcx]
	mov	byte ptr [rdi + rcx], al
	add	rcx, 1
	cmp	r9, rcx
	jne	.LBB2_15
# %bb.16:
	sub	rdx, rcx
	add	rsi, rcx
	add	rdi, rcx
.LBB2_17:
	cmp	r8, 7
	jb	.LBB2_20
# %bb.18:
	xor	eax, eax
	.p2align	4, 0x90
.LBB2_19:                               # =>This Inner Loop Header: Depth=1
	movzx	ecx, byte ptr [rsi + rax]
	mov	byte ptr [rdi + rax], cl
	movzx	ecx, byte ptr [rsi + rax + 1]
	mov	byte ptr [rdi + rax + 1], cl
	movzx	ecx, byte ptr [rsi + rax + 2]
	mov	byte ptr [rdi + rax + 2], cl
	movzx	ecx, byte ptr [rsi + rax + 3]
	mov	byte ptr [rdi + rax + 3], cl
	movzx	ecx, byte ptr [rsi + rax + 4]
	mov	byte ptr [rdi + rax + 4], cl
	movzx	ecx, byte ptr [rsi + rax + 5]
	mov	byte ptr [rdi + rax + 5], cl
	movzx	ecx, byte ptr [rsi + rax + 6]
	mov	byte ptr [rdi + rax + 6], cl
	movzx	ecx, byte ptr [rsi + rax + 7]
	mov	byte ptr [rdi + rax + 7], cl
	add	rax, 8
	cmp	rdx, rax
	jne	.LBB2_19
	jmp	.LBB2_20
.LBB2_4:
	mov	r8, rdx
	and	r8, -32
	lea	rax, [r8 - 32]
	mov	rcx, rax
	shr	rcx, 5
	add	rcx, 1
	mov	r9d, ecx
	and	r9d, 3
	cmp	rax, 96
	jae	.LBB2_6
# %bb.5:
	xor	eax, eax
	jmp	.LBB2_8
.LBB2_6:
	sub	rcx, r9
	xor	eax, eax
	.p2align	4, 0x90
.LBB2_7:                                # =>This Inner Loop Header: Depth=1
	movups	xmm0, xmmword ptr [rsi + rax]
	movups	xmm1, xmmword ptr [rsi + rax + 16]
	movups	xmmword ptr [rdi + rax], xmm0
	movups	xmmword ptr [rdi + rax + 16], xmm1
	movups	xmm0, xmmword ptr [rsi + rax + 32]
	movups	xmm1, xmmword ptr [rsi + rax + 48]
	movups	xmmword ptr [rdi + rax + 32], xmm0
	movups	xmmword ptr [rdi + rax + 48], xmm1
	movups	xmm0, xmmword ptr [rsi + rax + 64]
	movups	xmm1, xmmword ptr [rsi + rax + 80]
	movups	xmmword ptr [rdi + rax + 64], xmm0
	movups	xmmword ptr [rdi + rax + 80], xmm1
	movups	xmm0, xmmword ptr [rsi + rax + 96]
	movups	xmm1, xmmword ptr [rsi + rax + 112]
	movups	xmmword ptr [rdi + rax + 96], xmm0
	movups	xmmword ptr [rdi + rax + 112], xmm1
	sub	rax, -128
	add	rcx, -4
	jne	.LBB2_7
.LBB2_8:
	test	r9, r9
	je	.LBB2_11
# %bb.9:
	add	rax, 16
	neg	r9
	.p2align	4, 0x90
.LBB2_10:                               # =>This Inner Loop Header: Depth=1
	movups	xmm0, xmmword ptr [rsi + rax - 16]
	movups	xmm1, xmmword ptr [rsi + rax]
	movups	xmmword ptr [rdi + rax - 16], xmm0
	movups	xmmword ptr [rdi + rax], xmm1
	add	rax, 32
	inc	r9
	jne	.LBB2_10
.LBB2_11:
	cmp	r8, rdx
	jne	.LBB2_12
.LBB2_20:
	mov	eax, 1
	mov	rsp, rbp
	pop	rbp
	ret
.LBB2_12:
	and	edx, 31
	add	rsi, r8
	add	rdi, r8
	lea	r8, [rdx - 1]
	mov	r9, rdx
	and	r9, 7
	jne	.LBB2_14
	jmp	.LBB2_17
.Lfunc_end2:
	.size	pixel_cpy, .Lfunc_end2-pixel_cpy
                                        # -- End function
	.globl	qoi_pixel_encoder       # -- Begin function qoi_pixel_encoder
	.p2align	4, 0x90
	.type	qoi_pixel_encoder,@function
qoi_pixel_encoder:                      # @qoi_pixel_encoder
# %bb.0:
	push	rbp
	mov	rbp, rsp
	push	r15
	push	r14
	push	r13
	push	r12
	push	rbx
	and	rsp, -8
	mov	ebx, dword ptr [rbp + 16]
	mov	r10, qword ptr [rbp + 24]
	mov	r11, qword ptr [rbp + 32]
	xor	eax, eax
	cmp	r11, r10
	sete	al
	add	r9d, -1
	xor	r9d, ecx
	add	ebx, -1
	xor	ebx, r8d
	or	ebx, r9d
	sete	cl
	mov	r9b, byte ptr [r11]
	mov	r13b, byte ptr [r11 + 1]
	mov	r14b, byte ptr [r11 + 2]
	mov	r8b, byte ptr [r11 + 3]
	mov	ebx, dword ptr [rdx + 4*rax]
	cmp	r11, r10
	jne	.LBB3_3
# %bb.1:
	test	cl, cl
	jne	.LBB3_3
# %bb.2:
	cmp	ebx, 8224
	jne	.LBB3_7
.LBB3_3:
	shl	rax, 2
	cmp	ebx, 32
	jg	.LBB3_5
# %bb.4:
	add	bl, -1
	or	bl, 64
	mov	r12d, 1
	mov	r15, rsi
	jmp	.LBB3_6
.LBB3_5:
	add	ebx, -33
	mov	dword ptr [rdx + rax], ebx
	shr	ebx, 8
	or	bl, 96
	lea	r15, [rsi + 4]
	movsxd	rcx, dword ptr [rsi]
	mov	byte ptr [rdi + rcx], bl
	mov	bl, byte ptr [rdx + rax]
	mov	r12d, 2
.LBB3_6:
	lea	rsi, [rsi + 4*r12]
	movsxd	rcx, dword ptr [r15]
	mov	byte ptr [rdi + rcx], bl
	mov	dword ptr [rdx + rax], 0
.LBB3_7:
	cmp	r11, r10
	je	.LBB3_25
# %bb.8:
	mov	rax, qword ptr [rbp + 40]
	xor	r13b, r9b
	xor	r13b, r14b
	xor	r13b, r8b
	movzx	ecx, r13b
	shl	rcx, 5
	mov	rax, qword ptr [rax + rcx]
	cmp	rax, r11
	je	.LBB3_26
# %bb.9:
	mov	cl, byte ptr [r11]
	mov	byte ptr [rax], cl
	mov	cl, byte ptr [r11 + 1]
	mov	byte ptr [rax + 1], cl
	mov	cl, byte ptr [r11 + 2]
	mov	byte ptr [rax + 2], cl
	mov	cl, byte ptr [r11 + 3]
	mov	byte ptr [rax + 3], cl
	movsx	ecx, byte ptr [r11]
	movsx	eax, byte ptr [r10]
	sub	ecx, eax
	movsx	r9d, byte ptr [r11 + 1]
	movsx	eax, byte ptr [r10 + 1]
	sub	r9d, eax
	movsx	edx, byte ptr [r11 + 2]
	movsx	eax, byte ptr [r10 + 2]
	sub	edx, eax
	movsx	r8d, byte ptr [r11 + 3]
	movsx	eax, byte ptr [r10 + 3]
	sub	r8d, eax
	lea	r15d, [rcx + 16]
	lea	eax, [r9 + 16]
	or	eax, r15d
	lea	r14d, [rdx + 16]
	lea	r10d, [r8 + 16]
	mov	ebx, r14d
	or	ebx, r10d
	or	ebx, eax
	cmp	ebx, 32
	jae	.LBB3_16
# %bb.10:
	lea	r11d, [rdx + 2]
	cmp	r11d, 3
	ja	.LBB3_13
# %bb.11:
	lea	eax, [rcx + 2]
	lea	ebx, [r9 + 2]
	or	ebx, eax
	and	ebx, -4
	or	ebx, r8d
	jne	.LBB3_13
# %bb.12:
	shl	ecx, 4
	add	ecx, 32
	lea	eax, [4*r9 + 8]
	or	eax, ecx
	or	eax, r11d
	or	al, -128
	movsxd	rcx, dword ptr [rsi]
	mov	byte ptr [rdi + rcx], al
	jmp	.LBB3_25
.LBB3_26:
	movsxd	rax, dword ptr [rsi]
	mov	byte ptr [rdi + rax], r13b
	jmp	.LBB3_25
.LBB3_16:
	test	ecx, ecx
	setne	al
	shl	al, 3
	test	r9d, r9d
	setne	bl
	shl	bl, 2
	or	bl, al
	test	edx, edx
	setne	al
	add	al, al
	or	al, bl
	test	r8d, r8d
	setne	bl
	or	bl, al
	or	bl, -16
	movsxd	rax, dword ptr [rsi]
	mov	byte ptr [rdi + rax], bl
	test	ecx, ecx
	je	.LBB3_17
# %bb.18:
	mov	al, byte ptr [r11]
	movsxd	rcx, dword ptr [rsi + 4]
	add	rsi, 8
	mov	byte ptr [rdi + rcx], al
	test	r9d, r9d
	je	.LBB3_21
.LBB3_20:
	mov	al, byte ptr [r11 + 1]
	movsxd	rcx, dword ptr [rsi]
	add	rsi, 4
	mov	byte ptr [rdi + rcx], al
.LBB3_21:
	test	edx, edx
	je	.LBB3_23
# %bb.22:
	mov	al, byte ptr [r11 + 2]
	movsxd	rcx, dword ptr [rsi]
	add	rsi, 4
	mov	byte ptr [rdi + rcx], al
.LBB3_23:
	test	r8d, r8d
	je	.LBB3_25
# %bb.24:
	mov	al, byte ptr [r11 + 3]
	movsxd	rcx, dword ptr [rsi]
	mov	byte ptr [rdi + rcx], al
	jmp	.LBB3_25
.LBB3_13:
	lea	eax, [r9 + 8]
	add	edx, 8
	or	eax, edx
	and	eax, -16
	or	eax, r8d
	je	.LBB3_14
# %bb.15:
	mov	eax, r15d
	shr	al
	or	al, -32
	movsxd	rcx, dword ptr [rsi]
	mov	byte ptr [rdi + rcx], al
	shl	r15d, 7
	lea	eax, [4*r9 + 64]
	or	eax, r15d
	mov	ecx, r14d
	shr	ecx, 3
	or	ecx, eax
	movsxd	rax, dword ptr [rsi + 4]
	mov	byte ptr [rdi + rax], cl
	shl	r14d, 7
	or	r10d, r14d
	movsxd	rax, dword ptr [rsi + 8]
	mov	byte ptr [rdi + rax], r10b
	jmp	.LBB3_25
.LBB3_17:
	add	rsi, 4
	test	r9d, r9d
	jne	.LBB3_20
	jmp	.LBB3_21
.LBB3_14:
	or	r15b, -64
	movsxd	rax, dword ptr [rsi]
	mov	byte ptr [rdi + rax], r15b
	shl	r9d, 4
	sub	r9d, -128
	or	edx, r9d
	movsxd	rax, dword ptr [rsi + 4]
	mov	byte ptr [rdi + rax], dl
.LBB3_25:
	mov	eax, 1
	lea	rsp, [rbp - 40]
	pop	rbx
	pop	r12
	pop	r13
	pop	r14
	pop	r15
	pop	rbp
	ret
.Lfunc_end3:
	.size	qoi_pixel_encoder, .Lfunc_end3-qoi_pixel_encoder
                                        # -- End function
	.ident	"clang version 10.0.0-4ubuntu1 "
	.section	".note.GNU-stack","",@progbits
	.addrsig
C code 
#ifndef QOI_ENCODER_
#define QOI_ENCODER_

#include <stddef.h>
#include "qoi.h"

void pixel_cpy(char *dst, char *src, size_t sz)
{
    while (sz--)
    {
        *dst++ = *src++;
    }
}

int qoi_pixel_encoder(
    char *data, int *cur, int *run,
    const int x, const int y,
    const int maxX, const int maxY,
    const char *px_prev, char *px,
    char **index) // [64][4]
{
    qoi_rgba_t px_ = {.rgba = {
                          .r = px[0],
                          .g = px[1],
                          .b = px[2],
                          .a = px[3],
                      }};

    if (px == px_prev)
    {
        *run++;
    }

    int last_pixel = x == maxX - 1 && y == (maxY - 1);
    if (*run > 0 && *run == 0x2020 || px != px_prev || last_pixel)
    {
        if (*run < 33)
        {
            *(data + *cur++) = QOI_RUN_8 | *run - 1;
        }
        else
        {
            *run -= 33;
            *(data + *cur++) = QOI_RUN_16 | *run >> 8;
            *(data + *cur++) = *run & 0xFF;
        }
        *run = 0;
    }

    if (px != px_prev)
    {
        int index_pos = QOI_COLOR_HASH(px_);
        if (index[index_pos * 4] == px)
        {
            *(data + *cur++) = QOI_INDEX | index_pos;
        }
        else
        {
            pixel_cpy(index[index_pos * 4], px, 4);
            int vr = px[0] - px_prev[0];
            int vg = px[1] - px_prev[1];
            int vb = px[2] - px_prev[2];
            int va = px[3] - px_prev[3];

            if (
                vr > -17 && vr < 16 &&
                vg > -17 && vg < 16 &&
                vb > -17 && vb < 16 &&
                va > -17 && va < 16)
            {
                if (
                    va == 0 &&
                    vr > -3 && vr < 2 &&
                    vg > -3 && vg < 2 &&
                    vb > -3 && vb < 2)
                {
                    *(data + *cur++) = QOI_DIFF_8 | (vr + 2) << 4 | (vg + 2) << 2 | (vb + 2);
                }
                else if (
                    va == 0 &&
                    vr > -17 && vr < 16 &&
                    vg > -9 && vg < 8 &&
                    vb > -9 && vb < 8)
                {
                    *(data + *cur++) = QOI_DIFF_16 | (vr + 16);
                    *(data + *cur++) = (vg + 8) << 4 | (vb + 8);
                }
                else
                {
                    *(data + *cur++) = QOI_DIFF_24 | (vr + 16) >> 1;
                    *(data + *cur++) = (vr + 16) << 7 | (vg + 16) << 2 | (vb + 16) >> 3;
                    *(data + *cur++) = (vb + 16) << 7 | (va + 16);
                }
            }
            else
            {
                *(data + *cur++) = QOI_COLOR | (vr ? 8 : 0) | (vg ? 4 : 0) | (vb ? 2 : 0) | (va ? 1 : 0);
                if (vr)
                {
                    *(data + *cur++) = px[0];
                }
                if (vg)
                {
                    *(data + *cur++) = px[1];
                }
                if (vb)
                {
                    *(data + *cur++) = px[2];
                }
                if (va)
                {
                    *(data + *cur++) = px[3];
                }
            }
        }
        px_prev = px;
    }
    return 1;
}
#endif
@ii64
Copy link
Author

ii64 commented Nov 30, 2021 •
edited
Loading

I can reproduce it by using this code:

int TesByteSlice(char *t, size_t sz)
{
    for (int i = 0; i < sz; i++)
    {
        *t++ = (char)i;
    }
    return 1;
}

or

int TesByteSlice(char *t, size_t sz)
{
    int i = 0;
loop:
    *t++ = i++;
    if (i < sz)
        goto loop;
    return 1;
}
Generated CLang ASM 
.text
.intel_syntax noprefix
.file    "tes.c"
.globl   TesSum                  # -- Begin function TesSum
.p2align 4, 0x90
.type    TesSum, @function

TesSum:
# @TesSum
# %bb.0:
push rbp
mov  rbp, rsp
and  rsp, -8

# kill: def $esi killed $esi def $rsi
# kill: def $edi killed $edi def $rdi
	lea eax, [rdi + rsi]
	mov rsp, rbp
	pop rbp
	ret

.Lfunc_end0:
	.size TesSum, .Lfunc_end0-TesSum

# -- End function
.section .rodata.cst16, "aM", @progbits, 16
.p2align 4               # -- Begin function TesByteSlice

.LCPI1_0:
	.byte 0                       # 0x0
	.byte 1                       # 0x1
	.byte 2                       # 0x2
	.byte 3                       # 0x3
	.byte 4                       # 0x4
	.byte 5                       # 0x5
	.byte 6                       # 0x6
	.byte 7                       # 0x7
	.byte 8                       # 0x8
	.byte 9                       # 0x9
	.byte 10                      # 0xa
	.byte 11                      # 0xb
	.byte 12                      # 0xc
	.byte 13                      # 0xd
	.byte 14                      # 0xe
	.byte 15                      # 0xf

.LCPI1_1:
	.zero 16, 16

.LCPI1_2:
	.zero 16, 32

.LCPI1_3:
	.zero 16, 48

.LCPI1_4:
	.zero 16, 64

.LCPI1_5:
	.zero 16, 80

.LCPI1_6:
	.zero 16, 96

.LCPI1_7:
	.zero 16, 112

.LCPI1_8:
	.zero    16, 128
	.text
	.globl   TesByteSlice
	.p2align 4, 0x90
	.type    TesByteSlice, @function

TesByteSlice:
# @TesByteSlice
# %bb.0:
push rbp
mov  rbp, rsp
and  rsp, -8
test rsi, rsi
je   .LBB1_13

# %bb.1:
cmp rsi, 15
ja  .LBB1_3

# %bb.2:
	xor eax, eax
	jmp .LBB1_12

.LBB1_3:
	mov rax, rsi
	and rax, -16
	lea rdx, [rax - 16]
	mov rcx, rdx
	shr rcx, 4
	add rcx, 1
	mov r8d, ecx
	and r8d, 7
	cmp rdx, 112
	jae .LBB1_5

# %bb.4:
	movdqa xmm2, xmmword ptr [rip + .LCPI1_0] # xmm2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
	xor    edx, edx
	jmp    .LBB1_7

.LBB1_5:
	sub      rcx, r8
	movdqa   xmm2, xmmword ptr [rip + .LCPI1_0] # xmm2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
	xor      edx, edx
	movdqa   xmm8, xmmword ptr [rip + .LCPI1_1] # xmm8 = [16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16]
	movdqa   xmm9, xmmword ptr [rip + .LCPI1_2] # xmm9 = [32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]
	movdqa   xmm3, xmmword ptr [rip + .LCPI1_3] # xmm3 = [48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48]
	movdqa   xmm4, xmmword ptr [rip + .LCPI1_4] # xmm4 = [64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64]
	movdqa   xmm5, xmmword ptr [rip + .LCPI1_5] # xmm5 = [80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80]
	movdqa   xmm6, xmmword ptr [rip + .LCPI1_6] # xmm6 = [96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96]
	movdqa   xmm7, xmmword ptr [rip + .LCPI1_7] # xmm7 = [112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112]
	movdqa   xmm1, xmmword ptr [rip + .LCPI1_8] # xmm1 = [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128]
	.p2align 4, 0x90
	.LBB1_6:                                # =>This Inner Loop Header: Depth=1
	movdqu   xmmword ptr [rdi + rdx], xmm2
	movdqa   xmm0, xmm2
	paddb    xmm0, xmm8
	movdqu   xmmword ptr [rdi + rdx + 16], xmm0
	movdqa   xmm0, xmm2
	paddb    xmm0, xmm9
	movdqu   xmmword ptr [rdi + rdx + 32], xmm0
	movdqa   xmm0, xmm2
	paddb    xmm0, xmm3
	movdqu   xmmword ptr [rdi + rdx + 48], xmm0
	movdqa   xmm0, xmm2
	paddb    xmm0, xmm4
	movdqu   xmmword ptr [rdi + rdx + 64], xmm0
	movdqa   xmm0, xmm2
	paddb    xmm0, xmm5
	movdqu   xmmword ptr [rdi + rdx + 80], xmm0
	movdqa   xmm0, xmm2
	paddb    xmm0, xmm6
	movdqu   xmmword ptr [rdi + rdx + 96], xmm0
	movdqa   xmm0, xmm2
	paddb    xmm0, xmm7
	movdqu   xmmword ptr [rdi + rdx + 112], xmm0
	sub      rdx, -128
	pxor     xmm2, xmm1
	add      rcx, -8
	jne      .LBB1_6

.LBB1_7:
	test r8, r8
	je   .LBB1_10

# %bb.8:
add      rdx, rdi
neg      r8
movdqa   xmm1, xmmword ptr [rip + .LCPI1_1] # xmm1 = [16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16]
.p2align 4, 0x90
.LBB1_9:                                # =>This Inner Loop Header: Depth=1
movdqu   xmmword ptr [rdx], xmm2
paddb    xmm2, xmm1
add      rdx, 16
inc      r8
jne      .LBB1_9

.LBB1_10:
	cmp rax, rsi
	je  .LBB1_13

# %bb.11:
add      rdi, rax
.p2align 4, 0x90
.LBB1_12:                               # =>This Inner Loop Header: Depth=1
mov      byte ptr [rdi], al
add      rdi, 1
add      rax, 1
cmp      rsi, rax
jne      .LBB1_12

.LBB1_13:
	mov eax, 1
	mov rsp, rbp
	pop rbp
	ret

.Lfunc_end1:
	.size TesByteSlice, .Lfunc_end1-TesByteSlice

# -- End function
.ident   "clang version 10.0.0-4ubuntu1 "
.section ".note.GNU-stack", "", @progbits
.addrsig

@ii64
Copy link
Author

ii64 commented Nov 30, 2021 •
edited
Loading

Recursive function works, but let's ignore it i guess

edit: tried with byte slices, doesn't work :/

int TesByteSlice(char *t, size_t sz)
{
    if (sz == 0)
        return 1;
    *t++ = sz--;
    return TesByteSlice(t, sz);
}

Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.
Assignees
No one assigned
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
1 participant
@ii64