• i, j son enteros.

• c es un caracter.

• s es un puntero a un char (un string).

• Las variables están mapeadas a los registros $s0 - $s7 (en orden de aparición).

• Go-to
• En MIPS -> saltos incondicionales

• Ciclos y condicionales (if-then-else, for, while...)
• En MIPS -> saltos condicionales

• Llamadas a funciones y algunas excepciones
• En MIPS -> jump-and-link, jump-register

• Punteros a funciones, algunas excepciones
• En MIPS -> jump-and-link-register

 j label

goto label; ...label: code

• Tenemos
• beq             -   Branch if equal
  
• bne             -   Branch if not equal
• bgtz            -   Branch if greater than zero
• bgez           -   Branch if greater or equal than zero
• bltz             -   Branch if less than zero
• blez            -   Branch if less or equal than zero

• Limitados a saltos no mayores a 2^15 instrucciones.

if(i != j){    code;
}

if(i == j){    code_1} else {    code_2}

bne $s0 $s1 else
      code_1
      j done
else:       code_2
done:

switch(c){     case 'a': code_1;                break;
          case 'b': code_2;
          case 'c': code_3;               break;
          default : code_4;
}

li  $t0 'a'
beq $t0 $s0 a_case
li  $t0 'b'
beq $t0 $s0 b_case

li  $t0 'c'
beq $t0 $s0 c_case
j default

a_case:       code_1              j done
b_case:                     code 2
c_case:       code 3
              j done
default:               code_4done:

do { 
     code;
     i++;} while(i < j)

do_start:       code
      addi $s0 $s0 1
      blt  $s0 $s1 do_start

int i = 42;
while(i != 0){
      i--;
}

li $s0 42test:      beq $s0 $0 done      subi $s0 $s0 1      j testdone:

for(i = 0; i < j; i++){
      code;
}

li $s0 0test:      beq $s0 $s1 done      code      addi $s0 $s0 1      j testdone:

• slt - Set less than
• sltu, slti, sltui.

• Si la condición
• es verdadera, asigna 1 a un registro.
• es falsa, asigna 0 a un registro.

# $t0 = ($s0 < $s1) ? 1 : 0

slt $t0 $s0 $s1

• Comúnmente se implementan con S.C.E
• Short-circuit-evaluation

i = (s != NULL) && (*s)

      sne $t0 $s1 $zero   # $t0 = s!=NULL
      beqz $t0 skip       # ya es falso
      lw   $t0 0($s1)
      sne  $t0 $t0 $zero  # $t0 = (*s) != '\0'
skip:       add  $s0 $t0 $zero  # $s0 = $t0

• ¿Qué implica una llamada a una función?
• Saltar a una instrucción
• Registrar a dónde debemos regresar.
• Regresar a la instrucción correcta.

• Algunas arquitecturas implementan un stack de llamadas
• Y agregan intrucciones especiales.
  
• Que permiten entrar o salir.
  
• Puede ser algo complejo.

 jal label

• Transfiere el control (salta) a la instrucción indicada por la etiqueta
• Al igual que la instrucción j.

jr rs

• Transfiere el control (salta) a la instrucción indicada por la dirección en el registro rs.

.data
        bar_str: .asciiz ”- bar\n”
        foo_str: .asciiz ”foo -"
.text
        main:                jal foo
                puts bar_str
                j done                ...
        foo:                     puts foo_str
                jr $ra        done:                ...