Сборка нескольких массивов выделения памяти

Question

Как выделить память в сборке при использовании нескольких массивов. Например, у меня есть 2 массива;

la $s0, X
la $s1, Y

если «инициализировать» его таким образом, выделение памяти является непрерывным, например

Address     +0       +4       +8       +12     .....
22112      x[0]     y[0]     x[1]      y[1]    ...
.
.
.

Чтобы «исправить» это, я подумал о загрузке адреса массива кулака, инициализирующего значения n, а затем об инициализации другого. Например

arrayAllocationX:
   la $t0, X
     fill with $zero until n-1($t0)
   la $s0, X

arrayAllocationY:
   la $t1, Y
      fill with $zero until n-1($t1)
   la $s1, Y

Это не сработало, поскольку при указании la $s0, X и la $s1, Y оно продолжает сохранять значения непрерывно.

Я думал о других способах сделать это, которые могли бы работать, например; Заполнение элементов непрерывно и при чтении значения для любого массива переходят на 1 адрес памяти, поэтому x [0] = Address 2234 -> x [1] = 2234 + 8. Но это не кажется хорошей практикой программирования.

Можете ли вы посоветовать мне, как правильно поступить? Спасибо!

---

Кстати, значения всегда вводятся и читаются последовательно (сначала x, затем y)

Answer 1

Надеюсь, я не ошибаюсь в вашем вопросе, но выделение памяти для массива обычно выполняется специальной директивой ассемблера, а не конкретными инструкциями. К сожалению, синтаксис варьируется, но общая идея состоит в том, чтобы попросить ассемблер выделить некоторое пространство. Предположим, что массиву X требуется 100 дюймов, а массиву Y 200. Вот как это делают некоторые ассемблеры:

X:   defs  100*4
Y:   defs  200*4

Другие могут сказать «.byte» вместо «defs». «* 4» - это потому, что вы выделяете пространство в байтах, но каждое целое число составляет 4 байта. Иногда у ассемблеров есть способ сказать «выделить пространство и заполнить его некоторой ценностью». То, что я представил здесь, не будет этого делать, поэтому, чтобы быть уверенным, что вам теперь нужно написать начальные значения. Давайте заполним X 1, а Y 2:

     la   $t0,X         ; get address of X array into $t0
     mov  $t1,100       ; number of items in X into $t1
     mov  $s0,1         ; All X[] to be filled with 1
xlp: st   $s0,0($t0)    ; write next X[] value
     add  $t0,$t0,4     ; move to next position in X[] array
     add  $t1,$t1,-1    ; count down one less item
     bne  $t1,0,xlp     ; keep doing this until we get to zero

     la   $t0,Y
     mov  $t1,200
     mov  $s0,2
ylp: st   $s0,0($t0)
     add  $t0,$t0,4
     add  $t1,$t1,-1
     bne  $t1,0,ylp

Комментарии несколько избыточны, но я хотел повторить то, что я делаю, в вероятном случае, если я забыл мнемонику MIPS на ассемблере или допустил ошибку.

Динамическое распределение массивов - это совсем другое предложение. Обычно это подпрограмма операционной системы, которую вы вызываете, чтобы получить указатель на кусок памяти определенного размера. Если вы действительно на низком уровне, вам придется придумать свою собственную схему. Как ни странно, это само по себе связано с объявлением статического массива, который покрывает всю доступную память, и последующей передачей кусков по мере того, как программа об этом просит. Затем вам нужно усложнить отслеживание того, что вы передали, чтобы вы могли освободить куски.

В любом случае вам будет дан указатель на объем запрошенной памяти. Обычно вам нужно сохранить этот указатель в ячейке памяти, но он может находиться в регистре для простой программы. Код выделения может выглядеть примерно так:

X:     word    0

mov    $t0,100*8    ; how much memory we will need
bal    alloc        ; get memory -- assume it returns pointer in $t1
la     $s0,X        ; X pointer address
st     $t1,0($s0)   ; keep track of start of array

Обратите внимание, как мы должны сделать два шага, чтобы получить адрес массива. Перед "Х" был адрес памяти, чтобы использовать. Теперь «X» - это адрес 4 байтов памяти, которые содержат адрес массива.

Предыдущий код инициализации будет работать, как и раньше, но вместо простого "la $ t0, X" вам придется:

la   $t0,X
l    $t0,0($t0)

Если вы знакомы с C, разница здесь та же, что и "int X [100];" vs. "int * X = malloc (100 * sizeof (int));". В обоих случаях вы можете сказать «X [n]», но за кадром C использует правильные последовательности ассемблера.