ELO311 Estructuras de Computadores Digitales. Ambiente de Ejecución de Funciones

Transcripción

1 ELO311 Estructuras de Computadores Digitales Ambiente de Ejecución de Funciones Tomás Arredondo Vidal Este material está basado en: material de apoyo del texto de David Patterson, John Hennessy, "Computer Organization & Design", (segunda y tercera edición), Morgan Kaufmann, CA material del curso anterior ELO311 del Prof. Leopoldo Silva material del curso CSE331 de Mary Jane Irving de Penn State

2 Repaso: Organización MIPS hasta ahora src1 addr src2 addr dst addr write data Processor Register File 32 registers ($zero - $ra) 32 bits src1 data src2 data read/write addr 32 Memory words Exec br offset PC 32 Add 32 4 Fetch 32 PC = PC+4 Decode Add 32 ALU 32 read data write data byte address (little Endian) 32 bits word address (binary)

3 Repaso: MIPS ISA hasta ahora Category Instr Op Code Example Meaning Arithmetic add 0 and 32 add $s1, $s2, $s3 $s1 = $s2 + $s3 (R & I format) subtract add immediate 0 and 34 8 sub $s1, $s2, $s3 addi $s1, $s2, 6 $s1 = $s2 - $s3 $s1 = $s2 + 6 or immediate 13 ori $s1, $s2, 6 $s1 = $s2 v 6 Data Transfer (I format) load word store word load byte lw $s1, 24($s2) sw $s1, 24($s2) lb $s1, 25($s2) $s1 = Memory($s2+24) Memory($s2+24) = $s1 $s1 = Memory($s2+25) store byte 40 sb $s1, 25($s2) Memory($s2+25) = $s1 load upper imm 15 lui $s1, 6 $s1 = 6 * 2 16 Cond. Branch (I & R format) br on equal br on not equal set on less than set on less than immediate and beq $s1, $s2, L bne $s1, $s2, L slt $s1, $s2, $s3 slti $s1, $s2, 6 if ($s1==$s2) go to L if ($s1!=$s2) go to L if ($s2<$s3) $s1=1 else $s1=0 if ($s2<6) $s1=1 else $s1=0 Uncond. Jump (J & R format) jump jump register jump and link 2 0 and 8 3 j 2500 jr $t1 jal 2500 go to go to $t1 go to 10000; $ra=pc+4

4 Repaso: Registros MIPS Nombre $zero $v0 - $v1 $a0 - $a3 $t0 - $t7 $s0 - $s7 $t8 - $t9 $gp $sp $fp $ra Numero Registro Uso the constant 0 returned values arguments temporaries saved values temporaries global pointer stack pointer frame pointer return address Debe preservar en llamada? n.a. no no no yes no yes yes yes yes

5 Lenguajes Interpretados vs Compilados Un interpretador es un programa que ejecuta otros programas. Scheme Java bytecode Java C++ C Assembly machine language Fácil de programar Ineficiente para Interpretar Eficiente para interpretar Difícil de programar Traducción de lenguajes es otra opción. En general, se interpreta un lenguaje de alto nivel (e.g. Java) cuando su eficiencia no es critica y se traduce a un lenguaje de nivel mas bajo para mejorar su desempeño.

6 Jerarquía de Traducción del Código C program compiler assembly code assembler object code library routines linker machine code executable loader memory

7 Compilador Transforma el programa C en un programa en asembler Ventajas de lenguajes de alto nivel (e.g. C) Menor numero de líneas de código Mas fácil entender y depurar Los compiladores de hoy pueden producir código asembler casi tan bueno como el de un programador experto, muchas veces mejor para programas grandes Código mas pequeño significa ejecución mas rápida y menor consumo de energía

8 Ensamblador (Assembler) Transforma código assembler en código objeto (e.g. código de maquina) Ventajas del assembler Mucho mas fácil que recordar códigos binarios (e.g op codes) Se puede usar etiquetas para direcciones y dejar que el ensamblador haga los calculos de saltoscan use labels for addresses and let the assembler do the arithmetic Se pueden usar seudo instrucciones (e.g. macros) Hay que recordar que el código de maquina es la realidad que se ejecuta Cuando se considera la eficiencia de cierto código hay que contar las instrucciones reales ejecutadas no el tamaño del código

9 Otras Tareas del Ensamblador Determina direcciones binarias correspondientes a las etiquetas (e.g de saltos y bifurcaciones) Mantiene información de las etiquetas usadas en bifurcaciones y transferencias de datos en una tabla de símbolos Pares de símbolos y direcciones Convierte seudo instrucciones en código asembler legal Usa el registro $at para esto Convierte bifurcaciones a ubicaciones lejanas en una bifurcación seguida de un salto (jump) Convierte instrucciones con valores inmediatos grandes en load upper (e.g. lui) seguido por un or inmediato (e.g. ori) Convierte números especificados en decimal y hex en sus binarios correspondientes Convierte caracteres a los valores binarios especificados por la tabla ASCII

10 Partes de un Archivo Objeto Encabezado de Archivo Objeto: tamaño y posición de los siguientes elementos Modulo Text: código de objeto (e.g. código maquina) Modulo de Data: datos que acompañan al código Datos estáticos datos que duran toda la vida del programa (e.g. globales) Datos dinámicos crecen y se achican a medida que el programa los usa Información de reubicación (Relocation information): identifica instrucciones que están localizados en direcciones absolutas esas que no son relativas a un registro (e.g., jump destination addr) Tabla de símbolos: etiquetas que no están definidas (e.g., referencias a funciones o datos externos) Información para la depuración

11 Organización de Memoria en MIPS (spim) $sp Memory Mem Map I/O f f f f f f f c Kernel Code & Data Stack 7f f e f f fc 2 30 words $gp PC Dynamic data Static data Your Code Reserved OS

12 Enlazador (Linker) Toma todo el código objeto ensamblado previamente y lo enlaza Mucho mas rápido que juntar el código maquina a mano! Decide en el patrón de la ubicación de código y datos para cada segmento de código objeto Cada segmento de código objeto fue ensamblado separadamente y cada uno asume que el comienzo de su código es 0x y que el comienzo de sus datos estáticos es 0x Las direcciones absolutas (e.g. Absolute addresses) tienen que ser reubicadas (e.g relocated) para reflejar el punto de comienzo de cada modulo de código y datos Usa la información en la(s) tablas de símbolos para resolver todas etiquetas indefinidas Bifurcaciones, saltos y direcciones de datos a segmentos externos

13 Cargador (e.g. Loader) Copia el código ejecutable almacenado en disco a la memoria en la dirección de comienzo establecida por el sistema operativo Inicializa los registros de maquina y también el puntero al stack a la primera ubicación libre (0x7ffe fffc) Copia los parámetros (si es que hay) al stack Salta a la rutina de comienzo (e.g. start-up routine) en la dirección del PC 0x on xspim La rutina de comienzo copia los parámetros de main a los registros de argumentos y después llama el código de main con un jal main

14 Ejemplo: foo.c C program: foo.c Compiler Assembly program: foo.s Assembler Object(mach lang module): foo.o Linker lib.o Executable(mach lang pgm): a.out Loader Memory

15 Ensamblador (assembler) Input: Código assembler (e.g., foo.s para MIPS) Output: Código Objeto, (e.g., foo.o para MIPS) Lee y usa Directivos Remplaza seudo instrucciones (Macros) Seudo instrucciones son instrucciones de conveniencia (utilidad) que corresponden a múltiples instrucciones reales (se expanden en machine language a instrucciones reales) Produce código de maquina (Machine Language) Crea archivo objeto (Object File)

16 Directivos Dan instrucciones al ensamblador y depurador.text: Poner items subsecuentes en segmento de texto (machine code).data: Poner items subsecuentes en segmento de datos (representacion binaria de datos en archivo fuente).globl sym: declara sym como global y puede ser referenciado de otros archivos.asciiz str: Almacenar string str en memoria y terminarlo con nulo.word w1 wn: Almacenar los n items en palabras sucesivas de 32-bits en memoria.half h1 hn: Almacenar los n items en ½ palabras sucesivas de 16-bits en memoria.byte b1 bn: Almacenar los n items en bytes sucesivos en memoria.align n: Alinea la memoria para que los datos comiencen en una ubicación correcta dado el tamano de los datos (alinea los datos en una celda de memoria capaz de contener 2 n bytes)

17 Directivos II.frame frame-reg, offset, return_pc_reg Específica el registro a usar para el stack, tamaño del contexto del stack (offset) en palabras y el registro con dirección de retorno. Ejemplo:.frame sp, 24, ra Indica un stack usando sp de 24 bytes y dirección de retorno ra.mask mask_addr, offset Declara cuales registros han sido guardados, permitiendo que el depurador localice variables guardadas en el stack. offset indica la ubicación del registro almacenado en la direccion mas alta relativa al puntero del frame. Ejemplo:.mask 0x , -4 Indica que se guardo el registo $31 en el stack y que el registro almacenado en la dirección mas alta (highest address) esta a 4 bytes menos que el frame pointer (i.e. el TOF o Top Of Frame).

18 Reemplazo de seudo instrucciones Pseudo: Real: subu $sp,$sp,32 addiu $sp,$sp,-32 sd $a0, 32($sp) mul $t7,$t6,$t5 move $t0, $t6 sw $a0, 32($sp) sw $a1, 36($sp) mult $t6,$t5 mflo $t7 addu $t0, $t6, $zero o or $t0, $t6, $zero addu $t0,$t6,1 ble $t0,100,loop addiu $t0,$t6,1 slti $at,$t0,101 bne $at,$0,loop la $t1, i (en 0x ) lui $t1,0x1001 ori $t1,$t1,0x0004 Nota: macro mul $t7,$t6,$t5 significa $t7 = $t6 * $t5 (resultado en registro $t7 de 32bits) mult $t6,$t5 significa {Hi, Lo} = $t6 * $t5 (guardando resultado en regs. Hi,Lo) se rescata el resultado usando mflo y mfhi, mult no chequea overflow

19 Variables Se denominan variables locales a las definidas dentro de una función. En assembler se requiere tener una zona de la memoria en que se almacenarán estas variables. De tal modo que cuando se ingresa a una función, se crea el espacio en el stack; y cuando se sale de la función el espacio es devuelto, y puede ser reutilizado por otras variables locales. El compilador intenta emplear el máximo de variables locales localizadas en registros (e.g. $s0, $s1,, $s7, $t0 ) Las variables locales que deseen ser almacenadas en registros, se emplean los registros $sn (pero deben ser preservados sus contenidos antes de ser empleados por la función, y recuperados sus valores originales antes de salir de la función) esto es por si otras funciones necesitan los valores previamente guardados en $sn. Durante la ejecución pueden emplearse libremente los registros $tn Los argumentos se pasan en los registros $a0 hasta $a4 Los valores de retorno usan registros $v0 y $v1

20 Ejemplo: Un programa simple Este ejemplo, en C, muestra un programa simple: int i = 0; void main(void) { i = 5; }

21 Ejemplo: Un programa simple (cont) En assembler:.data 0x # comienzo segmento datos i:.word 0.text.globl main main: # inicia variable i, en zona estática, con constante 5. li $t3, 5 # t3=5 Macro que puede escribirse: # ori $t3,$zero,5

22 Ejemplo: Un programa simple (cont) En assembler: la $t0, i # t0=&i t0 es un puntero. Apunta a # variable i. # sin usar macro la: lui $t0, 0x1001 # ori $t0, $t0, 0x0000 sw $t3, 0($t0) # *t0=t3 Escribe en lo que apunta t0: i=5 # Los 2 comandos anteriores pueden escribirse con macro: sw $t3, i($zero) jr ra

23 Ejemplo: Un programa simple2 El siguiente programa declara algunas variables int i1 = 0, i2 = 1; int arr[5] = { 0, 1, 2, 3, 4}; char ch[] = "Hola"; int main(void) { // como j1 y j2 no se usan int j1, j2; // lcc no guarda espacio en return(0); // el stack para ellas }

24 Ejemplo: Un programa simple2 (cont) Version en assembler.set reorder.globl i1.sdata.align 2 i1:.word 0x0.globl i2.sdata.align 2 i2:.word 0x1 # Permite que el assembler reordene instrucciones # i1 es una referencia global # small data define memoria en una region de 64KB # alineamiento de palabra

25 Ejemplo: Un programa simple2 (cont)....globl arr.data.align 2 arr:.word 0x0.word 0x1.word 0x2.word 0x3.word 0x4.globl ch.data.align 0 ch:.byte 72.byte 111.byte 108.byte 97.byte 0 # arr es una referencia global # data contiene memoria con simbolo que se direccionan # con 32 bits # ch es una referencia global

26 Ejemplo: Un programa simple2 (cont)....globl main # main es una referencia global.text # esta region es de instrucciones (codigo).align 2.ent main # inicio de funcion main main:.frame $sp,0,$31 addu $2,$0, $0 # setear valor de retorno: $v0=0 L.1: jr $31 # retornar de la funcion: jr $ra.end main # fin de funcion main # frame de funcion main de tamaño zero (no se usan)

27 Ejemplo: Un programa simple2 (versión 2) El siguiente programa declara algunas variables int i1 = 0, i2 = 1; int arr[5] = { 0, 1, 2, 3, 4}; char ch[] = "Hola"; int main(void) { int j1=0; // guarda espacio en el stack j1=j1 + 5; return(j1); }

28 Ejemplo: Un programa simple2 (cont) Version en assembler.set reorder.globl i1.sdata.align 2 i1:.word 0x0.globl i2.sdata.align 2 i2:.word 0x1 # Permite que el assembler reordene instrucciones # i1 es una referencia global # small data define memoria en una region de 64KB # alineamiento de palabra

29 Ejemplo: Un programa simple2 (cont)....globl arr.data.align 2 arr:.word 0x0.word 0x1.word 0x2.word 0x3.word 0x4.globl ch.data.align 0 ch:.byte 72.byte 111.byte 108.byte 97.byte 0 # arr es una referencia global # data contiene memoria con simbolo que se direccionan # con 32 bits # ch es una referencia global

30 Ejemplo: Un programa simple2 (cont)....globl main # main es una referencia global.text # esta region es de instrucciones (codigo).align 2.ent main # inicio de funcion main main:.frame $sp,4,$31 # frame de funcion main de cuatro palabras addu $sp,$sp,-4 # setear stack.mask 0x ,-4 # se guarda el registro $30 ($fp usado como $s8) sw $30,0($sp) # guardar $fp en el stack : 0($sp) move $30,$0 # $pf = 0 la $30,5($30) # $fp = $fp + 5 addu $2,$30, $0 # setear valor de retorno: $v0=$fp L.1: lw $30,0($sp) # restaura $fp del stack addu $sp,$sp,4 # restaura el stack jr $31 # retornar de la funcion: jr $ra.end main # fin de funcion main

31 Llamadas al sistema Para llamar al sistema operativo se usa la llamada syscall. syscall tambien se usa para hacer operaciones en punto flotante con el coprocesador. En el caso del MIPS, el coprocesador de punto flotante es el número 1. Existen 32 registros de punto flotante de 32 bits cada uno. Para manipular doubles se emplean registros pares; el par más el impar siguiente forman el espacio para el doble.

32 Llamadas al sistema (cont) Se ilustran algunas instrucciones para usar con el coprocesador Cop. z (0...3): lwcz Reg, 0($t2) #Load Word into Cop. z register Reg swcz Reg, 0($t2) #Store Word from Cop. z register Reg mfcz CPSrc, CPUDestt #Move from to Coproc. z to CPU CPdest mtcz CpuSrc, CPdest #Move from CpuSrc To Coproc.z reg. CPdest bczt label #Branch to label if Coprocessor z flag is set (True) bczf label #Branch to label if Coprocessor z flag not set (False) #Se emplean después de comparaciones en punto flotante

33 Ejemplo: Sumar dos números El siguiente segmento en C, produce la suma de dos números en punto flotante: #include <stdio.h> float x = 1.1; float y = 2.2; float z1, z2; int main (void) { z1 = x + y; printf("%f\n",z1); } z2 = x * y; printf("%f\n",z2); return(0);

34 Ejemplo: Sumar dos números (cont) Se traslada al siguiente código assembler:.data x:.float 1.1 # Variables en segmento de datos y:.float 2.2 # 0.22e+1 en notación científica. z1:.float 0.0 z2:.float 0.0 newline:.asciiz "\n".text.globl main main: la $t0, x # t0 = &x lwc1 $f0, 0($t0) # f0 = x (lectura desde memoria) la $t0, y lwc1 $f2, 0($t0) # f2 = y add.s $f4, $f0, $f2 # f4 = x + y

35 Ejemplo: Sumar dos números (cont) la $t0, z1 swc1 $f4, 0($t0) # t0 = &z1 # *t0 = f4 z1 = x + y (escritura en memoria) mov.s $f12, $f4 # argumento en $f12 li $v0,2 # print float syscall la $a0, newline # argumento en $a0 li $v0,4 # print string syscall mul.s $f4, $f0, $f2 la $t0, z2 swc1 $f4, 0($t0) # f4 = x * y # t0 = &z2 # *t0 = f4 z2 = x * y

36 Ejemplo: Sumar dos números (cont) mov.s $f12, $f4 # argumento en $f12 li $v0, 2 # print float syscall la $a0, newline # argumento en $a0 li $v0, 4 # print string syscall li $v0, 10 # exit Retorno al monitor. syscall Notar que se emplean registros pares para flotantes en simple precisión. El llamado número 10 al sistema retorna a la primera instrucción del trap handler, que opera como un monitor( o sistema operativo primitivo).