1

Profesor Leopoldo Silva Bijit 18-07-2007

Captulo 2.
Creacin del ambiente de trabajo.
Una vez instalado el compilador cruzado lcc, ste queda en C:\Program Files\lcc\4.1
Conviene crear una subcarpeta para colocar los ejemplos. Sea sta ej.

En la carpeta ej, se crea el archivo cc.bat con el siguiente contenido:
c:\progra~1\lcc\4.1\bin\lcc -S -Wf-target=mips/ultrix %1

Se invoca a cc con un argumento:

C:\Program Files\lcc\4.1\ej>cc nombre.c

Comando que al ser ejecutado en una ventana DOS, permite ejecutar el compilador lcc, el cual
traduce nombre.c a assembler MIPS, dejando el archivo en nombre.asm.

Ntese que en el archivo cc.bat, el %1 se considera el primer argumento. De esta forma al
invocar: cc nombre.c, se reemplaza %1 por nombre.c.

En esta misma carpeta conviene crear un acceso directo a una ventana DOS. Esto puede lograrse
colocando en destino: C:\WINDOWS\system32\cmd.exe
y en Iniciar en: "C:\Program Files\lcc\4.1\ej"

Si adems se crea un acceso directo a la carpeta: C:\Program Files\lcc\4.1\ej es muy sencillo y
rpido desarrollar los ejemplos.
2.1. Funcin principal.
Veremos un primer ejemplo. Con un editor se crea el archivo: uno.c

int main(void)
{
return(0) ;
}

Este es el programa mnimo que puede escribirse en C. Evidentemente, en alto nivel, no produce
un resultado evidente. Sin embargo lo utilizaremos por los conceptos que ilustra.

Un programa en C, requiere una funcin principal, llamada main. En el ejemplo no se pasan
argumentos a la funcin main, por esto se coloca void, que significa vaco, o sin argumentos.
2 Estructuras de Computadores Digitales
Profesor Leopoldo Silva Bijit 18-07-2007
La palabra int, antes del nombre de la funcin, establece el tipo de datos que retorna la funcin.
La accin return, fija el valor del retorno; el entero cero en este caso.
Los parntesis cursivos, delimitan las acciones realizadas por la funcin.

Este programa puede ser compilado en ambiente PC, lo cual genera un archivo uno.exe.
Este archivo es un ejecutable en el ambiente del PC; y su ejecucin no produce ningn efecto
notable. Sin embargo este programa fue traducido al lenguaje de mquina del PC, y luego
cargado en la memoria, y luego ejecutado. Si se desea ver el assembler generado para un
procesador Intel para PC, puede cambiarse el comando cc.bat por:
c:\progra~1\lcc\4.1\bin\lcc -S -v -Wf-target=x86/win32 %1

Al compilar para MIPS, se obtiene el siguiente cdigo assembler, el que queda con el nombre:
uno.asm.

.set reorder
.globl main
.text
.align 2
.ent main
main:
.frame $sp,0,$31
move $2,$0
L.1:
j $31
.end main

Se aprecian una serie de instrucciones que son necesarias en un lenguaje assembler. En ste es
preciso establecer zonas de memoria e indicar el alcance de los smbolos empleados para las
direcciones.

.set reorder permite al assembler reordenar las instrucciones para mejorar el comportamiento.
.globl main define el nombre main como una referencia, y se la considera global.
.text establece que lo que viene a continuacin son instrucciones. Las instrucciones se van
localizando secuencialmente en una zona de la memoria reservada a las acciones.
.align 2 Indica alineamiento de palabra (en este caso). Se mantiene un contador con la direccin
que debe ser asociada al item, el 2 indica que los dos ltimos bits de la direccin deben ser
ceros.
.ent main y .end main indican el inicio y fin de la zona asociada a la funcin main.
main: es un identificador de la direccin que es el punto de entrada a la funcin main. Suelen
denominarse rtulos ( o labels) a estos identificadores.
L.1: Es un identificador colocado automticamente por el ensamblador.
.frame $sp,0,$31 Nos referiremos a esto ms adelante.
mov $2,$0 es una instruccin que mueve el contenido del registro 0 al registro 2.

En MIPS el registro $0 contiene la constante cero. Y el registro $2 de nombre simblico $v0 se
emplea para almacenar los retornos de una funcin.
Creacin del ambiente de trabajo 3
Profesor Leopoldo Silva Bijit 18-07-2007
j $31 es una instruccin de salto indirecto a la direccin almacenada en el registro $31 (de
nombre simblico $ra) que se emplea para almacenar la direccin de retorno desde una funcin.

El mismo texto podra haber sido escrito por un programador en assembler, segn:

.globl main
.text
.align 2
main: move $v0, $zero # return (0)
jr $ra

El programador assembler debe tener una visin del procesador. sta consiste de los registros
disponibles y de las zonas de memoria. Si se carga el programa uno.asm en el Simulador SPIM,
sin habilitar el trap.handler (esto se logra en Simulator: settings desmarcando la casilla
correspondiente). Se visualizan los registros y las zonas de memoria.

Los siguientes datos muestran la visin de un computador que requiere tener un programador
assembler.

Registers
=========================
PC = 00000000 EPC = 00000000 Cause = 00000000 BadVAddr= 00000000
Status = 00000000 HI = 00000000 LO = 00000000
General Registers
R0 (r0) = 00000000 R8 (t0) = 00000000 R16 (s0) = 00000000 R24 (t8) = 00000000
R1 (at) = 00000000 R9 (t1) = 00000000 R17 (s1) = 00000000 R25 (t9) = 00000000
R2 (v0) = 00000000 R10 (t2) = 00000000 R18 (s2) = 00000000 R26 (k0) = 00000000
R3 (v1) = 00000000 R11 (t3) = 00000000 R19 (s3) = 00000000 R27 (k1) = 00000000
R4 (a0) = 00000000 R12 (t4) = 00000000 R20 (s4) = 00000000 R28 (gp) = 10008000
R5 (a1) = 00000000 R13 (t5) = 00000000 R21 (s5) = 00000000 R29 (sp) = 7fffeffc
R6 (a2) = 00000000 R14 (t6) = 00000000 R22 (s6) = 00000000 R30 (s8) = 00000000
R7 (a3) = 00000000 R15 (t7) = 00000000 R23 (s7) = 00000000 R31 (ra) = 00000000

Text Segment
=========================
[0x00400000] 0x00001021 addu $2, $0, $0 ; 9: move $2,$0
[0x00400004] 0x03e00008 jr $31 ; 11: j $31

KERNEL

Data Segment
=========================
DATA
[0x10000000]...[0x10040000] 0x00000000
STACK
[0x7fffeffc] 0x00000000
KERNEL DATA
4 Estructuras de Computadores Digitales
Profesor Leopoldo Silva Bijit 18-07-2007
[0x90000000]...[0x90010000] 0x00000000

Observamos varios registros al inicio, por el momento slo destacamos el registro PC, que
apunta a la instruccin que corresponde ejecutar (es el Program Counter).
Luego 32 registros, con sus nombres numricos y sus equivalentes simblicos.
Notar que el registro sp est iniciado por defecto en 0x7fffeffc.
La zona de texto, por defecto comienza en 0x00400000, es donde se depositan las instrucciones
del programa.

En la zona de texto se advierten cuatro columnas. La primera es la direccin de memoria donde
est almacenada la instruccin. La segunda es el cdigo binario de la instruccin. La tercera es
la descripcin assembler de la instruccin. La cuarta contiene el nmero de la lnea del texto
assembler, seguida del cdigo que figura en el texto generado por el ensamblador.
Los ensambladores suelen disponer de macroinstrucciones; una macroinstruccin assembler
puede generar automticamente una serie de instrucciones de mquina.

En el caso del ejemplo, la instruccin: move $2, $0 es una macro, que puede traducirse a una
instruccin de mquina. Se logra con la instruccin de mquina: addu $2,$0,$0 la cual suma el
registro cero con el registro cero y coloca el resultado en el registro $2.

Tambin: j $31 es una macro que se traduce en la de mquina: salto incondicional indirecto:
jr $31

Que es un salto relativo a registro ( jump relative).

A medida que vamos avanzando irn apareciendo nuevas instrucciones assembler que se
explicarn en detalle.

Por el momento nos hemos dado cuenta de la necesidad de cargar un registro con una constante,
y la forma en que se retorna de una funcin. Para entender en mayor profundidad el llamado a
procedimientos o funciones es preciso describir la invocacin a una funcin en assembler. Se
emplea la instruccin de mquina:

jal nombre_de_funcin.

Donde nombre_de_funcin es un smbolo para un punto de entrada a una funcin; es decir una
direccin del segmento texto.

El mnemnico jal es por jump and link. Es decir enlace a funcin y salto. Esta instruccin
deposita en el registro $ra (return address, $31) la direccin de la instruccin siguiente al
llamado, y coloca en PC la direccin de la primera instruccin de la funcin.

Si ahora se carga el mismo programa, pero con el trap.handler, aparecen nuevos segmentos
ocupados en la memoria. Adems de cargar el cdigo para procesar excepciones, se pasan
argumentos a la funcin main, se setea el PC en la direccin de inicio del segmento texto, y se
agrega una instruccin que invoca al programa principal, con un: jal main.
Los argumentos se pasan en los registros $a0, $a1 y $a2.
Creacin del ambiente de trabajo 5
Profesor Leopoldo Silva Bijit 18-07-2007
Text Segment
=========================
[0x00400000] 0x8fa40000 lw $4, 0($29) ; 112: lw $a0, 0($sp) # argc
[0x00400004] 0x27a50004 addiu $5, $29, 4 ; 113: addiu $a1, $sp, 4 # argv
[0x00400008] 0x24a60004 addiu $6, $5, 4 ; 114: addiu $a2, $a1,4 # envp
[0x0040000c] 0x00c23021 addu $6, $6, $2 ; 115: addu $a2, $a2, $v0
[0x00400010] 0x0c1000a7 jal 0x0040029c [main] ; 116: jal main
[0x00400014] 0x00000000 nop ; 117: nop
[0x00400018] 0x3402000a ori $2, $0, 10 ; 118: li $v0 10
[0x0040001c] 0x0000000c syscall ; 119: syscall

El cdigo que se muestra es de autoarranque, y permite invocar a la funcin main. Se darn
detalles ms adelante. Importa notar la instruccin: jal main

Las otras instrucciones que aparecen se describirn ms adelante.

En la medida que aparecen datos (precedidos por .data) se van asignando en el segmento de
datos; en forma similar se mantiene un contador en la zona de texto.

Una vez que se han asignado todas las instrucciones y datos se conocen todas las direcciones de
los datos y las de las instrucciones a las cuales se puede hacer referencia. Es decir, despus de
una primera pasada por el texto assembler pueden conocerse todos los valores de las
direcciones. En una segunda pasada pueden efectuarse las codificaciones de los campos de las
instrucciones que hacen referencia a direcciones.
2.2. Segmentos en memoria.
Podemos visualizar los siguientes segmentos en que se organiza la asignacin de la memoria.
















Figura 2.1. Segmentos en la memoria.
Direccin Inicio Segmento Contenidos
0x00000000 Reservado uso sistema
0x00400000 Segmento texto. Programa.
0x10000000 Segmento datos
datos inicializados
sdata small inicializados.
bss datos no inicializados
Heap.
Se asigna con sbrk.
Se usa con malloc y free

0x7fffeffc

Stack
0x80000080 Texto Kernel
0x90000000 Datos Kernel

6 Estructuras de Computadores Digitales
Profesor Leopoldo Silva Bijit 18-07-2007
El stack crece hacia arriba (hacia direcciones menores); el heap crece hacia direcciones
mayores. Estas zonas se denominan dinmicas, ya que su ocupacin vara en tiempo de
ejecucin. Es necesario asumir un determinado espacio para estos segmentos.

Slo es necesario cargar de una imagen binaria en disco, las zonas de texto y las de datos
inicializados.

En un ambiente de microcontroladores existen segmentos de memoria adicionales. Para
diferenciar lo que puede grabarse en rom y lo que debe grabarse en ram. En C existen los
calificadores const y volatile para referirse a estas categoras de almacenamiento.
Creacin del ambiente de trabajo 7
Profesor Leopoldo Silva Bijit 18-07-2007

ndice general.
CAPTULO 2. ............................................................................................................................................ 1
CREACIN DEL AMBIENTE DE TRABAJO...................................................................................... 1
2.1. FUNCIN PRINCIPAL.......................................................................................................................... 1
2.2. SEGMENTOS EN MEMORIA.................................................................................................................. 5
NDICE GENERAL. ..................................................................................................................................... 7
NDICE DE FIGURAS................................................................................................................................... 7

ndice de figuras.
FIGURA 2.1. SEGMENTOS EN LA MEMORIA. ................................................................................................... 5