[Solved] Assembly MIPS: Nested loops

It surely got a bit tricky when I tried to write some code that would print five lines of the asterisk symbol times 4 in each one.

****
****
****
****

So I thought a nested loop could save the day.
Boy I was wrong.

So I made an inner loop for the asterisks and an outer loop for the spaces as below:

.text
.globl main
main:
add $t0, $zero, $zero   #i counter for the inner loop
add $t2, $zero, $zero   #j counter for the outer loop

outerloop:

    innerloop:

        slti    $t1, $t0, 4     #while (i<4)
        beq     $t1, $zero, innerexit

        li      $v0, 11         #printf("*");
        la      $a0, '*'
        syscall

        addiu   $t0, $t0, 1     #i++

    j innerloop
    innerexit:

slti    $t3, $t2, 5     #while (j<5)
beq     $t3, $zero, outerexit

li      $v0, 11         #printf("
");
la      $a0, '
'
syscall

addiu   $t2, $t2, 1     #j++

j outerloop
outerexit:

li  $v0, 10
syscall

But the output gives me just one line:

****

What’s the matter with the outer loop?

Enquirer: Coursal

||

Solution #1:

change the 5 on line number 23(slti $t3, $t2, 5) to 4 since loop starts from 0 , and add ( add $t0, $zero, $zero) after syscall on line number 28 to reinitialise i value.

.text
.globl main
main:
add $t0, $zero, $zero   #i counter for the inner loop
add $t2, $zero, $zero   #j counter for the outer loop

outerloop:

    innerloop:

        slti    $t1, $t0, 4     #while (i<4)
        beq     $t1, $zero, innerexit

        li      $v0, 11         #printf("*");
        la      $a0, '*'
        syscall

        addiu   $t0, $t0, 1     #i++

    j innerloop
    innerexit:

slti    $t3, $t2, 4     #while (j<5)
beq     $t3, $zero, outerexit

li      $v0, 11         #printf("
");
la      $a0, '
'
syscall
add $t0, $zero, $zero
addiu   $t2, $t2, 1     #j++

j outerloop
outerexit:

li  $v0, 10
syscall
Respondent: Khaulah

Solution #2:

The simplest way would be to use the write-string system call N times, with a non-nested loop. (Well arguably making one long string containing all the lines would be even “simpler”, but less maintainable, and bad for the size of your program with large N).

Note the use of down-counters, counting down towards zero so we can bne against $zero. This is idiomatic for asm, and so is putting the conditional branch at the bottom of the loop. Especially for any loop where you know the trip-count is guaranteed to be at least 1. (When that’s not the case, you’d normally use a branch outside the loop to skip it if needed.)

## Tested, works in MARS 4.5
.data
line: .asciiz "****
"

.text
.globl main
main:
   li  $t0, 4     # row counter
   li  $v0, 4     # print string call number
   la  $a0, line

 .printloop:
   syscall           # print_string has no return value, doesn't modify v0
   addiu  $t0, $t0, -1
   bnez   $t0,  .printloop           # shorthand for BNE $t0, $zero, .printloop

   li  $v0, 10       # exit
   syscall

You could generate the string in a temporary buffer, with a count from a register in a separate loop before the print loop. So you can still support runtime-variable row and column counts, with two sequential loops instead of nested.

With a buffer aligned by 4, we can store a whole word of 4 characters at once so that loop doesn’t have to run as many iterations. (li reg, 0x2a2a2a2a takes 2 instructions but li reg, 0x2a2a only takes one, so going by 2 with sh would make the code smaller).

.text
.globl main
main:
.eqv    WIDTH, 5
.eqv    ROWS, 4

   addiu  $sp, $sp, -32         # reserve some stack space.    (WIDTH&-4) + 8   would be plenty, but MARS doesn't do constant expressions.
   move   $t0, $sp
   
   addiu  $t1, $sp, WIDTH       # pointer to end of buf = buf + line length., could be a register
   li     $t2, 0x2a2a2a2a           # MARS doesn't allow '****' or even '*' << 8 | '*'
 .makerow:                  # do{
   sw     $t2, ($t0)          # store 4 characters
   addiu  $t0, $t0, 4         # p+=4
   sltu   $t7, $t0, $t1
   bnez   $t7, .makerow     # }while(p < endp);
# overshoot is fine; we reserved enough space to do whole word stores
   li     $t2, '
'
   sb     $t2, ($t1)
   sb     $zero, 1($t1)     # terminating 0 after newline.  Unfortunately an sh halfword store to do both at once might be unaligned

   move   $a0, $sp
   li     $t0, ROWS
   li     $v0, 4             # print string call number

 .printloop:
   syscall                   # print_string has no return value, doesn't modify v0
   addiu  $t0, $t0, -1
   bnez   $t0,  .printloop           # shorthand for BNE $t0, $zero, .printloop.      # }while(--t != 0)


## If you were going to return instead of exit, you'd restore SP:
#  addiu $sp, $sp, 32

   li  $v0, 10       # exit
   syscall

As expected, this prints 5 asterisks on every row.

*****
*****
*****
*****

Generally (in real systems) a system-call is much more expensive than normal instructions, so preparing a single large buffer with multiple newlines would actually make sense. (The overhead of a system call dwarfs the difference between writing 1 vs. 5 or even 20 bytes, so even though calling print_string instead of print_char is kind of hiding work inside the system call, it’s justified.)

In that case you probably would want nested loops, but with sb / addiu $reg, $reg, 1 pointer-increment instead of syscall. Only make one system call at the very end.

Or a loop to store all the * characters 4 at a time (for ROWS * COLS / 4 rounded up iterations), then another loop that inserts the
'
newlines where they belong. This lets you get all the data into memory with fewer instructions than doing everything in order 1 byte at a time. (For very large row*col counts, you would probably limit your buffer size to 4 or 8 kiB or something, so your data is still in cache when the kernel’s system call handler reads it to copy it to wherever it needs to be.)


BTW, in C terms, the print char system call is more like putchar('*'), not printf("*"). Note that you’re passing it a character by value, not a pointer to a 0-terminated string.

Respondent: Peter Cordes

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .

Leave a Reply

Your email address will not be published.