Htykuut

I encountered a strange problem while coding a linked list in arm assembly on the raspberry pi. my linked list works for all strings except strings with a length of 12. it displays a junk character at the end of all strings with a length of 12 and I cannot figure out why

any help is appreciated

here is the input function I'm using, it outputs the address to the malloc'd string in R0 and seems to function correctly for all strings not length 12:

.equ    BUFSIZE2,256



.data

inputbuf2:  .ds BUFSIZE2

prompt:     .asciz  "Enter: "

p1:     .word   0



input:

    push {R1,R2,R5,R14}

    mov R0,#0

    bl  v_ascz        @ prints string in R1

    ldr R1,=inputbuf2

    mov R2,#BUFSIZE2

    bl  c_ascz        @ does service call for input, returns in R1

    bl  v_ascz

    bl  v_nl

    bl  strlen        @ returns string length of R1 into R0

    sub R0,#1

    mov R5,R0

    bl  alloc

    bl  store

    ldr R0,=p1

    ldr R0,[R0]

    pop {R1,R2,R5,R14}

    bx  LR



alloc:

    push {R0-R4,R14}

    bl  malloc

    ldr R1,=p1

    str R0,[R1]

    pop {R0-R4,R14}

    bx  LR



store:

    push    {R1-R4,R14}

    mov R2,#0       @ index

    ldr R4,=p1

    ldr R4,[R4]

    loop:   ldrb    R3,[R1],#1

    strb    R3,[R4],#1

    add R2,#1

    cmp R2,R5

    blt loop



    mov R3,#0

    strb    R3,[R4]       @ store null at end of string

    pop {R1-R4,R14}

    bx  LR





.end

And here's the linked list add node function I'm using. It allocates 8 bytes and stores the address to the data in the first four and the address to the next node in the last 4:

.global list_add

@   R1  =   addr of head

@   R2  =   addr of tail

@   R3  =   data

.data

node:   .word   0



list_add:

    push    {R1-R4,R14}

    bl  alloc

    push    {R2}

    ldr R2,[R2]

    cmp R2,#0

    pop {R2}

    beq first_node

            @ normal add

    ldr R4,=node

    ldr R4,[R4]

    push    {R2}

    ldr R2,[R2]     @ R2 = tail node

    str R4,[R2,#4]  @ R2 next ptr = node

    pop {R2}

    str R4,[R2]     @ tail = node

    str R3,[R4]     @ node data = first addr of data

    mov R3,#0

    str R3,[R4,#4]

    pop {R1-R4,R14}

    bx  LR



first_node:

    push    {R1-R4}

    ldr R4,=node

    ldr R4,[R4]

    str R4,[R1]     @ head = node

    str R4,[R2]     @ tail = node

    str R3,[R4]     @ node data = data

    mov R3,#0

    str R3,[R4,#4]

    pop {R1-R4}

    pop {R1-R4,R14}

    bx  LR



alloc:

    push    {R1-R3,R14}

    mov R0,#8

    bl  malloc

    ldr R1,=node

    str R0,[R1]

    ldr R1,[R1]

    mov R3,#0

    str R3,[R1]

    str R3,[R1,#4]

    pop {R1-R3,R14}

    bx  LR

Adding a bunch of random strings centered around my girlfriend's dog, wriggly, this is the output. ignore the numbers, they're the decimal addresses of the malloc'd memory

Strings, by convention, are terminated by a zero byte called the 'termination character'.

When you call strlen you obtain the number of characters in the string, excluding the termination character that marks its end. This causes two problems:

• When you loop to copy the string, you are not copying the termination character. Your string will therefore end at the next byte in memory that happens to be a zero, which could be anywhere. You're seeing the result of undefined behaviour: there's no reason why 12 characters should not work when other numbers do, it's just a consequence of your specific circumstances.


• If you were to add the termination character, you'd be overflowing your destination string buffer, because your call to malloc also doesn't allocate enough space for the termination character.

While I'm here, I might as well also refer you to the ARM ABI, and specifically the part about the procedure call standard. While the ABI does not rule out using r0-r3 for intermediate values, these registers (along with r12) are 'call-clobbered' so it is typical to use r4-r11 for intermediate calculation. Functions must preserve r4-r11, usually by using the stack. Your use of r5 to hold a function argument (to store) is therefore contrary to the ABI, so your store function would not be callable from ABI-compliant code; and your pushing/popping of r1-r3 in several places is unnecessary if your callers also conform to the ABI. Also of note is that the ABI requires 8-byte stack alignment across function calls in different translation units, so it's a good idea to get into the habit of pushing and popping even numbers of registers to maintain this. (If you call a library function like malloc or strlen without ensuring 8-byte alignment, for example, you could run into undefined behaviour again.)