MIPS: The Equivalent of la instruction without using pseudo codes?

Question

The reference says the pseudo code for la (load address) is translated to:

Pseudo : la $1, Label   

lui $1, Label[31:16]
ori $1,$1, label[15:0]

Answer 1

That's a really good question, where I came myself to a possible solution. The answer above doesn't work unconditionally.

Actually, it should be possible to say, where you want your data segment to be located (SPIM for example allows you to do that). The .data directive takes one optional argument, the 32-bit address where this data segment should be located. This way exception handlers are written (only using .kdata instead of .data).

An example:

.data 0x10001000                 #remember this location
    .align 0
    .asciiz "MIPS IS GREAT!"     #this is at offset 0

.text
    .align 2
    .globl main
main:                            #let's assume we've got no arguments
    addiu $sp, $sp, -24          #subroutine prolog
    sw $ra, 16($sp)
    sw $fp, 10($sp)
    addiu $fp, $sp, 20

    ori $v0, $0, 4
    lui $a0, 0x1000              #sole argument must be str pointer
    ori $a0, $a0, 0x1000
    syscall                      #print STR out on console

    lw $ra, 16($sp)              #subroutine epilog
    lw $fp, 10($sp)
    addiu $sp, $sp, 24
    jal

I'm actually not sure, if this is the best solution but it is the only solution I can think of (even without using virtual addressing modes i.e. labels for load or store instruction) and this idea should work (whether my code example works, I don't know, I haven't tested it).

EDIT: I just have played around and discovered a really awesome trick which allows us to also load the label in registers without any pseudo instruction and with natural addressing mode. My example:

.data 0x10001000
        .word LABEL
LABEL:  .asciiz "Get LABEL to print this C string."

.text
    .align 2
    .globl main
#test if it loads LABEL
main:
    lui $4, 0x1000
    ori $4, $4, 0x1000
    lw $4, 0($4)
    ori $2, $0, 4
    syscall

In SPIM it assembles fine! A look at the memory at 0x10001000 shows, 0x10001004 is stored! This approach creates a pointer in memory. I'd recommend to place the pointers in front of other variable length data so that you can calculate easily the offset of the pointers.