I hope I'm not misinterpreting your question, but allocating memory for an array is generally done by a special assembler directive and not through particular instructions. Unfortunately, the syntax varies but the general idea is to ask the assembler to allocate some space. Suppose that the X array needs 100 ints and the Y array 200. Here's how some assemblers do this:
X: defs 100*4
Y: defs 200*4
Others might say ".byte" instead of "defs". The "*4" is because you allocate space in bytes but each int is 4 bytes. Sometimes assemblers have a way of saying "allocate space and fill it with some value". What I've presented here won't do that so to be sure you need to now write the initial values. Let's fill X with 1's and Y with 2's:
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
ylp: st $s0,0($t0)
The comments are kinda redundant but I wanted to re-iterate what I'm doing in the likely event that I've forgotten my MIPS assembler mnemonics or have made a mistake.
Allocating the arrays dynamically is quite a different proposition. Normally there will be an operating system subroutine you call to get a pointer to a chunk of memory of a certain size. If you're really at a low level you'll have to come up with your own scheme. Funnily enough, that itself is a matter of declaring a static array that covers all available memory and then handing off chunks of it as the program asks for it. Then you have to get tricky to keep track of what you've handed off so you can free up chunks.
In either case you'll be given a pointer to the amount of memory requested. Normally you'll need to save that pointer in a memory location but it could live in a register for a simple program. The allocation code might look something like this:
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
Notice how we have to make two steps to get the array address. Before "X" was the address of the memory to use. Now "X" is the address of 4 bytes of memory that contain the address of the array.
The previous initialization code will work as before, but instead of a simple "la $t0,X" you'll have to:
If you're familiar with C, the difference here is the same as "int X;" vs. "int *X = malloc(100 * sizeof(int));". In both cases you can say "X[n]" but behind the scenes C uses the right assembler sequences.