Initialize array to specific values in assembly (x86)

Question

I want to initialize an array in assembly with specific values. I tried doing it in a loop first but got junk in the arrays. I then tried doing it manually and got the same junk. I want the array to repeat 0 1 2 for an n amount of times. Here is some example code I tried.

This is my attempt at manully loading the array. The first value loads just fine. The second value however, loads in junk when I examine it in GDB.

sub esp, 260
mov [ebp - 12], dword -1
mov [ebp - 16], byte 0
mov [ebp - 17], byte 1
mov [ebp - 18], byte 2
mov [ebp - 19], byte 0
mov [ebp - 20], byte 1
mov [ebp - 21], byte 2
mov [ebp - 22], byte 0
mov [ebp - 23], byte 1
mov [ebp - 24], byte 2
mov [ebp - 25], byte 0

Here was my attempt at doing it automatically.

    sub esp, 260
    mov [ebp - 12], dword -1

again:
    add [ebp - 12], dword 1
    lea eax, [ebp - 16]
    sub eax, [ebp - 12]
    mov [eax], byte 0

    add [ebp - 12], dword 1
    lea eax, [ebp - 16]
    sub eax, [ebp - 12]
    mov [eax], byte 1

    add [ebp - 12], dword 1
    lea eax, [ebp - 16]
    sub eax, [ebp - 12]
    mov [eax], byte 2

    cmp [ebp - 12], dword 255
    jne again
    jmp elsewhere

Using NASM, x86-32, Intel syntax.

EDIT: When I convert this code to store the array values as DWORDs instead of bytes both methods work. Why is that?

Answer 1

With NASM, you can easily initialise repeating data by using the times prefix. For instance, to repeat the sequence "0 1 2" n times as requested in your question, you can do something similar to the following:

section .data

    my_array: times n db 0, 1, 2 

Simply replace n by the constant value you want. More information about the times prefix can be found in the NASM Manual.

Answer 2

Assuming you want your array of bytes to occupy the stackspace from [EBP-260] to [EBP-16], it will hold 260 - 16 + 1 = 245 bytes. Looking at your examples I see that the last element is a 0. Considering that the number of elements is not divisable by 3, I can work out that the first element needs to be a 1.

(1, 0) followed by 81 times (2, 1, 0)

Taking the first two elements out of the loop creates an opportunity to write an efficient solution with a couple of nested loops:

  push ebp
  mov  ebp, esp
  sub  esp, 260

  ; Initializing the array with 245 bytes (2 + 81 * 3)
  mov  edx, esp
  mov  eax, 1
  mov  [edx], ax         ; (1, 0)
  inc  eax               ; 1 -> 2
  add  edx, eax
  mov  ecx, 81           ; 81 triplets (2, 1, 0)
Outer:
Inner:
  mov  [edx], al
  inc  edx
  dec  eax               ; 2 -> 1 -> 0 -> -1
  jns  Inner
  add  eax, 3            ; -1 -> 2
  dec  ecx
  jnz  Outer
  mov  byte [edx], -1    ; (*)

But we can do much better if we write 32 bits at a time. The array in memory presents itself as:

| EBP-260 == ESP                                      | EBP-20    | EBP-16
v                                                     v           v
1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, ... , 1, 0, 2, 1, 0
\--------/  \--------/  \--------/  ^               ^ \--------/  -
    EAX         EBX         ECX     | repeats       |     EAX     BL
                                    | from here on  |     left-overs

In the 245-byte array, these 3 dwords (12 bytes) can repeat 20 times. And because the address where the array starts (ESP) is dword aligned, I'll put the repetitions at the low end.

  push ebp
  mov  ebp, esp
  sub  esp, 260
  mov  byte [ebp-15], -1 ; (*)

  ; Initializing the array with 245 bytes (20 * 12 + 5)

  mov  eax, 01020001h    ; (1, 0, 2, 1)
  mov  ebx, 00010200h    ; (0, 2, 1, 0)
  mov  ecx, 02000102h    ; (2, 1, 0, 2)
  lea  edx, [ebp-32]
  mov  [ebp-16], bl
  mov  [ebp-20], eax
More:
  mov  [edx+8], ecx
  mov  [edx+4], ebx
  mov  [edx], eax
  sub  edx, 12
  cmp  edx, esp
  jae  More

(*) If the intended use of this -1 is to terminate the list, then having a byte -1 at [ebp-15] makes more sense than a dword -1 at [ebp-12].

Answer 3

This may trigger more ideas about allocating bytes or dwords on the stack.

You may want to build a library of personal functions or macros that you may use often or find some other library to %include.

You can construe your array data in byte, dword, or other size as along as you treat all the data elements the same way. You have to always be mindful of the array element size (e.g., 1 vs 4 bytes..). I'll leave any alignment issues up to you to resolve.

section .data
        _len equ 64
section .text
        %macro mod 2
        mov eax, %1
        mov ebx, %2
        xor edx, edx
        div ebx                 ; div/mul are very slow; but ok for small loops
        mov eax, edx            ; return eax if you wish
        %endmacro

        global _start
_start:
        nop

        sub esp, _len                   ; 

        mov ecx, 1
        L1:

        mod ecx, 3                      ; n mod 3 
        mov byte [esp+ecx], al

        inc ecx
        cmp ecx, _len                   ; array size
        jb L1

        add sp, _len

_exit:
        mov eax, 1
        mov ebx, 0
        int 0x80

GDB example x/64d $esp using next....

(gdb) 
0xffffd180:     0       1       2       0       1       2       0       1
0xffffd188:     2       0       1       2       0       1       2       0
0xffffd190:     1       2       0       1       2       0       1       2
0xffffd198:     0       1       2       0       1       2       0       1
0xffffd1a0:     2       0       1       2       0       1       2       0
0xffffd1a8:     1       2       0       1       2       0       1       2
0xffffd1b0:     0       1       2       0       1       2       0       1
0xffffd1b8:     2       0       1       2       0       1       0       0
31      v eax, 1
(gdb) 
0xffffd180:     0       1       2       0       1       2       0       1
0xffffd188:     2       0       1       2       0       1       2       0
0xffffd190:     1       2       0       1       2       0       1       2
0xffffd198:     0       1       2       0       1       2       0       1
0xffffd1a0:     2       0       1       2       0       1       2       0
0xffffd1a8:     1       2       0       1       2       0       1       2
0xffffd1b0:     0       1       2       0       1       2       0       1
0xffffd1b8:     2       0       1       2       0       1       0       0
25      cx, 3                   ; n mod 3 
(gdb) 
0xffffd180:     0       1       2       0       1       2       0       1
0xffffd188:     2       0       1       2       0       1       2       0
0xffffd190:     1       2       0       1       2       0       1       2
0xffffd198:     0       1       2       0       1       2       0       1
0xffffd1a0:     2       0       1       2       0       1       2       0
0xffffd1a8:     1       2       0       1       2       0       1       2
0xffffd1b0:     0       1       2       0       1       2       0       1
0xffffd1b8:     2       0       1       2       0       1       0       0
27      cx
(gdb) 
0xffffd180:     0       1       2       0       1       2       0       1
0xffffd188:     2       0       1       2       0       1       2       0
0xffffd190:     1       2       0       1       2       0       1       2
0xffffd198:     0       1       2       0       1       2       0       1
0xffffd1a0:     2       0       1       2       0       1       2       0
0xffffd1a8:     1       2       0       1       2       0       1       2
0xffffd1b0:     0       1       2       0       1       2 

  0   

Answer 4

With gas (at&t syntax) you can use

array:
  .space size, value

you can also use .skip which is the same as .space.

Answer 5

Here is what i got:

;ecx = how much values  ;ds:edi = destination
function:

    pushad                    ;push all 32bit registers to stack

    xor eax,eax               ;clear eax

    function_loop:

        push eax              
        mov ebx,0x00000003    ;we divide by 3

        xor edx,edx           ;clear edx 

        div ebx               ;this stores the remainder of eax/0x03 in edx
        mov DWORD [edi],edx   ;move it to your array

        pop eax               ;we dont need the result of the division

        inc eax 
        add edi,4             ;increment pointer 4 bytes because 4 bytes are one DWORD

    loop function_loop        ;loop til ecx is 0

    popad                     ;pop all 32bit registers
ret

i wrote it out of my head so please report any bug with it

but the thing you have to do is increment a register and do a modulo operation with 3 on the incrementing register and then you have the 0,1,2 pattern

just be sure you have enough space on the desitnation to store all n values