sistema de simulaci on para un microcontrolador...

Sistema de simulacion para unmicrocontrolador Freescale MCore

basado en GDB

Jose Miguel Benıtez AlvarezTutor: Antonio Luque Estepa

9 de julio de 2005

Prefacio

Se presenta en este documento el Proyecto Final de Carrera de la titula-cion Ingenierıa de Telecomunicacion, realizado por Jose Miguel BenıtezAlvarez bajo la supervision de Antonio Luque Estepa.

Este proyecto ha tenido por objeto la realizacion de un sistema de simu-lacion mediante software libre para un microcontrolador MCore de Freescalebasado en las herramientas de desarrollo GNU, en concreto, en el depuradorGDB.

La estructura del documento es la siguiente:

Capıtulo 1 Introduccion que presenta brevemente el objetivo de este pro-yecto y las razones que han motivado su realizacion.

Capıtulo 2 Se muestra a continuacion una vision completa del proyecto,explicando los conceptos generales de cada una de las partes que locomponen.

Capıtulo 3 Esta seccion se centra en la biblioteca GCA, desarrollada co-mo interfaz de comunicacion con el depurador de GNU. Se detallanaquı una por una todas las funciones que componen dicha interfaz.

Capıtulo 4 Analisis de las modificaciones que se han realizado al simula-dor de GDB para el microprocesador MCore de Freescale, tanto en loque atane a la gestion de la memoria como a la inclusion de disposi-tivos perifericos para conformar la estructura de simulacion para unmicrocontrolador completo.

Capıtulo 5 Seccion que presenta brevemente una aplicacion grafica de si-mulacion que hace uso de la biblioteca GCA y pone de relieve su fun-cionalidad y potencia.

Capıtulo 6 Seccion final donde se muestra paso a paso la simulacion deun sencillo programa de ejemplo utilizando la aplicacion grafica antespresentada.

4 Prefacio

Apendice Se proporciona, finalmente, el codigo fuente de la librerıa por sise desea estudiarlo con mas detalle.

Indice general

Prefacio 3

1. Introduccion 11

2. Estructura general del sistema 132.1. Simulador del microprocesador . . . . . . . . . . . . . . . . . . 132.2. Simulacion de perifericos . . . . . . . . . . . . . . . . . . . . . 142.3. Interfaz de usuario . . . . . . . . . . . . . . . . . . . . . . . . 15

3. Comunicacion con GDB 173.1. Librerıa GCA . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.2. API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3.2.1. gca-session.h . . . . . . . . . . . . . . . . . . . . . . . . 213.2.2. gca-callback.h . . . . . . . . . . . . . . . . . . . . . . . 253.2.3. gca-list.h . . . . . . . . . . . . . . . . . . . . . . . . . . 263.2.4. gca-micro.h . . . . . . . . . . . . . . . . . . . . . . . . 293.2.5. gca-breakpoint.h . . . . . . . . . . . . . . . . . . . . . 303.2.6. gca-command.h . . . . . . . . . . . . . . . . . . . . . . 383.2.7. gca-data.h . . . . . . . . . . . . . . . . . . . . . . . . . 423.2.8. gca-file.h . . . . . . . . . . . . . . . . . . . . . . . . . . 473.2.9. gca-stop.h . . . . . . . . . . . . . . . . . . . . . . . . . 483.2.10. gca-program-flow.h . . . . . . . . . . . . . . . . . . . . 493.2.11. gca-variable.h . . . . . . . . . . . . . . . . . . . . . . . 533.2.12. gca-argument.h . . . . . . . . . . . . . . . . . . . . . . 543.2.13. gca-stack-frame.h . . . . . . . . . . . . . . . . . . . . . 553.2.14. gca-target.h . . . . . . . . . . . . . . . . . . . . . . . . 61

4. Modificaciones al simulador de GDB 654.1. Simuladores en GDB . . . . . . . . . . . . . . . . . . . . . . . 65

4.1.1. Interfaz de los simuladores en GDB . . . . . . . . . . . 664.1.2. Stand-alone simulation . . . . . . . . . . . . . . . . . . 70

6 INDICE GENERAL

4.1.3. BFD . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724.1.4. Formatos ejecutables: ELF . . . . . . . . . . . . . . . . 744.1.5. Enlazador . . . . . . . . . . . . . . . . . . . . . . . . . 74

4.2. Cambios introducidos en el simulador . . . . . . . . . . . . . . 764.2.1. Gestion de la memoria . . . . . . . . . . . . . . . . . . 774.2.2. Inclusion de dispositivos perifericos . . . . . . . . . . . 804.2.3. Puertos . . . . . . . . . . . . . . . . . . . . . . . . . . 874.2.4. SCI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

5. Aplicacion grafica KMcsim 995.1. Detalles del diseno con Qt/KDE . . . . . . . . . . . . . . . . . 99

5.1.1. Modelo vista-documento . . . . . . . . . . . . . . . . . 1005.1.2. Detalles especıficos . . . . . . . . . . . . . . . . . . . . 101

6. Ejemplo de aplicacion 1056.1. Programa para el microcontrolador . . . . . . . . . . . . . . . 1056.2. Simulacion paso a paso . . . . . . . . . . . . . . . . . . . . . . 114

A. Codigo fuente de la biblioteca GCA 119A.1. common.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119A.2. string.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122A.3. xmalloc.c, xstrdup.c, xstrstr.c . . . . . . . . . . . . . . . . . . 130A.4. result.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133A.5. gca-session.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146A.6. gca-list.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159A.7. gca-callback.h . . . . . . . . . . . . . . . . . . . . . . . . . . . 164A.8. gca-micro.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167A.9. gca-breakpoint.h . . . . . . . . . . . . . . . . . . . . . . . . . 168A.10.gca-command.h . . . . . . . . . . . . . . . . . . . . . . . . . . 181A.11.gca-data.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188A.12.gca-file.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198A.13.gca-stop.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203A.14.gca-program-flow.h . . . . . . . . . . . . . . . . . . . . . . . . 205A.15.gca-variable.h . . . . . . . . . . . . . . . . . . . . . . . . . . . 210A.16.gca-argument.h . . . . . . . . . . . . . . . . . . . . . . . . . . 214A.17.gca-stack-frame.h . . . . . . . . . . . . . . . . . . . . . . . . . 217A.18.gca-target.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227

Bibliography 231

Indice de figuras

5.1. Menu de acciones para controlar la ejecucion. . . . . . . . . . 1025.2. Pagina de configuracion para seleccionar los registros del micro.1035.3. Pagina de configuracion para seleccionar la zona de memoria. . 104

6.1. Asistente para la localizacion del simulador. . . . . . . . . . . 1146.2. Selector de ficheros para cargar un ejecutable dentro de la

aplicacion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1156.3. Informacion sobre los puntos de ruptura insertados en el codigo.1166.4. Programa en ejecucion con informacion sobre la memoria, los

registros y la pila. . . . . . . . . . . . . . . . . . . . . . . . . . 117

8 INDICE DE FIGURAS

Indice de cuadros

2.1. Comparacion de ciclos de reloj. . . . . . . . . . . . . . . . . . 13

10 INDICE DE CUADROS

Capıtulo 1

Introduccion

Los microcontroladores son las piezas fundamentales de los sistemas em-potrados, que en los ultimos tiempos se han convertido en casi ubicuos. Unmicrocontrolador es un dispositivo electronico parecido a un microprocesa-dor, pero mas completo que este en muchos aspectos. Al igual que un mi-croprocesador, un microcontrolador (uC) posee una unidad aritmetico-logica(ALU), y una serie de registros internos. Estos elementos forman la unidadcentral de proceso (CPU). Un microprocesador no contiene nada mas (sal-vo quiza memoria de almacenamiento), pero un microcontrolador integra enel mismo circuito integrado una serie de perifericos, que lo dotan de fun-cionalidad completa. Estos perifericos son, por ejemplo, contadores, puertosserie, temporizadores, memorias, puertos de E/S, etc. Un microcontroladorno necesita de mas componentes electronicos para funcionar, mientras que unmicroprocesador sı. Es por esto, que los microcontroladores son el componen-te mas utilizado para construir sistemas empotrados, en los que el tamano yel coste son factores determinantes [4].

Normalmente, estos sistemas empotrados carecen de los interfaces quepresentan los ordenadores de proposito general, como teclado o monitor, porlo que la programacion de los microcontroladores que los integran no pue-de hacerse directamente. Lo usual es escribir y compilar el programa en unordenador personal y luego descargar una imagen binaria del mismo a lamemoria interna del microcontrolador. La depuracion de los programas esextremadamente difıcil en un sistema empotrado, al no poseer este los me-canismos de interfaz con el exterior antes descritos, siendo muy habitual elproceso de prueba y error para depurar un programa. Conscientes de esteproblema, muchos fabricantes de microcontroladores han desarrollado emu-ladores, dispositivos que, situados en el sistema electronico en el mismo lugaren que estarıa el microcontrolador, y conectados a su vez a un PC, se com-portan desde el punto de vista electrico de la misma forma que lo harıa el

12 Introduccion

microcontrolador que se pretende emular. Estos emuladores suelen tener unprecio prohibitivo, que los hace inviables para muchas aplicaciones.

El proceso de depuracion usando el hardware real es caro y tedioso. Secomprende la necesidad de contar con un simulador que se ejecute enteramen-te en un PC y que sea capaz de leer e interpretar un programa compilado parael microcontrolador, y proporcionar las mismas salidas que proporcionarıa es-te. Usando simuladores, el ciclo de desarrollo se puede acortar sensiblementey el coste fijo asociado al proyecto es bastante menor.

En este documento se describe un sistema de simulacion desarrollado pa-ra los microcontroladores de la familia MCore de Freescale (MMC2000). Elsistema esta basado en las herramientas GNU, como GCC y GDB que han si-do aportadas por el fabricante del microcontrolador, a las que se han anadidolas rutinas suficientes para poder simular el microcontrolador completo.

Capıtulo 2

Estructura general del sistema

2.1. Simulador del microprocesador

La companıa Freescale, fabricante del microcontrolador, proporciona unsimulador de la CPU del mismo para ser embebido en el depurador GDB. Porotra parte, algunos empleados de la misma han contribuido a la comunidadde software libre una version del compilador GCC y del resto de herramientasde desarrollo GNU adaptadas para producir codigo MCore.

El simulador aportado por Freescale se limita exclusivamente a la CPUdel microcontrolador, por lo que es apropiado unicamente para calcular lostiempos de ejecucion de un determinado programa. En este aspecto es muypreciso, como se puede comprobar en la tabla 2.1, en la que se comparan losciclos de reloj que toma la ejecucion de varios programas en el simulador delque se trata con los que toma segun las pruebas internas de Freescale. Losprogramas elegidos son algoritmos de ordenacion, resolucion de ecuacionesy compresion de datos. La companıa afirma que la precision del simuladorpara cualquier programa esta en torno al 0.5 %.

ciclos reales ciclos sim diferenciaPrograma 1 366101 366102 0.00 %Programa 2 4461476 4462938 0.03 %Programa 3 255551 255547 0.00 %

Cuadro 2.1: Comparacion de ciclos de reloj.

El concepto central del sistema descrito en este documento es la construc-cion, en torno al simulador de Freescale, un sistema que sea capaz de simularlos perifericos del microcontrolador.

14 Estructura general del sistema

Para lograr el objetivo descrito, es necesaria una simulacion adicional a lade la CPU. Hay que simular todos los perifericos internos al microcontrolador,como contadores, puertos, etc.

2.2. Simulacion de perifericos

La familia MCore consta de varios microcontroladores diferentes cons-truidos alrededor de una CPU RISC (Reduced Instruction Set Code). Sucaracterıstica mas destacada es el bajo consumo, lo que los hace ideales paraaplicaciones moviles o que necesiten baterıas. Cada miembro de la familiaes ligeramente diferente en los perifericos que incorpora, pero en general secuenta con puertos serie sıncronos (SPI) y asıncronos (SCI), memoria Flash,memoria RAM estatica (SRAM), temporizadores, convertidores analogico-digitales, y puertos digitales de entrada/salida, entre otros.

La principal caracterıstica de la simulacion de los perifericos, al igual quela del resto del sistema, es su modularidad. No todos los microcontrolado-res de esta familia presentan los mismos dispositivos perifericos, de maneraque el diseno de estos dispositivos sigue un patron modular. Los elementosperifericos se representan como modulos independientes al microcontrolador,para conseguir ası una estructura flexible que puede simular cualquier ele-mento microcontrolador de la familia. De esta forma, ademas, se facilita laincorporacion de nuevos perifericos al simulador.

Para que la flexibilidad no derive en problemas de incompatibilidad entrelos distintos elementos que forman el simulador se ha definido una interfazde acceso a los dispositivos perifericos. La estandarizacion del acceso a estosperifericos permite que la adicion de un nuevo elemento que se ajuste a estainterfaz definida no implique cambios adicionales en el resto de la estructuradel simulador.

La combinacion del diseno modular en la simulacion de los perifericosjunto con la definicion de un acceso estandar a ellos consigue que el micro-procesador vea a los perifericos como cajas negras, sin que tenga que conocernada acerca de cual es su estructura interna o como se ha implementadosu funcionalidad. Lo unico que conoce el microprocesador es la manera deacceder a esas cajas negras.

La directriz que suele seguir Freescale en la arquitectura de sus micro-controladores es mapear todos los perifericos en memoria, de manera que nohay diferencia entre acceder a una posicion de memoria y acceder a un dis-positivo externo, del mismo modo que no hay diferencia entre acceder a unperiferico y acceder a otro. Esta arquitectura viene a redundar en la idea deque el microprocesador considere a los perifericos como cajas negras que se

2.3 Interfaz de usuario 15

distinguen entre sı tan solo por la direccion mediante la cual son accedidas.Este ha sido, pues, el diseno que se ha seguido en la definicion de la inter-

faz de acceso a los perifericos, por ser la que habitualmente emplea Freescale,pero podrıa cambiarse facilmente a otras arquitecturas usadas por otros fa-bricantes, como puede ser Intel, que diferencia entre accesos a memoria yaccesos a perifericos.

2.3. Interfaz de usuario

El uso de interfaces de usuario se hace especialmente util en el desarrollode sistemas empotrados, pues estos carecen de mecanismos de interfaz con elexterior como ocurre con los sistemas para computadores. De esta manera,el poder visualizar de algun modo cuales son las salidas que proporcionanlos programas que ejecuta el microcontrolador se convierte en una ayudainestimable para el desarrollo de tales sistemas.

La interfaz de usuario desarrollada refleja la doble vertiente de la natura-leza del desarrollo de sistemas empotrados. Por un lado, dispone de todos loselementos habituales de un sistema de depuracion convencional para progra-mas que se ejecuten en computadores, como puede ser la ejecucion controladao la posibilidad de comprobar el valor de las variables que conforman el pro-grama.

Por otro lado, la incorporacion al simulador de los dispositivos perifericosque forman el microcontrolador hace necesario que la interfaz de usuario nosolo trabaje con el programa que ejecuta el microprocesador, sino que tam-bien muestre el estado de los distintos perifericos. De esta manera, podemoscomprobar, por ejemplo, el estado del puerto serie o de los distintos registrosde salida.

La interfaz de usuario es la capa mas externa en la estructura del sistemadesarrollado por los autores. Se trata de una sencilla aplicacion grafica quepone a disposicion del usuario toda la potencia y capacidad que ofrece la APIde comunicacion con GDB. Dicha aplicacion esta implementada con la com-pleta librerıa de componentes Qt que ofrece Trolltech [7]. Se ha elegido estalibrerıa por la enorme flexibilidad y funcionalidad que provee el mecanismode signals y slots para la comunicacion entre objetos.

Hay que hacer notar que la aplicacion grafica esta perfectamente separadade la API, por lo que no es necesario utilizar aquella si queremos usar estaultima. La API esta presentada mediante una serie de llamadas que obtie-nen toda la funcionalidad que ofrece GDB, por lo que es posible desarrollarcualquier otro tipo de aplicacion grafica que haga uso de dicha interfaz deprogramacion. La aplicacion desarrollada, aun siendo una interfaz de usua-

16 Estructura general del sistema

rio completa y totalmente funcional, puede servir de muestra a otras futurasaplicaciones y a lo que estas pueden conseguir si se utiliza la API.

La aplicacion grafica tiene un diseno convencional compuesto por unmenu, una barra de herramientas y una serie de vistas y panales. En lavista principal se puede ver el codigo del programa que se quiere simular.Mediante el menu o directamente en la barra de herramientas, el usuario dela aplicacion grafica puede controlar como se ejecuta el programa, mediantela insercion y eliminacion de puntos de ruptura y mediante los comandos decontrol de flujo de ejecucion.

Se dispone tambien de una serie de ventanas adicionales en las que sepuede ir siguiendo la evolucion de varios componentes del programa. Ası, sedispone de vistas para obtener el valor de la pila de llamadas, de los registrosinternos del microprocesador y de cualquier direccion de memoria del micro-controlador. Es esta serie de vistas la que da sentido y utilidad al uso delsimulador, puesto que se puede comprobar que todos estos parametros tomanlos valores que quiere el programador a medida que ejecuta su programa.

Toda esta funcionalidad se obtiene a traves de la API de comunicacion conGDB. Esta interfaz de programacion ofrece toda una serie de llamadas queponen a disposicion de los programadores todo lo que GDB ofrece mediantesu interfaz de comandos. En el sistema desarollado se ha puesto especialhincapie en los aspectos mas relevantes del diseno de sistemas empotrados yque se puede apreciar en la interfaz de usuario, como puede ser la obtenciondel estado de los registros internos del microprocesador o la obtencion delvalor almacenado en una posicion cualquiera de memoria.

Esta interfaz de programacion no esta ligada al microcontrolador MCore,es decir, es independiente del microprocesador que se utilice, pudiendoseutilizar con cualquier otro simulador que provea GDB.

El funcionamiento de la librerıa se basa en la creacion de dos procesosque se comunican mediante tuberıas (pipes). Uno de estos procesos, el hijo,ejecuta el depurador GDB, mientras que el otro, el proceso padre, se encar-ga de realizar las peticiones y presentarlas de manera adecuada al exterior.Tambien se utiliza otro mecanismo de comunicacion entre procesos, comoson las senales, que se emplean para informar a la API de que han sucedidoeventos significativos, como puede ser el cambio de estado de los perifericos.

Para comunicarse con GDB se utiliza la interfaz GDB/MI, que es unainterfaz orientada al uso de GDB como una parte de un conjunto mayor [2].

Capıtulo 3

Comunicacion con GDB

3.1. Librerıa GCA

La librerıa GCA1 desarrollada es una interfaz para la comunicacion conGDB, de modo que se pueda extraer toda la informacion que este depuradorproporciona a traves de funciones y no a traves de la lınea de comandos.Se dispone, pues, de una serie de funciones que equivalen a las ordenes quese pueden introducir en la lınea de comandos de GDB. En esta primeraversion de la librerıa, puesto que la aplicacion desarrollada posteriormente ya partir de ella tiene como objetivo la depuracion de programas para sistemasempotrados, se ha puesto especial hincapie en las funcionalidades que ofreceGDB para trabajar con este tipo de sistemas.

Aun ası, esta primera version de la librerıa esta completa en el sentido deque se puede utilizar para construir programas que permitan la depuracionde cualquier tipo de sistemas, si bien pueden echarse en falta caracterısti-cas avanzadas de GDB, como puede ser el trabajo con hilos. Esta y otrasfuncionalidades de GDB podrıan aparecer en futuras versiones de la librerıa.

Para la construccion de la librerıa se ha utilizado la interfaz GDB/MI.Segun se encuentra en [2], ”GDB/MI es un interfaz de texto para gdb orienta-da a maquina y basada en lınea. Esta pensada especıficamente para permitirel desarrollo de sistemas que usen el depurador como una pequena parte deun sistema mayor.”

El hecho de separar la comunicacion con GDB y construir una librerıaindependiente de la interfaz de usuario, dota al proyecto de mayor flexibilidady le concede un valor anadido. Cualquier desarrollador que quiera construirotro depurador o usar GDB como parte de un sistema mayor, dispone dela librerıa para comunicarse con el depurador, de modo que no tiene que

1Gdb Communication Api

18 Comunicacion con GDB

volver a implementarlo de nuevo, si ası lo cree conveniente. Por poner unejemplo sencillo, para disponer de una interfaz de usuario construida con laslibrerıas de GTK+, en lugar de con las librerıas de KDE, como ocurre eneste proyecto, tan solo habrıa que preocuparse de construir dicha interfaz yno de la comunicacion con GDB, funcionalidad que esta oculta detras de lainterfaz de la librerıa.

El principio basico que domina el funcionamiento de la librerıa es la co-municacion entre procesos mediante pipes. Una vez que se inicia una sesionde depuracion, se construyen un par de procesos, uno padre y otro hijo. Elproceso hijo ejecuta GDB y el proceso padre se encarga de enviar las orde-nes (comandos) al depurador y de recoger las respuestas y presentarlas demanera adecuada.

Los pipes simplemente conectan la salida de un proceso con la entradade otro. Son, pues, unidireccionales o semiduplex, esto es, los datos fluyen enuna sola direccion. Hay dos tipos de pipes, los pipes con nombre y los pipessin nombre.

Los pipes con nombre se denominan habitualmente FIFOs (First In, FirstOut, lo que entra primero, sale primero). Estos pipes cuentan con una rutade acceso y existen el sistema de ficheros. Son denominados FIFOs porquelos datos se leen de los mismos en el mismo orden en que han sido escritos,de modo que el primer dato que entra a un FIFO es tambien el primer datoque sale del mismo. Un FIFO es, por tanto, una cola.

Los pipes sin nombre, sin embargo, carecen del mismo porque no necesitanuna ruta de acceso y, por lo tanto, no existen en el sistema de ficheros. Noson mas que un par de descriptores de fichero, uno de lectura y otro deescritura, asociados con un nodo-i en memoria. El ultimo proceso que cierrauno de estos descriptores de archivo hace que el inode, y por lo tanto el pipe,desaparezcan.

Para crear un pipe sin nombre se dispone de la llamada al sistema pipe.Su prototipo esta declarado en <unistd.h> de la manera siguiente:

int pipe ( int d e s c f [ 2 ] ) ;

pipe crea un par de descriptores de ficheros que apuntan a un nodo-i deun conducto y los pone en el vector de dos elementos apuntado por descf.descf[0] es para lectura y descf[1] es para escritura.

La limitacion mas importante de los pipes sin nombre es que solo puedenser utilizados por procesos relacionados entre sı. Por esta razon, el funcio-namiento de la librerıa se basa en la utilizacion de dos procesos, uno padrey otro hijo, creados por la llamada al sistema fork, porque estos procesoscomparten los descriptores de fichero abiertos (mas precisamente, el proceso

3.2 API 19

hijo hereda los descriptores del proceso padre). Esto quiere decir que todolo que un proceso padre escriba en el conducto (mediante el descriptor defichero de escritura, descf[1]) podra ser leıdo por el otro proceso en el otroextremo (a traves del descriptor de fichero de lectura, descf[0]).

Para que la comunicacion entre ambos procesos sea bidireccional no haymas que crear dos pipes o conductos, uno para cada sentido de la comuni-cacion. Es decir, se destina un pipe para el sentido padre-hijo y otro, parael sentido hijo-padre. Para que no existan errores en la transmision de in-formacion tan solo hay que cerciorarse de escribir y leer en los descriptorescorrespondientes. Para ello es preciso cerrar los que no sean necesarios.

3.2. API

La librerıa GCA implementa un subconjunto de los comandos que aceptaGDB. Basicamente, las funciones se corresponden casi directamente con estoscomandos, limitandose a hacer una comprobacion basica de parametros ydevolviendo el resultado en una forma adecuada para su tratamiento en unprograma. El funcionamiento de la librerıa emula, por tanto, lo que puedehacer un usuario de GDB ante una consola de comandos, de manera que elprogramador familiarizado con el uso de GDB encontrara sencillo tambienel uso de esta librerıa. De hecho, no tiene mas que encontrar la funcioncorrespondiente al comando que normalmente utiliza al trabajar con GDB.

La librerıa se ha construido utilizando la interfaz GDB/MI1. Esta inter-faz esta basada en caracteres y permite el uso de GDB dentro de sistemasmayores. Su funcionamiento se basa en el intercambio de informacion en-tre procesos. El proceso que ejecuta GDB acepta comandos en su entraday proyecta los resultados en la salida. El mecanismo de comunicacion entreprocesos elegido para la construccion de la librerıa ha sido el de las tuberıas(pipes), por su sencillez y su robustez. Como la comunicacion con GDB debeser bidireccional (se le proporcionan comandos y este devuelve las respuestasa dichos comandos), es necesario crear dos pipes que se comunique con el.

La forma en que GDB y la interfaz mi1 presentan dichos resultados esalgo compleja, pero muy estructurada. Esta es una, sino la mayor, de lasventajas que presenta el uso de la librerıa, pues el programador no tiene queocuparse de analizar la forma del resultado y sacar los valores que le interesancada vez que ejecuta un comando, sino tan solo de recogerlos mediante losparametros que las funciones de la librerıa proporciona para ello.

Al programador familiarizado con esta interfaz mi1 de GDB le resul-tara mas facil todavıa utilizar las funciones de la librerıa, pues hay una co-rrespondencia casi directa entre el nombre de la funcion y el comando mi1


que ejecuta.El proposito para el que ha nacido esta librerıa es la depuracion de siste-

mas empotrados, con lo que se hace especial hincapie en facilidades relativasal estudio de la memoria, la pila y los registros del microcontrolador y en eluso de GDB como cross-debugger, mas que en otros aspectos propios de laprogramacion de sistemas.

Futuras versiones de la librerıa pueden aumentar el conjunto de comandossoportados. La version actual implementa los comandos basicos necesariospara una sesion de depuracion completa, pero se deja atras temas avanzados,como puede ser la programacion con hilos.

Hay que decir, no obstante, que la librerıa puede utilizarse perfectamentepara construir aplicaciones que depuren aplicaciones no empotradas, siem-pre que sean sencillos y no se utilicen conceptos avanzados de programacionde sistemas, pues, como se ha mencionado mas arriba, la librerıa carece detales capacidades. No se descarta que la librerıa, amen de perfeccionar el tra-tamiento de programas para sistemas empotrados, evolucione tambien paraabarcar un abanico mas amplio de programas.

De esta forma, la manera de empezar a trabajar con la librerıa, del mis-mo modo que con GDB, iniciar una sesion. Una vez que se ha abierto dichasesion, tan solo habra que utilizar las funciones tal como lo harıa un usuarioante la lınea de comandos de GDB. Por ejemplo, para comenzar a utilizar elsimulador del microcontrolador, habrıa que iniciarlo y cargar el programa conlos comandos target sim y load. Para estos dos comandos, que normalmetevan unidos y seguidos, la librerıa proporciona sus funciones correspondientes,gca target select type y gca target load program, a la vez que suminis-tra una funcion que ejecuta las dos anteriores, gca target start simulator.

La librerıa se vertebra en torno a una estructura GcaSession que imple-menta el concepto de sesion de depuracion. Al iniciar el simulador la librerıacrea dinamicamente en memoria una estrucutura que almacena los parame-tros relativos a esa sesion y todos los elementos necesarios para trabajar conella. Este puntero se utiliza despues para cualquier operacion que queramosrealizar sobre la sesion, pues la identifica de manera unıvoca. De esta ma-nera, se pueden abrir varias sesiones simultaneas que se diferencian por laestructura GcaSession que la caracteriza.

Esta estructura almacenada en memoria debe liberarse una vez que sequiera terminar con la sesion de depuracion, asegurando ası que todos loselementos creados dinamicamente son correctamente liberados. Eso es tras-parente al programador, que tan solo debe limitarse a cerrar la sesion dedepuracion llamando a la funcion gca session close.

Esto mismo ocurre con otros elementos que estan almacenados en me-moria y que son devueltos por determinadas funciones de la librerıa. Para

3.2 API 21

asegurar que no se corrompe la memoria, estos elementos deben ser correcta-mente liberados, como corresponde a una buena practica de programacion.

Todos estos aspectos se pueden consultar en los siguientes apartados, queexplican cada una de las funciones de la librerıa y los detalles que es necesarioconocer para trabajar de manera adecuada con ellas.

El criterio que se ha elegido para estructurar las funciones de la bibliotecatiene que ver con el aspecto de GDB con el que estan relacionadas. Es deciry poniendo un ejemplo, todas las funciones que traten con los puntos deruptura se pueden encontrar en el fichero gca-breakpoint.h.

El nombre de las funciones tambien tiene en cuenta esta estructuracion.Ası, el nombre de todas las funciones comienzan con un prefijo que no esmas que el nombre de la librerıa, seguido del nombre del fichero en el que seencuentran. De igual forma, todas las funciones relacionadas con los framede la pila tendran un nombre que comience por gca stack frame. El restodel nombre de la funcion tendra que ver con el aspecto concreto para el quese utilizan, si bien se ha intentado que esta parte sea igual al comando mi1que implementa su funcionalidad.

3.2.1. gca-session.h

En este fichero se encuentran las funciones imprescindibles para empezara trabajar con la librerıa, pues contiene todos los metodos que interactuancon la estructura GcaSession. No hay que olvidar que esta estructura secorresponde de manera directa y unıvoca con una sesion de depuracion. Deeste modo, en este fichero se pueden encontrar las funciones que abren ycierran una ejecucion de GDB.

A continuacion se muestra el detalle de cada una de las funciones de estefichero.

gca session init

GcaSession ∗ g c a s e s s i o n i n i t( char ∗gdb , char ∗program ) ;

Esta funcion inicia una sesion de depuracion con GDB. Es equivalente ateclear gdb program en la lınea de comandos para comenzar la ejecucion delGNU Debugger.gdb Cadena que indica el path donde se encuentra GDB.

program Cadena que especifica el path del fichero ejecutable que va a serdepurado. Este parametro es opcional, de manera que puede tomar el


valor nulo. Esto es equivalente a iniciar GDB sin indicar el nombredel fichero ejecutable que se va a depurar, de manera que habra queespecificarlo luego mediante la funcion gca file exe.

El valor devuelto por esta funcion es un puntero a una estructura Gca-Session o nulo si ha habido algun error. Esta estructura contiene toda lainformacion relativa a una sesion de depuracion o, al menos, todos los ele-mentos necesarios para acceder a dicha informacion.

La memoria a la que apunta esta estructura debe ser liberada antes de ter-minar el programa. De eso se encarga la siguiente funcion, gca session close.

gca session close

int g c a s e s s i o n c l o s e ( GcaSession ∗ s e s ) ;

Metodo que termina la sesion de depuracion. Se encarga tanto de terminarcon la ejecucion de GDB como de eliminar todas las estructuras dinamicasde memoria utilizadas para almacenar informacion relativa a la sesion dedepuracion, ası que es imprescindible llamar a esta funcion si no queremostener procesos zombies y memoria no liberada. Es equivalente a teclear quit(-gdb-exit) en la lınea de comandos de GDB.

ses Puntero a una estructura GcaSession que identifica una sesion de depu-racion (valor que ha sido devuelto por una llamada a gca session init).

El valor devuelto por esta funcion es cero si no hay ningun problema o -1en caso contrario.

gca session command

GcaCommand ∗gca sess ion command ( GcaSession ∗ s e s ) ;

Esta funcion permite conocer informacion relativa al ultimo comando queha tratado GDB (comando ejecutado y respuesta de este).


El valor devuelto por esta funcion es un puntero a una estrucutura Gca-Command o un puntero nulo en caso de error.

3.2 API 23

gca session is open

int g c a s e s s i o n i s o p e n ( GcaSession ∗ s e s ) ;

Esta funcion comprueba si una sesion de depuracion esta abierta o cerra-da.ses Puntero a una estructura GcaSession que identifica una sesion de depu-

racion (valor que ha sido devuelto por una llamada a gca session init).

El valor devuelto por esta funcion es verdadero (1) si la sesion esta abiertao falso (0) si esta cerrada.

gca session set callback

int g c a s e s s i o n s e t c a l l b a c k( GcaSess ion ∗ ses , GcaCallbackType type ,void (∗ func ) ( void ) ) ;

Mediante esta funcion se puede conseguir que una determinada funciondesarrollada por el usuario se ejecute a medida que se depura el programa.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


type Valor del tipo GcaCallbackType que indica cuando debe ejecutarse lafuncion de callback, esto es, con que comando de flujo de programa.

func Puntero a la funcion definida por el usuario que se ejecutara con elcomando de flujo de programa correspondiente. La funcion no debetomar ningun parametro ni debe devolver ningun valor.

El valor devuelto por esta funcion es un entero no negativo que identificaa la funcion de callback o -1 si ha habido algun error.

gca session delete callback

void g c a s e s s i o n d e l e t e c a l l b a c k( GcaSess ion ∗ ses , u int numcbk ) ;

Con esta funcion se borra de la lista una determinada funcion de callback,evitandose ası que se vuelva a ejecutar.ses Puntero a una estructura GcaSession que identifica una sesion de depu-



numcbk Entero que identifica a una funcion de callback y que ha sido de-vuelto por una llamada a la funcion gca session set callback.

gca session set callback type

int g c a s e s s i o n s e t c a l l b a c k t y p e( GcaSess ion ∗ ses , int numcbk , GcaCallbackType type ) ;

Con esta funcion se puede cambiar el tipo de una funcion callback parahacer que se ejecute con un comando de flujo de programa distinto.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


numcbk Entero que identifica a una funcion de callback y que ha sido de-vuelto por una llamada a la funcion gca session set callback.

type Valor del tipo enumerado que indica cuando debe ejecutarse la funcionde callback, esto es, con que comando de flujo de programa.

El valor devuelto por esta funcion es cero si no hay ningun problema o -1en caso contrario.

gca session error

const char ∗ g c a s e s s i o n e r r o r ( GcaSession ∗ s e s ) ;

Funcion que permite conocer el mensaje de error proporcionado por lasalida de GDB para el ultimo comando ejecutado.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


El valor devuelto por esta funcion es un puntero a la cadena que almacenainternamente el mensaje de error.

gca session signal received

const char ∗ g c a s e s s i o n s i g n a l r e c e i v e d( GcaSess ion ∗ s e s ) ;

3.2 API 25

Funcion que devuelve la senal (en forma de cadena de caracteres) que hainterrumpido la ejecucion del programa.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


El valor devuelto por esta funcion es un puntero a la cadena que almacenainternamente la senal recibida.

gca session execute command

GcaCommand ∗ gca sess ion execute command( GcaSess ion ∗ ses , const char ∗op ) ;

Funcion con la que se puede ejecutar directamente un comando de lainterfaz mi1 de GDB. De esta manera, se puede trabajar con comandos queno estan recogidos en esta primera version de la librerıa.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


op Cadena que almacena el comando a ejecutar.

El valor que devuelve esta funcion es puntero a una estructura GcaCommand

que contiene informacion tanto del comando ejecutado como de la respuestade GDB.

3.2.2. gca-callback.h

Este fichero de la interfaz tan solo contiene la definicion de un tipo, pero sufichero fuente contiene una serie de funciones que implementan una capacidadmuy interesante de la librerıa, las funciones de callback.

La biblioteca brinda la oportunidad al programador de registrar funcionesdefinidas por el y hacer que estas se ejecuten con un comando de flujo deprograma. De esta forma, mediante las funciones de callback, el control dela ejecucion del programa vuelve al programador mientras tiene lugar unadeterminada instruccion de flujo.

Por poner un ejemplo sencillo, el programador podrıa estar interesado enconocer el valor de un determinado registro del sistema (quizas el contador deprograma) e imprimirlo en pantalla cada vez que se ejecuta una lınea de codi-go de fuente. En lugar de llamar explıcitamte a la funcion que obtiene dichovalor y despues hacer lo propio con la funcion de salida en pantalla, el progra-mador tiene la opcion de definir una funcion que haga todo esto y registrarla


en la biblioteca para que esta se ocupe de llamarla cada vez que se ejecuta unalınea de codigo fuente (mediante la funcion gca session set callaback).

De esta forma, el programador se libera de la obligacion de tener queinvocar explıcitamente el mismo esta funcion puesto que la biblioteca seocupa de hacerlo por el. Es una forma, si puede decirse, de cambiar de maneradinamica la biblioteca para que se adapte a las necesidades del programador.

Para especificar el comando de flujo de programa que hace que se ejecutenlas funciones de callback se ha definido un tipo enumerado GcaCallback:

typedef enum {GCA CALLBACK TYPE CONTINUE = 0 ,GCA CALLBACK TYPE FINISH,GCA CALLBACK TYPE NEXT,GCA CALLBACK TYPE NEXT INSTRUCTION,GCA CALLBACK TYPE RUN,GCA CALLBACK TYPE RETURN,GCA CALLBACK TYPE STEP,GCA CALLBACK TYPE STEP INSTRUCTION,GCA CALLBACK TYPE UNTIL} GcaCallbackType ;

Esto es lo mismo que decir que la funcion de callback se ejecutara cadavez que tenga lugar una instruccion continue, finish, next, next instruction, run,return, step, step instruction o until, respectivamente.

3.2.3. gca-list.h

Antes de empezar a describir otros elementos de la interfaz que tienen masque ver con GDB y con la depuracion de programas, se describira brevementelas funciones de un fichero que se utilizaran en algunas otras funciones de lainterfaz y que proporcionan una capacidad muy util al programador.

La biblioteca maneja informacion cuya longitud no se conoce de antemanopor el programdor. Esta puede ser, por ejemplo, el numero de frames de lapila (profundidad de la pila) o el numero de puntos de ruptura definidosen un momento dado. Por esta razon la biblioteca trata las estructuras quealmacenan este tipo de informacion como listas enlazadas.

Para ello se ha definido un tipo lista generico GcaList. Esta estructuraconsiste en un puntero a la siguiente estrucutura, como corresponde a unalista enlazada, y en un puntero generico (void *) que permite almacenarcualquier tipo de informacion.

3.2 API 27

Hay dos formas, entonces, de trabajar con este tipo. La primera es utilizarel puntero generico para hacer que apunte al elemento que el programadordesee. En la biblioteca se utiliza este modo exclusivamente para implemen-tar listas enlazadas de cadenas de caracteres. Ası, una lista de cadenas es,directamente, un estructura GcaList y se puede obtener la cadena que al-macenada en un elemento de la lista mediante la funcion correspondiente,gca list data.

Sin embargo, hay una segunda forma de trabajar con listas. A lo largo dela bibloteca, todas las estructuras de informacion susceptibles de ser listas porno conocerse su tamano se han definido de manera que pueden convertirseexplıcitamente (casts) en estructuras de tipo GcaList y utilizar, por tanto,las funciones propias de este tipo.

Estas otras estructuras que pueden utilizarse como si de listas se tratasese presentaran en los siguientes apartados, pero la forma de trabajar con lasfunciones que se veran a continuacion y con dichas estructuras es conver-tirlas al tipo GcaList primero y devolverlas despues a su tipo original si esnecesario.

Por ejemplo, para movernos al siguiente elemento de una lista tan solohabrıa que hacer:

OtroTipo ∗ elmt = g c a f u n c i o n q u e d e v u e l v e l i s t a ( ) ;elmt = ( OtroTipo ∗) g c a l i s t n e x t ( ( GcaList ∗) elmt ) ;

gca list data

void ∗ g c a l i s t d a t a ( GcaList ∗ elmt ) ;

Esta funcion permite obtener el puntero generico que permite trabajardirectamente con el tipo GcaList.elmt Puntero a una estructura GcaList que identifica un elemento de la

lista.

El valor devuelto por esta funcion es un punto generico con la informacionalmacenada en el elemento actual de la lista.

gca list next

GcaList ∗ g c a l i s t n e x t ( GcaList ∗ elmt ) ;


Esta funcion permite, dado un elemento de la lista, obtener el siguiente.elmt Puntero a una estructura GcaList que identifica un elemento de la

lista.

Esta funcion devuelve un puntero al siguiente elemento de la lista o unpuntero nulo en caso de que el actual sea el ultimo.

gca list tail

GcaList ∗ g c a l i s t t a i l ( GcaList ∗ elmt ) ;

Con esta funcion podemos obtener directamente, dado un miembro cual-quiera de la lista, el ultimo elemento de ella.elmt Puntero a una estructura GcaList que identifica un elemento de la

lista.

Se devuelve un puntero al ultimo elemento de la lista o un puntero nuloen caso de que la lista este vacıa.

gca list nth

GcaList ∗ g c a l i s t n t h ( GcaList ∗head , s i z e t n ) ;

Funcion que sirve para situarse en el elmento n-esimo de la lista.head Puntero a un elemento GcaList que identifica el primer elemento de

la lista.

n Numero de elemento que se quiere obtener.

El valor devuelto por esta funcion es un puntero al elemento n-esimo dela lista o un puntero nulo si la lista es mas pequena.

gca list length

s i z e t g c a l i s t l e n g t h ( GcaList ∗head ) ;

Esta funcion permite conocer la longitud de la lista.head Puntero a un elemento GcaList que identifica el primer elemento de la

lista.

Se devuelve un entero con el valor de la longitud de la lista.

3.2 API 29

gca list free

void g c a l i s t f r e e ( GcaList ∗head ) ;

Funcion que sirve para borrar la lista y liberar la memoria reservadautilizada para implementarla.

head Puntero a un elemento GcaList que identifica el primer elemento de lalista.

3.2.4. gca-micro.h

En este fichero se encuentran las definiciones relativas a caracterısticascomunes a todos los microcontroladores que utiliza GDB. Aquı se definen,por tanto, el tipo que almacenara una direccion de memoria (address), eltipo de la unidad basica de memoria (byte) y el tipo de una palabra (word).

Se ha pretendido que la liberıa no este ligada a ninguno en particular,sino que pueda trabajar con cualquier variante de GDB configurado comocross-debugger.

De esta manera, en este fichero se pueden encontrar las siguientes defini-ciones:

typedef u i n t 3 2 t address ;typedef i n t 3 2 t word ;typedef u i n t 3 2 t uword ;typedef i n t 1 6 t hword ;typedef u i n t 1 6 t uhword ;typedef i n t 8 t byte ;typedef u i n t 8 t ubyte ;

Los tipos utilizados en estas definiciones aseguran su tamano sea cual seala maquina en que se utilizan. Ası, el tipo address, por ejemplo, sera siem-pre un entero sin signo de 32 bits, de manera que la biblioteca sera capazde direccionar mapas de memoria de hasta 8G. Si el microprocesador con-creto que se esta utilizando con GDB tiene un mapa de memoria menor, nohabra ningun problema. De hecho, el problema serıa lo contrario, razon porla cual se han elegido tamanos maximos para todos estos tipos.

Lo mismo se puede decir del tipo word. Este tipo se utiliza para definirvariables que contienen el valor de los registros del sistema. Pues, tal como seha definido, la biblioteca trabajara con registros de 32 bits. Esto no suponeningun problema si el microprocesador, en realidad, tiene registros de 16 bits.


En futuras versiones de la biblioteca y a medida que se extiendan enel mercado las maquinas de 64 bits, serıa aconsejable, quizas, extender eltamano del tipo word para manejar palabras y registros de este numero debits. De momento, con las definiciones tal como estan ahora, se asegura quela biblioteca podra funcionan en la casi totalidad de maquinas del mercado.

3.2.5. gca-breakpoint.h

Este fichero contiene todos los metodos relacionados con el tratamientode puntos de ruptura (breakpoints) en GDB. Basicamente, la librerıa permitela insercion de puntos de ruptura y la modificacion de ciertas caracterısticasde dichos elementos.

La librerıa no almacena, de por sı, informacion relativa a los puntos deruptura en la misma forma que lo hace con la sesion de depuracion, puesto queesto ya lo hace el propio depurador, sino que cualquier consulta requiriendoinformacion sobre ellos es traspasada directamente a GDB.

Sı hay una funcion, sin embargo, que muestra toda la informacion ca-racterıstica de un punto de ruptura en un momento dado. Esta funciongca breakpoint info crea dinamicamente una estructura GcaBreakpoint

en memoria para almacenar toda esta informacion y devuelve un puntero adicha estructura. Las propiedades del punto de ruptura no son visibles direc-tamente, sino que existe toda una serie de metodos para obtener cada unade sus caracterısticas utilizando esta estructura.

Hay que apuntar que este tipo GcaBreakpoint puede utilizarse como side una lista se tratase, convirtiendolo al tipo GcaList y usando las funcionesde la librerıa que manejan listas.

Es responsabilidad del programador liberar esa memoria una vez que dejede utilizarla, teniendo en cuenta que la informacion contenida en ella no semodifica si se cambian las caracterısticas del punto de ruptura, por lo quesera necesario solicitarla de nuevo (esto es, crear otra estructura).

gca breakpoint number

int gca breakpoint number ( GcaBreakpoint ∗bkpt ) ;

Funcion que devuelve el numero que identifica el punto de ruptura.

bkpt Puntero a una estructura GcaBreakpoint que almacena informacionrelativa a un punto de ruptura (valor que ha sido devuelto por la funciongca breakpoint info).

3.2 API 31

El valor devuelto es un entero que identifica el punto de ruptura o -1 encaso de error.

gca breakpoint type is watchpoint

uint g c a b r e a kp o in t ty pe i s w a t ch po i n t( GcaBreakpoint ∗bkpt ) ;

Funcion que sirve para identificar el tipo del punto de ruptura. De mo-mento, la biblioteca GCA puede trabajar con dos tipos: breakpoints y watch-points.bkpt Puntero a una estructura GcaBreakpoint que almacena informacion

relativa a un punto de ruptura (valor que ha sido devuelto por la funciongca breakpoint info).

Esta funcion devuelve verdadero (1) en caso de que el punto de rupturasea un watchpoint o falso (0) es caso de tratarse de un breakpoint.

gca breakpoint disp is keep

uint g c a b r e a k p o i n t d i s p i s k e e p ( GcaBreakpoint ∗bkpt ) ;

Funcion que sirve para saber si el punto de ruptura seguira existiendo ohabilitado una vez que lo alcance el flujo de programa.bkpt Puntero a una estructura GcaBreakpoint que almacena informacion


Esta funcion devuelve verdadero (1) si el punto de ruptura seguira habi-litado despues de que se llegue a el o falso (0) en caso contrario.

gca breakpoint enabled

uint gca breakpo in t enab l ed ( GcaBreakpoint ∗bkpt ) ;

Funcion que indica si el punto de ruptura esta habilitado o no.bkpt Puntero a una estructura GcaBreakpoint que almacena informacion


El valor devuelto por esta funcion sera verdadero (1) si el punto de rupturaesta habilitado o falso (0) en caso contrario.


gca breakpoint address

address gca br eakpo in t addre s s ( GcaBreakpoint ∗bkpt ) ;

Funcion que sirve para obtener la direccion de memoria donde se ha in-sertado el punto de ruptura.bkpt Puntero a una estructura GcaBreakpoint que almacena informacion


Se devuelve un valor de tipo address que representa la direccion de me-moria donde esta incrustado el punto de ruptura o 0 en caso de que se hayaproducido algun error.

gca breakpoint function

const char ∗ gc a b r e a k p o i n t f u n c t i o n( GcaBreakpoint ∗bkpt ) ;

Metodo que muestra la funcion en la que se ha insertado el punto deruptura.bkpt Puntero a una estructura GcaBreakpoint que almacena informacion


El valor devuelto es una cadena de caracteres que contiene el nombre dela funcion correspondiente o un puntero nulo en caso de error.

gca breakpoint file

const char ∗ g c a b r e a k p o i n t f i l e ( GcaBreakpoint ∗bkpt ) ;

Metodo que muestra el fichero donde se encuentra la funcion en la que seha insertado el punto de ruptura.bkpt Puntero a una estructura GcaBreakpoint que almacena informacion


El valor devuelto es una cadena de caracteres que contiene el nombre delfichero correspondiente o un puntero nulo en caso de error.

3.2 API 33

gca breakpoint line

int g c a b r e a k p o i n t l i n e ( GcaBreakpoint ∗bkpt ) ;

Esta metodo sirve para conocer la lınea exacta del fichero donde se haintroducido el punto de ruptura.bkpt Puntero a una estructura GcaBreakpoint que almacena informacion


Se devuelve un entero con el valor de la lınea donde esta el punto deruptura o cero en caso de que se haya producido algun error.

gca breakpoint condition

const char ∗ gc a b r e ak po in t c on d i t i o n( GcaBreakpoint ∗bkpt ) ;

Funcion que sirve para conocer si el punto de ruptura esta sujeto a algunacondicion (esto es, si existe alguna expresion que deba cumplirse para que sedetenga la ejecucion del programa).bkpt Puntero a una estructura GcaBreakpoint que almacena informacion


El valor devuelto por este metodo es una cadena con la expresion quecondiciona el punto de ruptura o un puntero nulo en caso de error.

gca breakpoint times

int gca breakpo in t t imes ( GcaBreakpoint ∗bkpt ) ;

Metodo que indica el numero de veces que el flujo de programa ha alcan-zado el punto de ruptura.bkpt Puntero a una estructura GcaBreakpoint que almacena informacion


Esta funcion devuelve el numero de veces que el punto de ruptura ha sidoalcanzado por el flujo de programa o -1 en caso de que se haya producido unerror.


gca breakpoint ignore

int g ca b r e a k p o in t i gn o r e ( GcaBreakpoint ∗bkpt ) ;

Este metodo indica el numero de veces que hay que alcanzar el punto deruptura para que el flujo de programa se detenga en el.

bkpt Puntero a una estructura GcaBreakpoint que almacena informacionrelativa a un punto de ruptura (valor que ha sido devuelto por la funciongca breakpoint info).

El valor devuelto es el numero de veces que hay que alcanzar el punto deruptura para que el flujo de ruptura de detenga en el o -1 en caso de error.

gca breakpoint break after

int g c a b r e a k p o i n t b r e a k a f t e r( GcaSess ion ∗ ses , u int number , u int count ) ;

Esta funcion hace que un determinado punto de ruptura solo este activodespues de que la ejecucion lo haya alcanzado un cierto numero de veces (estevalor es el indicado por la propiedad ignore). La funcion es equivalente alcomando ignore (-break-after) de GDB.


number Entero positivo que identifica el punto de ruptura.

count Numero de veces que la ejecucion del programa debe alcanzar el puntode ruptura despues del cual pasara a estar activo.

Esta funcion devuelve cero si no hay ningun problema o -1 en caso con-trario.

gca breakpoint break condition

int gca b r eakpo in t b r e ak co nd i t i o n( GcaSess ion ∗ ses , u int number , const char ∗cond ) ;

3.2 API 35

Esta funcion provoca que un punto de ruptura sea efectivo solo si es ciertauna determinada condicion. Es equivalente a teclear el comando condition

(-break-condition) en la consola de comandos de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


number Entero positivo que identifica el punto de ruptura.

cond Cadena de caracteres que almacena la condicion a ser evaluada.

Funcion que devuelve cero si no hay ningun problema o -1 en caso con-trario.

gca breakpoint delete

int g c a b r e a k p o i n t d e l e t e( GcaSess ion ∗ ses , u int number ) ;

Esta funcion borra un punto de ruptura. Es equivalente al comando delete(-break-delete) de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


number Entero positivo que identifica el punto de ruptura. Si este parame-tro toma el valor ALL BREAKPOINTS la operacion se realizara sobre todoslos puntos de ruptura definidos.

Se devuelve cero si no hay ningun problema o -1 en caso contrario.

gca breakpoint disable

int g c a b r e a k p o i n t d i s a b l e( GcaSess ion ∗ ses , u int number ) ;

Funcion que deshabilita un punto de ruptura. Es equivalente al comandodisable (-break-disable) de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-



Cero si no hay ningun problema o -1 en caso contrario.


gca breakpoint enable

int gca breakpo in t enab l e( GcaSess ion ∗ ses , u int number ) ;

Funcion que habilita un punto de ruptura. Es equivalente al comandoenable (-break-enable) de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-



Se devuelve cero si no hay ningun problema o -1 en caso contrario.

gca breakpoint info

GcaBreakpoint ∗ g c a b r e a k p o i n t i n f o( GcaSess ion ∗ ses , u int number ) ;

Esta funcion proporciona toda la informacion disponible sobre un puntode ruptura. Es equivalente a teclear info break (-break-info) en la consola decomandos de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


number Entero positivo que identifica el punto de ruptura. Si este parame-tro toma el valor ALL BREAKPOINTS se muestra informacion de todoslos puntos de ruptura definidos en ese momento.

bkpt Puntero a una estructura GcaBreakpoint que almacena la informacionrelativa a un punto de ruptura.

Se devuelve un puntero a un elemento GcaBreakpoint que contiene to-da la informacion relativa al punto de ruptura o un puntero nulo si seha producido algun error. En caso de que se haya proporcionado el valorALL BREAKPOINTS para el parametro number lo que se devuelve es una lis-ta de estructuras GcaBreakpoint con la informacion de todos los puntos deruptura definidos.

La memoria reservada por el sistema para este elemento debe ser liberadapor el programador mediante la funcion gca breakpoint free.

3.2 API 37

gca breakpoint insert in address

int g c a b r e a k p o i n t i n s e r t i n a d d r e s s( GcaSess ion ∗ ses , address addr ) ;

Esta funcion inserta un punto de ruptura en una determinada direccionde memoria. Es equivalente al comando break (-break-insert) de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


addr Valor de tipo address que indica la direccion de codigo maquina dondese quiere ubicar el punto de ruptura.

Esta funcion devuelve el numero entero que identifica al punto de rupturao -1 si ha habido algun error.

gca breakpoint insert in function

int g c a b r e a k p o i n t i n s e r t i n f u n c t i o n( GcaSess ion ∗ ses , const char ∗ funct ion ,const char ∗ f i l e ) ;

Funcion que permite insertar un punto de ruptura en una funcion concretadentro de un fichero determinado. Es equivalente al comando break (-break-insert) de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


function Cadena que indica el nombre de la funcion donde se desea insertarel punto de ruptura.

file Cadena que indica el nombre el fichero donde se encuentra la funcionanterior.


gca breakpoint insert in line

int g c a b r e a k p o i n t i n s e r t i n l i n e( GcaSess ion ∗ ses , u int l i n e , const char ∗ f i l e ) ;


Esta funcion permite especificar la lınea concreta del fichero fuente dondese quiere insertar el punto de ruptura. Es equivalente al comando break (-break-insert) de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


line Entero con el valor de la lınea del fichero de codigo fuente donde sedesea ubicar el punto de ruptura.

file Cadena que contiene el nombre del fichero anterior.


gca breakpoint free

void g c a b r e a k p o i n t f r e e ( GcaBreakpoint ∗bkpt ) ;

Funcion que sirve para liberar la memoria almacenada para contener ele-mentos de tipo GcaBreakpointt. En caso de tener una lista de puntos deruptura esta funcion la libera entera.bkpt Puntero a una estructura GcaBreakpoint que almacena la informacion

relativa a un punto de ruptura.

3.2.6. gca-command.h

Las funciones de este fichero tienen que ver con los comandos que acepta yejecuta GDB. Dado que la interfaz mi1 es una basada en texto, se ha definidouna estructura GcaCommand que, basicamente, son dos cadenas de texto, unaque contiene el comando ejecutado o el proximo que va a serlo y otra quealmacena la respuesta a dicho commando.

Normalmente la respuesta de GDB a un comando es done si se ha ejecu-tado correctamente o error junto con un mensaje de error en caso de quese haya producido alguno. No obstante, hay comandos especıficos que tienenuna salida particular, de modo que se han definido funciones concretas paraanalizar la respuesta a estos comandos.

Hay que decir que estas funciones que analizan el tipo de respuesta deGDB a un comando no seran necesarias a no ser que el programador ejecutedirectamente un comando mediante la funcion gca session execute command,puesto que este metodo devuelve, directamente y sin ningun procesamientointermedio, la salida del comando en forma de estructura GcaCommand.

3.2 API 39

Si esto lo hace a traves de funciones concretas, que es el uso recomendadode la biblioteca y motivo por el que fue creada, la funcion correspondiente seencargara de estudiar la respuesta de GDB al comando de manera transpa-rente al programador y de presentar el resultado de forma adecuada para untratamiento mas sencillo por parte de un programa.

gca command input

char ∗gca command input (GcaCommand ∗cmd ) ;

Esta funcion muestra el ultimo comando ejecutado en una sesion de de-puracion.md Puntero a una estructura de tipo GcaCommand que almacena tanto el

comando en curso de una sesion de depuracion como la respuesta deGDB a dicho comando. Debe ser, por tanto, un campo de una estructu-ra GcaSession devuelto por la funcion gca session command o porla funcion gca session excute command.

Esta funcion devuelve un cadena de caracteres que contiene un comandode la interfaz GDB/MI.

gca command output

char ∗gca command output (GcaCommand ∗cmd ) ;

Esta funcion muestra la salida al ultimo comando ejecutado en una sesionde depuracion.cmd Puntero a una estructura de tipo GcaCommand que almacena tanto el


Esta funcion devuelve un cadena de caracteres que contiene la respuestade GDB a un comando de la interfaz GDB/MI.

gca command output is connected

uint gca command output is connected (GcaCommand ∗cmd ) ;


Funcion que sirve para conocer si la respuesta al comando de iniciar elsimulador (-target-select type) es afirmativa (connected) o no.cmd Puntero a una estructura de tipo GcaCommand que almacena tanto el


Esta funcion devuelve verdadero (1) si el comando de iniciar el simuladorse ha ejecutado de forma correcta o falso (0) en caso contrario.

gca command output is done

uint gca command output is done (GcaCommand ∗cmd ) ;

Funcion que sirve para conocer si un comando se ha ejecutado correcta-mente. La mayorıa de los comandos devuelven la cadena done en ese caso.cmd Puntero a una estructura de tipo GcaCommand que almacena tanto el


Esta funcion devuelve verdadero (1) si un comando se ha ejecutado co-rrectamente o falso (0) en caso contrario.

gca command output is error

uint gca command output i s er ror (GcaCommand ∗cmd ) ;

Funcion que sirve para conocer si se producido algun error en la ejecucionde un comando (GDB responde entonces con error y un mensaje textual deerror).cmd Puntero a una estructura de tipo GcaCommand que almacena tanto el


Esta funcion devuelve verdadero (1) si la salida de un comando es, efec-tivamente, erronea o falso (0) en caso contrario.

3.2 API 41

gca command output is exit

uint gca command output i s ex i t (GcaCommand ∗cmd ) ;

Funcion que sirve para concer si el comando mi1 de terminacion de unasesion de depuracion (-gdb-exit) se ha ejecutado de manera correcta (GDBdevuelve entonces una cadena exit).cmd Puntero a una estructura de tipo GcaCommand que almacena tanto el


Esta funcion devuelve verdadero (1) si GDB se ha terminado correcta-mente o falso (0) en caso contrario.

gca command output is running

uint gca command output is running (GcaCommand ∗cmd ) ;

Funcion que sirve para conocer si GDB esta ejecutando algun comandode flujo de programa (lo indica mediante una cadena running).cmd Puntero a una estructura de tipo GcaCommand que almacena tanto el


Esta funcion devuelve verdadero (1) si GDB esta tratando algun comandode ejecucion controlada de programa o falso (0) en caso contrario.

gca command output is stopped

uint gca command output is stopped (GcaCommand ∗cmd ) ;

Funcion que sirve para conocer si la ejecucion de un programa se ha dete-nido por algun motivo (GDB lo indica entonces mediante la salida stopped).cmd Puntero a una estructura de tipo GcaCommand que almacena tanto el

comando en curso de una sesion de depuracion como la respuesta de


GDB a dicho comando. Debe ser, por tanto, un campo de una estructu-ra GcaSession devuelto por la funcion gca session command o porla funcion gca session excute command.

Esta funcion devuelve verdadero (1) si la ejecucion del programa se hadetenido o falso (0) en caso contrario.

3.2.7. gca-data.h

En este fichero, como su nombre indica, se encuentran las funciones quetrabajan con los datos de un programa. Dada la especial orientacion de labiblioteca hacia la depuracion de sistemas empotrados, estas funciones hacenun fuerte hincapie en ela obtencion de valores de la memoria y de los registrosdel sistema.

La memoria del sistema es tratada de manera muy sencilla, mediantebytes. La direccion se especifica con un valor del tipo address y este valor secorresponde directamente con un byte de memoria.

Para el tratamiento de los registros del sistema se ha definido, sin embar-go, una estructura GcaDataRegister que contiene el numero que identificaal registo y el valor que tiene en cada momento.

Ademas del numero asociado al registro, GDB tambien identifica a cadauno de ellos mediante un nombre, que es equivalente al numero anterior. Esdecir, un registro puede encontrarse bien mediante su numero o bien mediantesu nombre.

Evidentemente, el conjunto de registros del sistema es una caracterısticaque depende del microcontrolador que se este utilizando.

La estructura GcaDataRegister esta definida como una lista, ası que pue-de convertirse explıcitamente al tipo GcaList para utilizar todos los metodosdefinidos en la biblioteca para el manejo de lsitas.

gca data read memory

int gca data read memory( GcaSess ion ∗ ses , address addr ,ubyte ∗ bu f f e r , s i z e t s i z e ) ;

Esta funcion obtiene el contenido de una determinado region de memoria.La lectura se realiza por bytes. Es equivalente a teclear x (-data-read-memory)en la consola de comandos de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


3.2 API 43

addr Direccion de comienzo de la zona de memoria que quiere ser leıda.

buffer Puntero a caracter que senala el bufer donde se van a almacenar losbytes leıdos.

size Longitud del bufer de salida y cantidad de bytes, por tanto, que sequieren leer.

Se devuelve el numero de bytes leıdos (que puede ser inferior al indicadopor size) o -1 si ha habido algun error.

gca data evaluate expression

GcaVariable ∗ g c a d a t a e v a l u a t e e x p r e s s i o n( GcaSess ion ∗ ses , char ∗ expr ) ;

Esta funcion sirve para obtener el resultado de una expresion. Es equiva-lente al comando print (-data-evaluate-expression) de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


expr Cadena de caracteres que contiene la expresion a ser evaluada.

Se devuelve un puntero a una estructura GcaVariable cuyo nombre esla expresion a evaluar y cuyo valor es el resultado que GDB arroja para estaexpresion. Si se producido algun error se devuelve un puntero nulo.

La memoria reservada para contener esta estructura debe ser liberada porel programador utilizando la funcion gca variable free.

gca data register number

int gca data r eg i s t e r number ( GcaDataRegister ∗ reg ) ;

Con esta funcion se puede obtener el numero de un registro identificadopor una estructura GcaDataRegister.reg Puntero a una estructura GcaDataRegister que almacena numero y

valor de un registro en concreto (valor que ha sido devuelto por lafuncion gca data register info).

El valor devuelto por esta funcion es el numero que identifica a un registroconcreto o -1 si se ha producido algun error.


gca data register value

word g c a d a t a r e g i s t e r v a l u e ( GcaDataRegister ∗ reg ) ;

Funcion que obtiene el valor de un registro identificado por una estructuraGcaDataRegister.

reg Puntero a una estructura GcaDataRegister que almacena numero yvalor de un registro en concreto (valor que ha sido devuelto por lafuncion gca data register info).

El valor devuelto por esta funcion es el valor que contiene un registroconcreto o -1 si se ha producido algun error.

gca data register name

GcaList ∗ gca da ta r eg i s t e r name( GcaSess ion ∗ ses , u int number ) ;

Esta funcion obtiene el nombre que se utiliza dentro del simulador pa-ra identificar un registro del sistema. En GDB no hay un comando equivalentepara esta funcion, aunque sı en la interfaz mi1, -data-list-register-names.


number Entero que identifica el registro. Si este parametro toma el valorALL REGISTERS se obtiene una lista de cadenas de caracteres con losnombres de todos los registros del sistema.

El valor devuelto es un puntero a una estructura GcaList cuyo punterogenerico contiene una cadena de caracteres con el nombre del registro o unpuntero nulo si se ha producido algun error. Si se ha proporcionado el valorALL REGISTERS al parametro number se devuelve una lista de cadenas conlos nombres de todos los registros del sistema.

Estas estructuras no deben liberarse por el programador, pues son unacaracterıstica constante del sistema, ligados a la estructura GcaSession, yes el sistema el que se encargara de liberar esos elementos cuando termine lasesion de depuracion.

3.2 API 45

gca data register get number

int g c a d a t a r e g i s t e r g e t n u m b e r( GcaSess ion ∗ ses , const char ∗name ) ;

Descripcion

Funcion que, dado el nombre de un registro, devuelve el numero corres-pondiente que tambien lo identifica.


name Cadena de caracteres que contiene el nombre del registro cuyo numeroidentificativo se quiere obtener.

Esta funcion devuelve el numero correspondiente al nombre de un registroo -1 si se ha producido algun error.

gca data register info

GcaDataRegister ∗ g c a d a t a r e g i s t e r i n f o( GcaSess ion ∗ ses , u int number ) ;

Funcion que suministra informacion sobre los registros del sistema. Esequivalente a teclear info reg (-data-list-register-values) en la consola de co-mandos de GDB.


number Entero que identifica el registro. Si este parametro toma el valorALL REGISTERS se obtiene una lista con la informacion de todos losregistros del sistema.

Esta funcion devuelve un puntero a una estructura GcaDataRegister conla informacion (numero y valor) sobre un registro concreto del sistema o unpuntero nulo en caso de error. Si se ha proporcionado el valor ALL REGISTERS

al parametro number se obtiene una lista de punteros GcaDataRegister conla informacion de todos los registros del sistema.

La memoria reservada para estos elementos debe ser liberada por el pro-gramador mediante la funcion gca data register free.


gca data changed registers

GcaList ∗ g c a d a t a c h a n g e d r e g i s t e r s ( GcaSession ∗ s e s ) ;

Esta funcion sirve para conocer el nombre de todos los registros que hancambiado tras una instruccion de flujo de programa. GDB no tiene un coman-do equivalente para esta funcion, aunque mi1 sı lo tiene, -data-list-changed-registers.


La funcion devuelve una lista de cadenas de caracteres con los nombresde todos los registros del sistema que han cambiado tras una instruccion deflujo de programa o un puntero nulo si se ha producido algun error.

Esta lista, a diferencia de lo que ocurre con la que devuelve la funciongca data register name sı tiene que ser liberada por el programador mediantela funcion gca list free.

gca data register count

int g c a d a t a r e g i s t e r c o u n t ( GcaSession ∗ s e s ) ;

Funcion que obtiene el numero de registros del sistema.


El valor que se devuelve es el numero de registros del sistema.

gca data register free

void g c a d a t a r e g i s t e r f r e e ( GcaDataRegister ∗ reg ) ;

Funcion que libera la memoria reservada por el sistema para contener unelemento de tipo GcaDataRegister.

reg Puntero a una estructura GcaDataRegister que almacena numero yvalor de un registro en concreto (valor que ha sido devuelto por lafuncion gca data register info).

3.2 API 47

3.2.8. gca-file.h

En este fichero de la interfaz se encuentran un par de funciones que estanrelacionadas con los ficheros que intervienen en un programa, tanto el propiofichero ejecutable como los ficheros fuente que lo componen.

Hay que destacar que, en caso de que la sesion de depuracion se abrierasin especificar ningun fichero ejecutable, aquı se encuentra la funcion parahacerlo, gca file exe.

gca file exe

int g c a f i l e e x e( GcaSess ion ∗ ses , const char ∗ x f i l e ) ;

Esta funcion especifica el fichero ejecutable que va a ser depurado.


xfile Cadena que almacena el nombre del fichero ejecutable.


gca file sources

GcaList ∗ g c a f i l e s o u r c e s ( GcaSession ∗ s e s ) ;

Funcion que devuelve una lista de cadenas de caracteres con los nombresde todos los ficheros fuente que conforman el progrma.


El valor devuelto por esta funcion es una lista de estructuras GcaList

que contienen los nombres de los ficheros fuentes que forman el programa.

Esta lista, puesto que es una constante para una sesion de depuracion,esta ligada a la estructura GcaSession, de modo que el programdor no tieneque liberar la memoria reservada para contenerla. De eso ya se ocupa lapropia biblioteca.


gca file main

const char ∗ g c a f i l e m a i n ( GcaSession ∗ s e s ) ;

Con esta funcion se puede obtener el nombre del fichero donde se encuen-tra la funcion principal (main) del programa.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


El valor devuelto por esta funcion es una cadena que contiene el nombredel fichero donde se encuentra la funcion main. De igual modo que ocurrecon la funcion anterior, el programador no debe liberar la memoria reservadapara esta cadena, pues, de hecho, no es mas que una de las que se obtienencon la funcion gca file sources y ya se ocupa la biblioteca tanto de crearlacomo de liberarla.

3.2.9. gca-stop.h

Este fichero contiene tan solo la definicion de las razones por las que GDBdetiene la ejecucion de un programa.

Para eso se define un tipo enumerado GcaStopReason que permite a unprograma trabajar de forma sencilla con estas razones, a la vez que se pro-porciona una funcion que transforma los valores de este tipo enumerado encadenas de caracteres, mas entendibles para las personas.

Como se vera a continuacion, las funciones que manejan los comandosde flujo de programa devuelven un valor de este tipo GcaStopReason, cuyadefinicion es la siguiente:

typedef enum {GCA STOP REASON BREAKPOINT HIT = 0 ,GCA STOP REASON END STEPPING RANGE,GCA STOP REASON FUNCTION FINISHED,GCA STOP REASON LOCATION REACHED,GCA STOP REASON SIGNAL RECEIVED,GCA STOP REASON EXITED NORMALLY,GCA STOP REASON EXITED} GcaStopReason ;

El valor 0 de este tipo, GCA STOP REASON BREAKPOINT HIT, se produ-ce cuando el programa se ha detenido a causa de un punto de ruptura.El siguiente, GCA STOP REASON END STEPPING RANGE, se devuelve cada vez

3.2 API 49

que se da un comando de ejecutar la siguiente instruccion, ya sea un co-mando next, next instruction, step o step instruction. GDB devuelve el valorGCA STOP REASON FUNCTION FINISHED cuando tiene lugar el comando de ter-minar con la ejecucion de una funcion (finish). Cuando se ejecuta, sin embar-go, el comando de ejecutar el programa hasta un determinado punto del mis-mo (until), el valor que devuelve GDB es GCA STOP REASON LOCATION REACHED.Todos estos valores implican que la ejecucion del programa se ha detenido enun punto de ruptura y el programador comienza a controlarla paso a paso.

Cuando un programa se ejecuta y no encuentra puntos de ruptura ensu camino, termina normalmente (GCA STOP REASON EXITED NORMALLY) o deforma excepcional, esto es, con un codigo de salida (GCA STOP REASON EXITED).Tambien puede detenerse la ejecucion del programa a causa de una senal delsistema operativo (GCA STOP REASON SIGNAL RECEIVED).

gca stop reason

const char ∗ gca s t op r ea so n ( GcaStopReason reason ) ;

Con esta funcion se puede convertir los valores numericos del tipo enu-merado GcaStopReason en cadenas de caracteres.reason Valor de tipo GcaStopReason que corresponde a una de las razones

por las que GDB detiene la ejecucion del programa (es un valor devueltopor las funciones de flujo de programa).

El valor devuelto por esta funcion es una cadena de caracteres con laexplicacion textual correspondiente a un codigo numerico de detencion deprograma.

Estas cadenas son constantes definidas en la biblioteca, puesto que lasrazones de detencion de un programa son finitas y perfectamente concocidaspor GDB, de manera que el programador no tiene que liberarlas.

3.2.10. gca-program-flow.h

Este es uno de los ficheros mas importantes, o mas utiles al menos, de lainterfaz de la biblioteca. Aquı se encuentra implementada toda la funciona-lidad que tiene que ver con los comandos de flujo de programa.

Todas las funciones de este fichero son similares. Cada una de ellas re-presenta un comando de flujo de programa y devuelven un entero que es uncodigo representativo de la razon por la cual se ha detenido la ejecucion delprograma. Este entero toma valores del tipo GcaStopReason que se define


en el fichero gca-stop.h y que se ha visto anteriormente. De esta manera, elprogramdor puede controlar a su antojo la ejecucion del programa y conocercual es el estado del mismo en cada paso.

gca program flow continue

int gca program f low cont inue ( GcaSession ∗ s e s ) ;

Funcion que reanuda la ejecucion del programa que esta siendo depurado.Se corresponde con el comando continue (-exec-continue) de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


El valor devuelto por esta funcion es un valor del tipo GcaStopReason conel codigo que representa una determinada razon de detencion del programao -1 en caso de que se haya producido algun error.

gca program flow finish

int g c a p r o g r a m f l o w f i n i s h ( GcaSess ion ∗ s e s ) ;

Funcion que reanuda la ejecucion del programa depurado hasta finalizarla funcion actual en la que se encuentra dicho programa. Es equivalente alcomando finish (-exec-finish) de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-



gca program flow next

int gca program f low next ( GcaSession ∗ s e s ) ;

Funcion que ejecuta una instruccion de codigo fuente del programa. Esequivalente a teclear next (-exec-next) en la lınea de comandos de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


3.2 API 51


gca program flow next instruction

int g c a p r o g r a m f l o w n e x t i n s t r u c t i o n ( GcaSession ∗ s e s ) ;

Funcion que ejecuta una instruccion de codigo maquina del programa. Esequivalente al comando nexti (-exec-next-instruction) de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-



gca program flow return

int gca program f low return ( GcaSession ∗ s e s ) ;

Funcion que hace que se vuelva inmediatamente de la funcion actual. Sila instruccion es una llamada a funcion, la ejecucion continua hasta que sevuelve de dicha funcion. Es equivalente a teclear return (-exec-return) en lalınea de comandos de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-



gca program flow run

int gca program f low run ( GcaSession ∗ s e s ) ;

Funcion que inicia la ejecucion del programa a depurar. Es equivalente alcomando run (-exec-run) de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-




gca program flow step

int gca program f low step ( GcaSession ∗ s e s ) ;

Funcion que ejecuta una instruccion de codigo fuente del programa. Si lainstruccion es una llamada a funcion, la ejecucion se detiene en la primerainstruccion de dicha funcion. Es equivalente a teclear step (-exec-step) en laconsola de comandos de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-



gca program flow step instruction

int g c a p r o g r a m f l o w s t e p i n s t r u c t i o n ( GcaSession ∗ s e s ) ;

Funcion que ejecuta una instruccion de codigo maquina del programa. Sila instruccion es una llamada a funcion, la ejecucion se detiene en la primerainstruccion de dicha funcion. Es equivalente a teclear stepi (-exec-step) en laconsola de comandos de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-



gca program flow until

int gca p rog ram f l ow unt i l( GcaSess ion ∗ ses , const char ∗ l o c a t i o n ) ;

3.2 API 53

Funcion que ejecuta el programa a depurar hasta que se alcanza un puntodeterminado especificado por el programador. Se puede especificar medianteel nombre de una funcion, mediante una lınea de un determinado fichero fuen-te (fichero fuente:lınea) o mediante una direccion de memoria. Es equivalenteal comando until (-exec-until) de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


location Cadena que contiene el punto donde va a detenerse el programa.


3.2.11. gca-variable.h

La biblioteca GCA define un tipo para almacenar el nombre y el valorde una variable. De esta forma, si se interroga a GDB por el valor de unacierta variable, ya sea una interna de GDB o una definida en el programa, labiblioteca devolvera una variable de este tipo.

El tipo GcaVariable es una estructura con dos campos, que representanel nombre y el valor de la variable, respectivamente. Estos dos campos hansido definidos como cadenas de caracteres. Esto es algo logico en el camponombre, pero quizas no tanto en el campo valor. Sin embargo, dado que labiblioteca no puede conocer a priori el tipo de la variable por la que se leinterroga, devuelve el valor como cadena de caracteres y deja al programadorla tarea de convertirlo en otro tipo mas apropiado, si este ası lo desea.

Hay que hacer notar que este tipo GcaVariable puede ser consideradocomo una lista, de manera que se puede utilizar para contener la informacionrelativa a una serie de variables.

Por ultimo, tambien es conveniente senalar que el espacio reservado pa-ra este tipo de estructuras es reservado por el sistema, pero es tarea delprogramador liberarlo cuando deje de utilizarlo.

gca variable name

const char ∗ gca var iab le name ( GcaVariable ∗var ) ;

Esta funcion devuelve el nombre de una variable especificada por unaestructura GcaVariable.


var Puntero a una estructura GcaVariable que contiene la informacion re-lativa a una determinada variable.

El valor devuelto por esta funcion es una cadena de caracteres que con-tiene el nombre de una variable o un puntero nulo en caso de error.

gca variable value

const char ∗ g c a v a r i a b l e v a l u e ( GcaVariable ∗var ) ;

Esta funcion devuelve el valor de una variable especificada por una es-tructura GcaVariable.var Puntero a una estructura GcaVariable que contiene la informacion re-

lativa a una determinada variable.

El valor devuelto por esta funcion es una cadena de caracteres que con-tiene el valor de una variable o un puntero nulo en caso de error.

gca variable free

void g c a v a r i a b l e f r e e ( GcaVariable ∗var ) ;

Funcion que libera el especio reservado para contener una variable deltipo GcaVariable.var Puntero a una estructura GcaVariable que contiene la informacion re-

lativa a una determinada variable.

3.2.12. gca-argument.h

En relacion con el tipo GcaVariable que se acaba de ver, la bibliotecatambien define un tipo GcaArgument para contener la informacion relativa alos argumentos de las funciones de un programa. Esta informacion solo puedeconocerse para las funciones que forman, en un instante determinado, la pilade programa.

De hecho y por esta razon, este tipo GcaArgument no es mas que unaestructura basada en la definida previamente, GcaVariable, a la que se leanade un entero que indica el nivel de la funcion en la pila del programa.

Este tipo tambien puede ser tratado como una lista, ası que puede con-vertirse explıcitamente al tipo GcaList para ser usado en las funciones quemanejan listas enlazadas.

Es obvio, entonces, que el programador tambien debe ocuparse de liberarel espacio que la biblioteca reserva para crear este tipo de estructuras.

3.2 API 55

gca argument level

int gca argument l eve l ( GcaArgument ∗arg ) ;

Con esta funcion se obtiene el nivel de la pila en la que se encuentra lafuncion cuyos argumentos estan indicados por la estructura GcaArgument.arg Puntero a una estructura GcaArgument que contiene la informacion

relativa al argumento de una determinada funcion.

El valor devuelto por esta funcion es un entero que indica el nivel de lafuncion en la pila o -1 si se ha producido algun error.

gca argument variable

GcaVariable ∗ gca argument var iab l e ( GcaArgument ∗arg ) ;

Funcion que permite conocer las variables propiamente dichas de unafuncion en la pila de programa y que estan contenidas en una estructura detipo GcaArgument.arg Puntero a una estructura GcaArgument que contiene la informacion re-

lativa al argumento de una determinada funcion.

Esta funcion devuelve un puntero a una estructura GcaVariable que con-tiene informacion de todas las variables que son argumentos de una funciono un puntero nulo si se ha producido algun error.

gca argument free

void gca argument f r ee ( GcaArgument ∗arg ) ;

Funcion que libera el especio reservado para contener una variable deltipo GcaArgument.arg Puntero a una estructura GcaArgument que contiene la informacion re-

lativa al argumento de una determinada funcion.

3.2.13. gca-stack-frame.h

En este fichero de la interfaz se encuentran todas las funciones relaciona-das con la pila del programa.


Cada vez que un programa hace una llamada a una funcion se generainformacion sobre esa llamada. Esta informacion incluye la situacion de lallamda en el programa, los argumentos de la llamada y las variables localesde la funcion llamada. Esta informacion se guarda en un bloque de datosllamado stack frame. Los stack frames se situan en una region de memoriallamada pila (call stack).

Ası que la pila de llamadas esta dividida en bloques contiguos llamadosstack frames o directamente frames. Cada frame esta formado por los datosasociados a una llamada a funcion y contiene los argumentos que se pasan adicha funcion, sus variables locales y la direccion en la cual se esta ejecutandola funcion.

Cuando el programa comienza, la pila tiene solo un frame, el de la funcionprincipal. Este es llamado frame inicial o outermost frame. Cada vez que seregresa de una funcion, el frame para esa invocacion de funcion es eliminado.El frame de la funcion que se esta ejecutando actualmente se llama innermostframe.

En el programa, los stack frames se identifican mediante sus direcciones.Un stack frame esta formado por muchos bytes, cada uno con su propia di-reccion; cada tipo de maquina tiene su modo de elegir un byte cuya direccionsirva como direccion del frame. Normalmente, esta dierccion se almacena enun registro llamada frame pointer register mientras la ejecucion ocurra enese frame.

Para albergar la informacion sobre la pila, la biblioteca GCA define unaestructura GcaStakcFrame, que representa un frame de la pila y que contienetoda su informacion caracterıstica. Esta informacion es el nivel que ocupa elframe en la pila, la direccion de memoria en la que se encuentra la funcionque ha sido llamada, el nombre de dicha funcion, sus argumentos, el ficheroen el que esta definida y la lınea concreta dentro de este fichero donde se hadetenido la ejecucion del programa.

Esta estructura GcaStackFrame es tambien una lista, por lo que puedeutilizarse, tras su conversion al tipo adecuado, en las funciones que manejanesta estructura dinamica.

Es tarea del programador liberar el espacio que la biblioteca reserva paraestas estructuras mediante la funcion gca stack frame free.

Tambien hay que hacer notar que la biblioteca no las crea una vez y actua-liza su contenido, sino que crea dinamicamente estructuras de este tipo cadavez que se le solicita mediante las funciones gca stack frame backtrace ygca stack frame info.

gca stack frame level

3.2 API 57

int g c a s t a c k f r a m e l e v e l ( GcaStackFrame ∗ s f ) ;

Funcion que sirve para conocer el nivel en la pila que ocupa el frameidentificado por una estructura GcaStackFrame.sf Puntero a una estructura GcaStackFrame que identifica un frame de la pila

y que ha sido devuelto por las funciones gca stack frame backtrace

o gca stack frame info.

El valor devuelto por esta funcion es un entero que indica el nivel delframe en la pila o -1 si se ha producido algun error.

gca stack frame address

address g ca s t a ck f r ame addr e s s ( GcaStackFrame ∗ s f ) ;

Funcion con la que se puede conocer la direccion de memoria donde seubica la funcion cuya llamada es un determinado frame de la pila identificadopor una estructura GcaStackFrame.sf Puntero a una estructura GcaStackFrame que identifica un frame de la pila



Se devuelve un valor de tipo address con la direccion de la funcion co-rrespondiente a un determinado frame de la pila o 0 si se ha producido algunerror.

gca stack frame function

const char ∗ g c a s t a c k f r a m e f u n c t i o n( GcaStackFrame ∗ s f ) ;

Funcion que sirve para conocer el nombre de la funcion cuya llamada es undeterminado frame de la pila identificado por una estructura GcaStackFrame.sf Puntero a una estructura GcaStackFrame que identifica un frame de la pila



El valor devuelto por este metodo es una cadena de caracteres que con-tiene el nombre de la funcion correspondiente a un determinado frame de lapila o un puntero nulo en caso de error.


gca stack frame args

GcaVariable ∗ g c a s t a c k f r a m e a r g s ( GcaStackFrame ∗ s f ) ;

Con esta funcion se pueden obtener todas los argumentos de la funcioncuya llamada es un determinado frame de la pila identificado por una estruc-tura GcaStackFrame.sf Puntero a una estructura GcaStackFrame que identifica un frame de la pila



Esta metodo devuelve un puntero a una estructura GcaVariable que con-tiene la informacion relativa a los argumentos de la funcion correspondientea un deteminado frame de la pila o un puntero nulo si se ha producido algunerror.

gca stack frame file

const char ∗ g c a s t a c k f r a m e f i l e ( GcaStackFrame ∗ s f ) ;

Con esta funcion se puede conocer el nombre del fichero donde se encuen-tra la funcion cuya llamada es un determinado frame de la pila identificadopor una estructura GcaStackFrame.sf Puntero a una estructura GcaStackFrame que identifica un frame de la pila



Este metodo devuelve una cadena de caracteres que contiene el nombredel fichero donde se encuentra la funcion correspondiente a un determinadoframe de la pila o un puntero nulo en caso de error.

gca stack frame line

int g c a s t a c k f r a m e l i n e ( GcaStackFrame ∗ s f ) ;

Funcion que sirve para encontrar la lınea de codigo fuente dentro de unfichero que corresponde a una funcion cuya llamada es un determinado framede la pila identificado por una estructura GcaStackFrame.sf Puntero a una estructura GcaStackFrame que identifica un frame de la pila



3.2 API 59

El valor devuelto por este metodo es un entero que contiene la lınea decodigo fuente donde se encuentra la funcion correspondiente a un determi-nado frame de la pila o 0 en caso de que se haya producido algun error.

gca stack frame depth

int gca s tack f rame depth ( GcaSess ion ∗ s e s ) ;

Funcion que sirve para conocer la profundidad de la pila de llamadas.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


Se devuelve la profundidad de la pila o -1 si se ha producido algun error.

gca stack frame backtrace

GcaStackFrame ∗ gca s ta ck f r ame back t ra c e( GcaSess ion ∗ s e s ) ;

Funcion que proporciona informacion sobre toda la pila del programa. Esequivalente, pues, al comando backtrace (-stack-list-frames) de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


Esta funcion devuelve un puntero a una estructura GcaStackFrame contoda la informacion de la pila completa (es una lista, por tanto) o un punteronulo en caso de error.

La memoria reservada por esta funcion para esta lista de estructuras debeser liberada por el programador mediante la funcion gca stack frame free.

gca stack frame info

GcaStackFrame ∗ g c a s t a c k f r a m e i n f o( GcaSess ion ∗ ses , u int l e v e l ) ;

Funcion que suministra informacion sobre un frame de la pila de llamadasdel sistema.ses Puntero a una estructura GcaSession que identifica una sesion de depu-

racion (valor que ha sido devuelto por una llamada a gca session init).Equivale a teclear info frame (-stack-info-frame) en la consola de coman-dos de GDB.


level Entero que identifica el frame de la pila. Si este parametro toma el valorALL FRAMES se obtiene informacion sobre toda la pila de programa (esequivalente entonces a llamar a gca stack frame backtrace).

Esta funcion devuelve un puntero a una estructura GcaStackFrame con lainformacion relativa a un frame de la pila o un puntero nulo en caso de error.Si se ha utilizado el valor ALL FRAMES para el parametro level, se obtienetoda una lista de estructuras de este tipo con la informacion referente a todala pila de programa.

La memoria reservada por esta funcion para este tipo de estructuras debeser liberada por el programador mediante la funcion gca stack frame free.

gca stack frame arguments

GcaArgument ∗ gca stack f rame arguments( GcaSess ion ∗ ses , u int l e v e l ) ;

Funcion que muestra los argumentos y sus valores de un frame de la pila.Aunque GDB no tiene un comando equivalente, la interfaz mi1 proporcionala orden -stack-list-arguments.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


level Entero que identifica el frame de la pila. Si este parametro toma elvalor ALL FRAMES se obtiene informacion sobre los argumentos toda lapila de programa.

Se devuelve un puntero a una estructura GcaArgument con los argumentosde un frame de la pila o un puntero nulo si se ha producido algun error. Sise ha utilizado el valor ALL FRAMES para el parametro level, se obtiene todauna lista de estructuras de este tipo con la informacion referente a todos losargumentos de las llamadas de la pila de programa.


gca stack frame locals

GcaVariable ∗ g c a s t a c k f r a m e l o c a l s( GcaSess ion ∗ ses , u int l e v e l ) ;

3.2 API 61

Funcion que muestra las variables locales y sus valores correspondientesde un frame de la pila. Esto es equivalente a teclear info locals (-stack-list-locals) en la consola de comandos de GDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


level Entero que identifica el frame de la pila. Si este parametro toma elvalor ALL FRAMES se obtiene informacion sobre las variable locales detodas las funciones de la pila de programa.

Se devuelve un puntero a una estructura GcaVariable con las variableslocales de un frame de la pila o un puntero nulo si se ha producido algun error.Si se ha utilizado el valor ALL FRAMES para el parametro level, se obtienetoda una lista de estructuras de este tipo con la informacion referente a todoslas variables locales de las funciones de la pila de programa.


gca stack frame free

void g c a s t a c k f r a m e f r e e ( GcaStackFrame ∗ s f ) ;

Funcion que libera el especio reservado para contener una variable deltipo GcaStackFrame.sf Puntero a una estructura GcaStackFrame que identifica un frame de la pila

(valor que ha sido devuelto por las funciones gca stack frame backtrace

o gca stack frame info).

3.2.14. gca-target.h

Las funciones de este fichero de la interfaz estan relacionadas con lostargets que GDB puede manejar. Un target es el entorno de ejecucion de unprograma.

Normalmente, GDB se ejecuta en la misma maquina que el programa queesta depurando. Sin embargo, tambien se puede hacer que GDB se ejecuteen una maquina distinta de la que ejecuta el programa (cross-debugging)o incluso controlar la ejecucion de un sistema sobre el puerto serie o unaconexion TCP/IP.

Se ha definido entonces un tipo enumerado GcaTargetType para indicarlos distintos targets con los que GDB puede trabajar.


De momento, en esta primera version de la biblioteca GCA, tan solo secontempla el uso de GDB como cross-debugger. De este modo, solo hay unvalor para el tipo enumerado GcaTargetType:

typede enum {GCA TARGET TYPE SIMULATOR = 0} GcaTargetType ;

Esto quiere decir que, una vez iniciada una sesion de depuracion, si sequiere utilizar GDB como cross-debugger, habra que indicarle este tipo detarget. Esto se consigue mediante la funcion gca target select type conel valor GCA TARGET TYPE SIMULATOR para el parametro type.

Una vez hecho esto, lo unico que resta para empezar con la sesion dedepuracion es cargar el ejecutable, tarea que se consigue con la funciongca target load program.

gca target select type

int g c a t a r g e t s e l e c t t y p e( GcaSess ion ∗ ses , GcaTargetType type ) ;

Funcion que selecciona el tipo de target en una sesion de depuracion. Estoes equivalente a teclear target (-target-select) en la consola de comandos deGDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


type Enumerado del tipo GcaTargetType que identifica el tipo de target.


gca target load program

int gca ta rge t l oad prog ram ( GcaSession ∗ s e s ) ;

Funcion que carga en el simulador el fichero ejecutable a depurar. Esequivalente a teclear load (-exec-download) en la consola de comandos deGDB.ses Puntero a una estructura GcaSession que identifica una sesion de depu-


3.2 API 63


gca target start simulator

int g c a t a r g e t s t a r t s i m u l a t o r ( GcaSession ∗ s e s ) ;

Funcion que inicia el simulador y carga en el simulador el fichero ejecu-table a depurar. Esta funcion no es mas que la union de las dos anteriores.ses Puntero a una estructura GcaSession que identifica una sesion de depu-



Capıtulo 4

Modificaciones al simulador deGDB

4.1. Simuladores en GDB

Una de las capacidades mas interesantes de GDB es la de trabajar comodepurador cruzado (cross-debugger). Esto es, GDB puede utilizarse para de-purar programas que estan escritos para ejecutarse en maquinas diferentes dela propia maquina en que se ejecuta GDB. Aparecen, entonces, dos tipos desistemas. Se habla de host cuando se hace referencia al sistema donde se eje-cuta GDB. Por otro lado, cuando se quiere hacer referencia al sistema dondeva a ejecutarse el programa que esta siendo depurado se habla de target.

En la mayorıa de los casos, host y target seran la misma maquina. Enlos casos en los que esto no ocurre es cuando se dice que GDB trabaja comodepurador cruzado. Ası ha sido en este proyecto, puesto que se ha utilizadogdb para depurar programas escritos para la arquitectura MCore (target),mientras que el propio gdb se ejecutaba en una arquitectura Intel x86 (host).

Existen muchos tipos de targets, que se especifican a traves del comandotarget. Los que interesan en este proyecto son los simuladores de CPUs, quese indican con el parametro sim. GDB incluye simuladores para la mayorıade arquitecturas, la basada en el microprocesador MCore de Freescale entreellas.

El target se puede especificar como una de las opciones de configuracioncuando se esta compilando el paquete GDB. En el caso de este proyecto,gdb se ha compilado utilizando esta opcion con el valor –target=mcore-elf.De esta manera, se obtiene una version de GDB (mcore-elf-gdb) que ejecu-tara el simulador del microprocesador MCore cuando se ordene el comandotarget sim.

66 Modificaciones al simulador de GDB

Ademas del propio GDB, con el proceso de compilacion se obtienen unaserie de herramientas (todas con el prefijo mcore-elf) que permiten trabajarcon los ficheros ejecutables y proporcionan informacion sobre ellos. Entreestas herramientas, una especialmente interesante es la que tiene por nombremcore-elf-run. Si se ejecuta esta herramienta junto con el nombre de un ficheroejecutable se pone en funcionamiento el simulador y este ejecuta el programasin interrupcion. No sirve, pues, para depurar, pero puede utilizarse comouna primera forma de ver si el progama construido tiene algun tipo de falloy se interrumpe cuando se ejecuta.

A continuacion se va a echar un vistazo a la estructura de los simuladoresen GDB. En el diectorio donde se encuentran los archivos fuente de gdb existeun diectorio sim donde se puede encontrar casi todo lo relativo a los simula-dores. En este directorio existe un subdirectorio para cada arquitectura queGDB soporta y un subdirectorio common. En este subdirectorio, obviamente,se encuentra casi todo lo que es comun al funcionamiento de los simuladoresen GDB y no especıfico de cada arquitectura.

La interfaz entre los simuladores y GDB se define, sin embargo, en elfichero sim-remote.h. En este fichero se encuentra la definicion de todas lasfunciones necesarias que todo target debe implementar si quiere funcionardentro de GDB. La definicion es, por tanto, comun a todas las arquitecturas,mientras que su declaracion es particular a cada una de ellas.

4.1.1. Interfaz de los simuladores en GDB

Se va a estudiar, entonces, con algo mas de detalle la interfaz definida deGDB con los simuladores que soporta.

sim open

SIM DESC sim openPARAMS ( ( SIM OPEN KIND kind ,

struct h o s t c a l l b a c k s t r u c t ∗ ca l lback ,struct bfd ∗abfd , char ∗∗ argv ) ) ;

Esta funcion crea una instancia del simulador completamente iniciada.El simulador creado estara lo suficiente preparado como para manejar, sinninguna restriccion, cualquier peticion del cliente (incluyendo lecturas y escri-turas de memoria, almacenamiento y extraccion de valores de los registros yla continuacion de la ejecucion). Se llama a esta funcion cuando se seleccionael simulador desde la lınea de comandos de GDB.

4.1 Simuladores en GDB 67

kind especifica como se usara el simulador. Actualmente solo hay dostipos: stand-alone y debug. (Poner la definicion del tipo SIM OPEN KIND.)

callback especifica un callback estandar de host. (Hablar quizas de loque son los callbacks).

abfd, cuando no es NULL, designa un programa target. El programa noesta cargado. (Hablar quizas de lo que es la librerıa bfd.)

argv es un puntero argv estandar como el que se pasa desde la lınea decomandos. (Hablar de la sintaxis de la lista de argumentos.)

Si se tiene exito, el resultado es un descriptor no nulo que se pasara al restode las funciones sim *. (Poner la definicion del tipo SIM DESC y comentarsi las opciones son necesarias para el exito de la llamada.)

sim close

void s i m c l o s e PARAMS ( (SIM DESC sd , int q u i t t i n g ) ) ;

Esta funcion destruye una instancia de simulador. Esto puede incluir li-berar memoria del target y cerrar todos los ficheros abiertos y las areas dememorias mapeadas.

quitting es distinto de cero si no se puden manejar errores.

sim load

SIM RC sim loadPARAMS ( (SIM DESC sd , char ∗prog ,

struct bfd ∗abfd , int f o rm tty ) ) ;

Esta funcion carga el programa prog en la memoria del simulador. Nor-malmente, cada seccion del programa se escribe en memoria en funcion delas direcciones fısicas o directas (LMA). Una llamada a esta funcion no de-berıa afectar al estado de los registros del procesador. Se permiten multiplesllamadas, teniendo en cuenta que tendrıan un efecto acumulativo.

Si abfd es distinto de cero, el bfd del fichero ya ha sido abierto. El resul-tado es un codigo de retorno que indica exito. (Poner la definicion del tipoSIM RC).

sim create inferior

SIM RC s i m c r e a t e i n f e r i o rPARAMS ( (SIM DESC sd , struct bfd ∗abfd ,

char ∗∗argv , char ∗∗env ) ) ;


Esta funcion prepara el sistema para ejecutar el programa simulado. Ini-ciara los registros del procesador a un valor conocido. Se dara valor al conta-dor de programa, y posiblemente al puntero de pila, utilizando la informacionobtenida de abfd (o se usaran valores hardware por defecto). argv y env, enfuncion del ABI1 del target, pueden ser escritos en la memoria.

abfd, si es distinto de cero, provee informacion inicial del estado del pro-cesador.

argv y env, cuando son distintos de NULL, son listas de punteros termi-nadas en punteros nulos.sim read

int s im readPARAMS ( (SIM DESC sd , SIM ADDR mem,

unigned char ∗buf , int l ength ) ) ;

Esta funcion extrae length bytes de la memoria del programa simulador.La extraccion comienza en la direccion virtual mem y tiene como destino ladireccion buf. El resultado es el numero de bytes leıdos o cero si hay algunerror.sim write

int s im wr i t ePARAMS ( (SIM DESC sd , SIM ADDR mem,

unsigned char ∗buf , int l ength ) ) ;

Esta funcion almacena length bytes procedentes de buf en la memoriade simulacion. El almacenamiento de bytes comienza en la direccion virtualmem. El resultado es el numero de bytes escritos o cero si ha habido algunerror.sim fetch register

int s i m f e t c h r e g i s t e rPARAMS ( (SIM DESC sd , int regno ,unsigned char ∗buf , int l ength ) ) ;

Esta funcion extrae el valor del registro regno, almacenando su valor raw(target endian) en BUF. Devuelve el tamano actual del registro o cero siregno no tiene un valor aplicable.

1Application Binary Interface.


Si regno no coincide con el tamano de regno no se transfiere ningun dato(pero se devuelve el tamano del registro).sim store register

int s i m s t o r e r e g i s t e rPARAMS ( (SIM DESC sd , int regno ,

unsigned char ∗buf , int l ength ) ) ;

Esta funcion almacena en el registro REGNO el valor raw (target endian)contenido en BUF. Devuelve el tamano actual del registro o cero si REGNOno tiene un valor aplicable.

Si LENGTH no coincide con el tamano de REGNO no se transfiere ningundato (pero se devuelve el tamano del registro).sim info

void s i m i n f o PARAMS ( (SIM DESC sd , int verbose ) ) ;

Esta funcion imprime las estadısticas que el simulador haya acumulado.verbose no se usa actualmente y debe ser siempre cero.

sim resume

void sim resume PARAMS ( (SIM DESC sd , int step ,int s i g g n a l ) ) ;

Esta funcion ejecuta el programa simulado o reanuda su ejecucion. Siel valor sigrc devuelto por sim stop reason se pasa de nuevo al simuladormediante el parametro siggnal, el simulador lanzara correctamente el eventohardware indicado por esa senal. Si se pasa, sin embargo, un valor nulo,entonces la simulacion continuara como si no hubiera una senal pendiente.El efecto de cualquier otro valor de siggnal depende de la implementacion.

step, cuando es distinto de cero, indica que solo debe ejecutarse un ciclodel simulador.

siggnal, si es distinto de cero, es un valor SIGRC del host que indica eltipo de evento (interrupcion de hardware, senal) que va a ser lanzado por elprograma simulador.sim stop

int s im stop PARAMS ( (SIM DESC sd ) ) ;


Esta funcion es una peticion asıncrona para detener la simulacion. Unvalor de retorno distinto de cero indica que el simulador es capaz de manejarla peticion.sim stop reason

enum s im stop { s im running , s im po l l i ng , s im ex i ted ,s im stopped , s i m s i g n a l l e d } ;

void s im s top rea sonPARAMS ( (SIM DESC sd , enum s im stop ∗ reason ,

int ∗ s i g r c ) ) ;

Esta funcion extrae la razon por la que el program se ha detenido.sim exited: El programa ha terminado. sigrc indica el estado de salida

(dependiente del target).sim stopped: El programa se ha detenido. sigrc usa la numeracion de

senales del host como una forma de identificar la razon: programa interrum-pido por el usuario mediante una peticion sim stop SIGINT ; instruccionde ruptura (SIGTRAP); ejecucion sencilla completada (SIGTRAP); condicionde error interno (SIGABRT); instruccion ilegal (SIGILL); acceso a una regionde memoria indefinida (SIGSEGV); acceso a memoria no alineada (SIGBUS).Para algunas senales, el simulador puede almacenar informacion adicional alnumero de senal, como puede ser la direccion de memoria involucrada, perodicha informacion no es directamente accesible a traves de esta interfaz.sim do commands

void sim do command PARAMS ( (SIM DESC sd , char ∗cmd ) ) ;

Esta funcion se utiliza para pasar otros comandos que el simulador pudierasoportar. Los simuladores deberıan poder tratar con cualquier combinacionde valores nulos o vacıos del parametro CMD.

4.1.2. Stand-alone simulation

En los sistemas basados en microcontroladores, se distinguen claramentedos grupos:

- stand-alone systems: son los sistemas finales, los productos que se ven-den. Estos sistemas ejecutan un unico programa cuando arrancan. Esteprograma debe estar disponible para la CPU cuando el sistema se en-ciende, ası que debe estar almacenado en una memoria no volatil; es lo


que se conoce como firmware, porque para modificar estos programashay que sustituir o cambiar la memoria ROM.

- development systems and computer systems: estos sistemas ejecutanmuchos programas diferentes, ası que el codigo de programa debe po-der ser cambiado facilmente. En los computes systems el sistema ope-rativo carga un programa desde el disco duro antes de ejecutarlo. Enlos development systems se carga un programa en la memoria, normal-mente desde una workstation, antes d ejecutarlo. Una vez cargado, elprograma se ejecuta. Esto quiere decir que los programas se cargan enun dispositivo de memoria que debe ser modificable.

Por supuesto, tanto unos sistemas como otros deben ejecutar un pro-grama cuando arrancan. Los computer systems tienen un firmware llamadobootloader o programa BIOS. Los development systems tiene un firmwareque consiste en un programa monitor.

El fichero principal de la utilidad mcore-elf-run es run.c, donde seencuentra la funcion principal main. Se puede echar un vistazo a esta funcioncomo una primera forma de comprender cual es el significado y la forma deutilizar las funciones de la interfaz de simuladores en gdb. La estructura dela funcion principal es relativamente sencilla. En primer lugar, se analizanlas opciones que se pasan mediante la lınea de comandos. Evidentemente, lautilidad necesita de un parametro fundamental que es el nombre del ficheroejecutable que se pretende simular. Ademas, existe una serie de opcionesque particularizan el comportamiento del simulador. Entre estas opciones sepuede encontrar alguna interesante, como puede ser la posibilidad de fijar lacantidad de memoria que va a utilizar el simulador o una salida mas detallada,con las instrucciones que se ejecutan en cada paso de simulacion.

A continuacion se comprueba el formato del fichero ejecutable, incluyendosu endianess. Esto se hace mediante funciones de la librerıa BFD. Una vez quese verificado que es fichero ejecutable es apto para la simulacion, se procede ala apertura e iniciacion del simulador con la funcion de la interfaz sim open.Seguidamente, se carga el fichero ejecutable en memoria (sim load) y seinician los registros del simulador (sim create inferior). Si no ha habidoningun problema en ninguna de estas operaciones, se procede a la ejecucion delas instrucciones del programa mediante la funcion sim resume. La condicionde salida de esta funcion, tanto si es una salida normal como si es una salidaproducto de un error, se recoge mediante la funcion adecuada y se imprimepor pantalla con el numero de senal correspondiente.

Hay que hacer notar que en la implementacion de la funcion sim load seha utilizado una funcion sim load file que se puede encontrar en el fichero


sim-load-file.c, en el directorio common. Esta funcion no pertenece a lainterfaz de los simuladores, pero permite cargar un fichero ejecutable en elsimulador, de manera que puede usarse en las implementaciones particularesde la interfaz en caso de que no haya requisitos especiales a la hora de efectuaresta operacion.

bfd ∗ s i m l o a d f i l e (SIM DESC sd , const char ∗myname ,h o s t c a l l b a c k ∗ ca l lback , char ∗prog , bfd ∗prog bfd ,int verbose p , int lma p , s i m w r i t e f n do wr i t e ) ;

Esta funcion carga el programa prog en el simulador usando la funciondo load.

Si prog bfd es no nulo, el fichero ya se ha abierto.Si verbose p es distinto de cero, se imprimen estadısticas de la carga de

cada seccion y de la tasa de transferencia.Si lma p is no no nulo, las secciones del programa se cargan en LMA en

lugar de en VMA.Si la funcion falla, se imprime un mensaje de error y se retorna NULL.

Si, por el contrario, tiene exito se devuelve un puntero bfd.En primer lugar, lo que se hace en esta funcion es comprobar si tenemos

un BFD abierto; si no lo estuviera, se abre con las funciones correspondientesde esta librerıa.

Seguidamente, se comprueba que su formato corresponde a algun tipo defichero objeto.

Hay un bucle for que recorre todas las secciones del BFD. La condicionque deben cumplir las secciones para que sean tratadas es que activo el flagsec load que indica al sistema operativo que cargue esa seccion desde elfichero en este proceso (loading). Este flag esta inactivo, por ejemplo, en unaseccion .bss. Ademas, el tamano de estas secciones loadables debe ser mayorque cero.

Entonces, para estas secciones, se toman sus datos y se pasan a un buferde memoria y, de aquı, se pasaran a la memoria del simulador correspondientecon la llamada a la funcion sim write mediante el puntero do write.

4.1.3. BFD

BFD2 es un paquete que permite a las aplicaciones usar las mismas rutinaspara operar sobre ficheros objeto cualesquiera que sean sus formatos.

BFD esta dividido en dos partes, el front end y el back end (uno paracada formato de fichero).

2Binary file descriptor


El front end presenta la interfaz al usuario. Gestiona la memoria y variasestructuras de datos canonicas. Decide ademas que back end usar y cuandollamar a sus rutinas.

El back end da a BFD su vision del mundo real. Cada back end tieneuna serie de llamadas que el front end de BFD puede usar para mantener suforma canonica.

BFD presenta una interfaz comun a las partes de un fichero objeto parauna aplicacion llamante.

Cuando una aplicacion abre con exito un fichero target (objeto, archivo olo que sea), se devuelve un puntero a una estructura interna llamada bfd. Porconvencion, al puntero se le llama un BFD y a sus instancias en el codigo,abfd. Todas las operaciones sobre el fichero objeto target se aplican comometodos del BFD.

La abstraccion usada en BFD es que un fichero objeto tiene:

- una cabecera

- un numero de secciones que contienen raw data

- una serie de reubicaciones

- alguna informacion de sımbolos

Cuando se abre un fichero objeto, las subrutinas BFD determinan au-tomaticamente el formato del fichero. Construyen entonces un descriptor enmemoria con punteros a rutinas que se usaran para acceder a los elementosde las estructuras de datos del fichero objeto. Cada back end BFD proveeuna rutina para la conversion entre la representacion del fichero objeto y unformato interno canonico. Naturalmente, hay otra rutina para deshacer elcambio. Esto puede provocar perdida de datos si se pasa, el enlazar, de unformato de entrada a otro de salida.

El formato canonico de fichero objeto de BFD tiene informacion, entreotras cosas, acerca de:

- ficheros: arquitectura de la maquina target, tipo del formato, byte or-der, /ldots

- secciones: nombre, direccion original en el fichero de entrada, tamano,informacion de alineacion, varios flags y punteros a otras estructurasde datos BFD.

- sımbolos: cuando un back end BFD lee una tabla de sımbolos, reubicatodos los sımbolos para hacerlos relativos a la base de la seccion dondeestan definidos.


4.1.4. Formatos ejecutables: ELF

Un fichero objeto producido por el ensamblador tiene, al menos, tressecciones (que pueden estar vacıas): text, data, bss. La seccion text comienzaen la direccion 0 y despues le siguen las secciones data y bss respectivamente.

Para permitir que el enlazador conozca que datos cambian cuando sereubican las secciones y como lo hacen, el ensamblador ademas anade alfichero objeto detalles de la reubicacion necesaria. Para poder llevar a cabola reubicacion, el enlazador debe conocer, cada vez que se menciona unadireccion en el fichero objeto:

- donde (en el fichero objeto) esta el comienzo de esa referencia a unadireccion.

- cual es la longitud en bytes de dicha referencia.

- a que seccion se refiere la direccion y cual es el valor numerico de ladireccion en relacion al comienzo de dicha seccion.

- si la referencia es relativa al contador de programa.

El enlazador, sin embargo, trata cuatro tipo de secciones:

secciones con nombre, secciones text y secciones data: estas secciones alma-cenan el programa. Cuando el programa se esta ejecutando, la seccion text semantiene inalterada. Es, a menudo, compartida entre procesos: contiene ins-trucciones, constantes y cosas ası. La seccion data contiene cosas que puedencambiar: las variables C, por ejemplo.

seccion bss: contiene bytes rellenados con ceros cuando el programa comienzaa ejecutarse. Se usa para almacenar variables sin iniciar.

seccion absolute: las direcciones de esta seccion no son reubicables.

seccion undefined: se utiliza para las referencias a direcciones que no estanen las secciones precedentes.

4.1.5. Enlazador

Para eso es necesario conocer, aunque sea de manera somera, las seccionesque componen un fichero objeto en el formato con el que trabaja el sistema.El microprocesador MCore trabaja con ficheros objetos de formato ELF3.

El principal proposito de un linker script es describir como las seccionesde los ficheros de entrada deben mapearse en el fichero de salida y controlar

3Executable and Linking Format


el layout de memoria de este fichero. La mayorıa de los linker scripts no hacenmas que esto. Sin embargo, cuando es necesario, el linker script puede dirigiral enlazador para que ejecute muchas otras operaciones. El enlazador siempreusa un linker script. Si no se le proporciona uno, usara un script por defecto.

Las secciones loadables implican que su contenido sera cargado en me-moria a la hora de ejecutar el fichero de salida. Una seccion sin contenidopuede ser allocatable, que significa que un area en memoria debe ser reserva-da, sin cargar nada en particular en ella. Una seccion que no es loadable niallocatable tıpicamente contiene algun tipo de informacion de depuracion.

Cada seccion de salida allocatable o loadable tiene dos direcciones. Laprimera es la VMA o direccion de memoria virtual. Esta es la direccion quetendra la seccion cuando se ejecute el fichero de salida. La segunda es laLMA o direccion de memoria de carga. Esta es la direccion en la cual secargara la seccion. En la mayorıa de los casos, ambas direcciones coincidiran.Un ejemplo de cuando pueden ser diferentes es cuando una seccion de datoses cargada en ROM y copiada en RAM cuando el programa comienza (estatecnica se usa a menudo para iniciar variables globales en un sistema basadoen ROM). En este caso, la direccion ROM sera la LMA y la direccion LMAsera la VMA.

Cada fichero objeto tiene ademas una lista de sımbolos, llamada tabla desımbolos. Un sımbolo puede estar definido o indefinido. Cada sımbolo tiene unnombre, y cada sımbolo definido tiene, ademas, entre otra informacion, unadireccion. Se tendra un sımbolo definido por cada funcion y variable globalo estatica definidas. Si no estan definidas, se tendra un sımbolo indefinido.

La primera instruccion a ejecutar en un programa se llama entry point.Hay que tener en cuenta que, en el desarrollo de sistemas empotrados, al

no disponerse de un sistema operativo que se encargue de la gestion de lamemoria de sistema (stand-alone systems), debe ser el propio programador elque realice esta tarea. Es decir, es labor del programador el especificar donde(en que zona de memoria) se ubican cada uno de las distintos segmentos queconforman un fichero ejecutable.

Esto, normalmente, es transparente al programador, pues, como se hadicho, se encarga de ello el sistema operativo, que tiene perfecto conocimientode la memoria de sistema y es el que se encarga de su administracion. Ademas,el programa ejecutable que construye el enlazador (linker) se dice que esreubicable, pues no tiene asignadas direcciones de memoria donde ejecutarse,sino que esta formado a base de definiciones simbolicas y es precisamentecuando comienza su ejecucion cuando el sistema operativo asocia direccionesde memoria a esas definiciones simbolicas. Este es el proceso conocido comoreubicacion (relocation).

Se dice entonces que la reubicacion es el proceso de conectar referencias


simbolicas con la definicion de estos sımbolos. En otras palabras, laos ficherosreubicables deben tener informacion que describa como modificar el contenidode sus secciones, permitiendo ası a los ficheros ejecutables y compartidos tenerlos datos necesarios para crear la imagen del proceso. Esta informacion seencuentra en las entradas de reubicacion de la tabla de sımbolos.

En realidad, el ensamblador tambien realiza un primer paso de reubica-cion. Cuando el compilador produce un fichero objeto, este programa parcialcomienza en la direccion 0. El enlacador asigna las direcciones finales a es-te programa parcial de manera que todos estos programas parciales no sesolapen.

El enlazador, por tanto, traslada bloques de bytes de un programa a susdirecciones de tiempo de ejecucion. En este proceso se incluyen las tareasnecesarias para convertir las referencias a direcciones de fichero objeto enreferencias a direcciones de tiempo de ejecucion apropiadas.

Dicho de otro modo y resumiendo, los ficheros ejecutables y compartidosrepresentan de forma estatica programas. Para ejecutar estos programas, elsistema operativo usa esos ficheros para crear representaciones dinamicas delprograma o imagenes del proceso.

Pues bien, la manera de conseguir la reubicacion en sistemas empotradoses mediante ordenes de enlazado a la hora de construir el programa, queindican donde van cada una de los segmentos que componen un ejecutable.

4.2. Cambios introducidos en el simulador

Como ya se ha comentado en apartados anteriores de este documento,GDB tiene una funcionalidad interesentısima para los sistemas empotrados,que es la de poder ejecutarse como cross-debugger. Esto quiere decir quepuede utilizarse GDB para depurar programas que estan construidos paracorrer en un sistema diferente (target) del que ejecuta GDB (host).

Gdb funciona entonces como un simulador, pues, si se dispone ademas decualquier editor de texto y de la herramienta cruzada de compilacion paraproducir codigo propio del microcontrolador con el que se esta trabajando, sepuede desarrollar completamente un programa para un sistema empotradosin tener acceso directo a dicho microcontrolador. Esto es ventajoso desdevarios puntos de vista, por ejemplo el economico si el disponer de un chipresulta muy oneroso.

Aun teniendo en cuenta estas limitaciones de los simuladores, esta claroque el sistema simulado debe ser lo mas parecido posible al sistema queemula y representar lo mas fielmente posible su comportamiento, pues, de lo

4.2 Cambios introducidos en el simulador 77

contrario, se pierde el objetivo principal de la simulacion.

Este es el concepto primordial que ha motivado que en este proyecto semodifique el tratamiento que el simulador de gdb hace de la memoria desimulacion para el microprocesador MCore, pues, despues de estudiarlo condetalle, se considera que este no es del todo satisfactorio.

4.2.1. Gestion de la memoria

Trabajando con las herramientas originales tal como las proporciona Frees-cale, el usuario pronto puede darse cuenta que, si utiliza direcciones de memo-ria validas segun los mapas de memoria de las familias de microcontroladoresque utilizan el microprocesador MCore, la ejecucion de los programas se in-terrumpe de manera irreversible a causa de la aparicion de violaciones desegmento.

Estudiando el codigo fuente original del simulador, se puede apreciar queeste reserva memoria en el sistema sin tener en cuenta el mapa de memoriadel microprocesador ni los distintos tipos de memoria que este posee. De estamanera, reserva espacio para un bloque plano y completo de 8M y hace usode el sin distinguir direccionamiento alguno.

Es cierto que esto hace que el simulador no este ligado a un microcon-trolador en concreto, pues los mapas de memoria varıan entre las distantasfamilias que hacen uso de un mismo micro. Se reserva el mismo bloque inde-pendientemente del microcontrolador que se este utilizando.

Tambien es cierto que no se puede simular el tipo de memoria con elque trabaja el programa en cada momento; es decir, no se puede distinguir,a priori, si el programa esta accediendo en una instruccion concreta a unamemoria ROM para tomar, por ejemplo, la siguiente instruccion de codigo aejecutar o, si por el contrario, esta modificando el valor de una variable, que,por tanto, debe estar en memoria RAM.

Pero, el metodo utilizado hasta ahora, ademas de ser un desperdicio deespacio, no parece tener mucho sentido, puesto que utiliza en la simulaciondirecciones de memoria que luego no van a estar disponibles, por no existir,en el sistema real. La idea, como se ha comentado anteriormente, es que elsistema simulado tenga, en la medida de lo posible, el mismo comportamientoque el sistema real.

Por tanto, no parece lo mas conveniente compilar el programa con di-recciones falsas (por decirlo de algun modo) para el simulador y compilarloluego otra vez con las direcciones reales para cargarlo en el sistema que lo vaa ejecutar. Esto puede redundar en un incremento del tiempo de desarrollodel programa.


Teniendo esto en mente, la modificacion que se ha introducido en el codi-go fuente del simulador es anadir el mapa de memoria del microprocesadorFreescale MCore. De este modo, se reservan bloques indepedientes para cadatipo de memoria y, cada vez que se accede a una determinada posicion, secomprueba a que tipo de memoria se accede para direccionar sobre el bloquecorrecto.

Esto tiene un inconveniente, pues ahora el simulador depende del ma-pa de memoria del micro que se esta utilizando. Sin embargo, teniendo encuanta que todos los sistemas basados en microcontrolador tienen siempre,basicamente, los mismos tipos de memoria (esto es, ROM, RAM, memoriapara perifericos y memoria externa), el codigo dependiente de dicho mapa dememoria se encuentra localizado en un unico fichero, mientras que el restode codigo trabaja haciendo referencia a constantes definidas en dicho fichero.Para cambiar el mapa de memoria, bastara tan solo cambiar las definicionesde estas constantes.

Esto hace que el programa trabaje unicamente con las direcciones de me-moria de las que luego va a disponer realmente cuando este funcionando en elsistema real. Este funcionamiento parece tener mucho mas sentido, pues unavez que se haya comprobado que el programa construido funciona correcta-mente simulando su funcionamiento con gdb, puede llevarse directamente alsistema real para hacerlo funcionar de inmediato y sin ningun tratamientoadicional.

Se muestra a continuacion el fichero de cabecera con las definiciones co-rrespondientes al mapa de memoria del microcontrolador MMC2107 basadoen el microprocesador MCore de Freescale. Hay que indicar que esta es launica parte de este proyecto que depende del microcontrolador, puesto queni la librerıa ni la interfaz grafica desarrollada que hace uso de ella estanligadas a ninguna arquitectura concreta.

#ifndef MMC2107 MMAP H#define MMC2107 MMAP H

typedef long int word ;typedef unsigned long int uword ;

#define INTERNAL ROM START 0x0#define INTERNAL ROM SIZE 0x20000#define INTERNAL ROM END \

(INTERNAL ROM START + INTERNAL ROM SIZE)


#define INTERNAL RAM START 0x800000#define INTERNAL RAM SIZE 0x2000#define INTERNAL RAM END \

(INTERNAL RAM START + INTERNAL RAM SIZE)

#define REGISTER SPACE START 0 xc00000#define REGISTER SPACE END 0x80000000#define REGISTER SPACE SIZE \

(REGISTER SPACE END − REGISTER SPACE START)

#define EXTERNAL MEMORY START 0x80000000#define EXTERNAL MEMORY SIZE 0x80000000

/∗ Ports ∗/#define PORTS BASE ADDRESS 0 x00c00000/∗ Chip c o n f i g u r a t i o n ∗/#define CCM BASE ADDRESS 0 x00c10000/∗ Chip s e l e c t s ∗/#define CS BASE ADDRESS 0 x00c20000/∗ Clocks ∗/#define CLOCK BASE ADDRESS 0 x00c30000/∗ Reset ∗/#define RESET BASE ADDRESS 0 x00c40000/∗ I n t e r r u p t c o n t r o l l e r ∗/#define INTC BASE ADDRESS 0 x00c50000/∗ Edge por t ∗/#define EPORT BASE ADDRESS 0 x00c60000/∗ Watchdog t imer ∗/#define WDT BASE ADDRESS 0 x00c70000/∗ Programmable i n t e r r u p t t imer 1 ∗/#define PIT1 BASE ADDRESS 0 x00c80000/∗ Programmable i n t e r r u p t t imer 2 ∗/#define PIT2 BASE ADDRESS 0 x00c90000/∗ Queued analog−to−d i g i t a l c o n v e r t e r ∗/#define QADC BASE ADDRESS 0 x00ca0000/∗ S e r i a l p e r i p h e r a l i n t e r f a c e ∗/#define SPI BASE ADDRESS 0x00cb0000/∗ S e r i a l communications i n t e r f a c e 1 ∗/#define SCI1 BASE ADDRESS 0 x00cc0000/∗ S e r i a l communications i n t e r f a c e 2 ∗/#define SCI2 BASE ADDRESS 0x00cd0000


/∗ Timer 1 ∗/#define TIM1 BASE ADDRESS 0 x00ce0000/∗ Timer 2 ∗/#define TIM2 BASE ADDRESS 0 x00cf0000/∗ FLASH r e g i s t e r s ∗/#define CMFR BASE ADDRESS 0x00d00000

#define NPER 17#define BLOCK SIZE 0x10000

#endif /∗ MMC2107 MMAP H ∗/

4.2.2. Inclusion de dispositivos perifericos

La misma idea de buscar la maxima similitud entre los sistemas simuladosy real ha motivado la segunda modificacion importante del codigo de gdb parael simulador del microprocesador MCore.

Dicho simulador tan solo se ocupa del microprocesador, pero no tiene encuenta todos los dispositivos que se le anaden y forman un microcontrolador,como pueden ser los puertos serie, sıncronos, asıncronos y todos los periferi-cos de proposito general de los que suelen disponer los microcontroladores(convertidores analogico-digitales, temporizadores, etc.).

Bien es cierto que la simulacion de estos elementos es mucho mas complejaque la del funcionamiento interno de un microprocesador (por increıble queparezca esta afirmacion) y que, de nuevo, el simulador se hace dependientede un microcontrolador concreto.

Sin embargo, la inclusion de perifericos en el simulador tambien lo hacemucho mas util y mas potente a la hora de trabajar con sistemas empotrados,pues practicamente la totalidad de los programas que van en estos sistemasutilizan algun que otro periferico.

Como ya se ha comentado, la simulacion de estos sistemas es muchomas complicada, de manera que en este proyecto tan solo se ha abordado laimplementacion de un par de ejemplos, quedando, tanto el codigo como estedocumento, abiertos a la inclusion de nuevos perifericos en el simulador.

La estructura que se ha incorporado al simulador proporcionado porFreescale para emular el comportamiento de los perifericos es definir un pe-riferico generico y hacer que este se comporte como un periferico concreto enfuncion de la direccion a la que este accediendo el programa. De esta forma,se presenta una interfaz unica y comun de todos los perifericos hacia el si-mulador del microprocesador y sera la direccion de memoria la encargada de


distinguir entre ellos, tal y como sucede en la realidad.De hecho, cualquier periferico se puede reducir a una zona de memoria

en la que el programa escribe datos y de la que el programa toma datos.La nota distintiva y lo que los hace diferentes es la logica interna, pero elfuncionamiento visto desde fuera es igual para todos ellos. Es decir, puedenser vistos como una caja negra con entradas y salidas.

Entonces, el simulador del microprocesador accede a los perifericos me-diante una serie de funciones, cuyos prototipos se muestran a continuacion:

void i n i t p e r i p h e r a l s ( void ) ;int s e l e c t p e r i p h e r a l (ADDRESS x ) ;void w r i t e t o p e r i p h e r a l(ADDRESS x , word v , ACCESS TYPE type ) ;int r e a d f r o m p e r i p h e r a l (ADDRESS x , ACCESS TYPE type ) ;void a c t u a l i z e p e r i p h e r a l ( void ) ;

Los tipos que aparecen en estas funciones se definen en el fichero perip-heral.h, que puede consultarse un poco mas adelante.

A la vista de estas funciones, resulta obvio que el simulador del micro-procesador no distingue entre perifericos a la hora de interactuar con ellos.Tan solo se ocupa de seleccionar el periferico correspondiente mediante lafuncion select peripheral y la direccion a la que quiere acceder. Esta funcionse encuentra en el fichero peripheral.c, que puede consultarse mas adelante.

Una vez hecho esto, el simulador no tiene por que conocer las peculiarida-des internas de los distintos perifericos con los que trabaja, sino que trabajacon ellos siempre mediante funciones unicas, conocidas y bien definidas.

Lo que hace en realidad la funcion select peripheral, tal como puede com-probarse en las paginas siguientes, es hacer que el periferico generico apunteal periferico adecuado en funcion de la direccion a la que se este accediendo.De esta manera, el simulador del microprocesador estara trabajando en cadamomento, sin que el se de cuenta, con el dispositivo correspondiente a ladireccion de memoria que indica la instruccion que esta ejecutando.

Para conseguir esto, se ha definido una interfaz a la que deben ajustarsetodos los perifericos que se incluyan en el simulador. Los prototipos de lasfunciones que forman esta interfaz son:

void i n i t f u n c t i o n ( void ) ;void w r i t e f u n c i o n (ADDRESS, word ) ;int r e a d f u n c t i o n (ADDRESS) ;void a c t u a l i z e f u n c t i o n ( void ) ;void s e l e c t f u n c t i o n ( p e r i p h e r a l ∗per ) ;


Como se puede ver, la interfaz consta de cinco funciones, donde cuatrode ellas son las distintas formas en que un microprocesador interactua conun dispositivo externo:

- inicializacion

- escritura

- lectura

- actualizacion

La forma de trabajar en cada instante con las funciones correspondientesal periferico al cual esta accediendo el programa es mediante una estructuraperipheral compuesta por punteros a estos tipos de funcion. Esta estructurapuede verse en el fichero peripheral.h.

#ifndef PERIPHERAL H#define PERIPHERAL H

#include ”mmc2107−mmap. h”

typedef unsigned char BYTE;typedef uword ADDRESS;

typedef enum{

BYTE ACCESS,HALF WORD ACCESS,WORD ACCESS

} ACCESS TYPE;

typedef struct p e r i p h e r a l p e r i p h e r a l ;

struct p e r i p h e r a l{

void (∗ i n i t ) ( void ) ;void (∗ wr i t e ) (ADDRESS, word ) ;int (∗ read ) (ADDRESS) ;void (∗ a c t u a l i z e ) ( void ) ;

} ;


void i n i t p e r i p h e r a l s ( void ) ;int s e l e c t p e r i p h e r a l (ADDRESS x ) ;void w r i t e t o p e r i p h e r a l (ADDRESS x , word v ,

ACCESS TYPE type ) ;int r e a d f r o m p e r i p h e r a l (ADDRESS x ,

ACCESS TYPE type ) ;void a c t u a l i z e p e r i p h e r a l ( void ) ;

#endif /∗ PERIPHERAL H ∗/Al iniciar el simulador se define una estructura cuyos miembros, en el mo-

mento de trabajar con algun periferico en concreto, apuntaran a sus funcionescorrespondientes. Esto, como se ha comentado anteriormente, se consigue me-diante la funcion select peripheral y la funcion de seleccion correspondientea cada dispositivo.

Y es que, ademas de las funciones de inicializacion, lectura, escritura yactualizacion, para incorporar un nuevo dispositivo al simulador es necesarioanadir una funcion de seleccion que haga que los punteros miembro de laestrucura peripheral que se le pasa como parametro apunten a las funcionesque implementan la interfaz para ese dispositivo.

En el fichero peripheral.c se puede comprobar el detalle de lo que hacenexactamente las funciones que se acaban de describir.

#include ”mmc2107−mmap. h”#include ” p e r i p h e r a l . h”#include ” por t s . h”#include ” s c i . h”

extern int t a r g e t b i g e n d i a n ;

p e r i p h e r a l ∗per ;p e r i p h e r a l p ;

typedef void (SELFUNC) ( p e r i p h e r a l ∗ ) ;SELFUNC ∗permap [NPER] ;

stat ic void build permap ( void ) ;stat ic int s i z e i n b y t e s (ACCESS TYPE type ) ;

voidi n i t p e r i p h e r a l s ( void )


{int i ;stat ic bu i ld = 1 ;

i f ( bu i ld ){

build permap ( ) ;bu i ld = 0 ;per = &p ;

}

for ( i = 0 ; i < NPER; i++)i f ( permap [ i ] ){

permap [ i ] ( per ) ;per−> i n i t ( ) ;

}}

stat ic voidbuild permap ( void ){

int i = 0 ;

permap [ i ++] = s e l e c t p o r t s ;permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t c c m ∗/permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t c s ∗/permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t c l o c k ∗/permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t r e s e t ∗/permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t i n t c ∗/permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t e p o r t ∗/permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t w d t ∗/permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t p i t 1 ∗/permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t p i t 2 ∗/permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t q a d c ∗/permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t s p i ∗/permap [ i ++] = s e l e c t s c i 1 ;permap [ i ++] = s e l e c t s c i 2 ;permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t t i m 1 ∗/permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t t i m 2 ∗/permap [ i ++] = (SELFUNC ∗) 0 ; /∗ s e l e c t c m f r ∗/


}

ints e l e c t p e r i p h e r a l (ADDRESS x ){

unsigned int i ;

x −= REGISTER SPACE START;i = x / BLOCK SIZE ;i f ( i < NPER && permap [ i ] ){

permap [ i ] ( per ) ;return 0 ;

}else

/∗ bus monitor t r a n s f e r erro r e x c e p t i o n ∗/return −1;

}

voidw r i t e t o p e r i p h e r a l (ADDRESS x , word v ,

ACCESS TYPE type ){

int j , i = s i z e i n b y t e s ( type ) ;

i f ( ! t a r g e t b i g e n d i a n )for (−− i ; i >= 0 ; −− i )

per−>wr i t e ( x + i , v >> i ∗ 8 ) ;else

for ( ; j < i ; j++)per−>wr i t e ( x + j , v >> ( i − 1 − j ) ∗ 8 ) ;

}

intr e a d f r o m p e r i p h e r a l (ADDRESS x , ACCESS TYPE type ){

int r e t = 0 , j = 0 , i = s i z e i n b y t e s ( type ) ;

i f ( ! t a r g e t b i g e n d i a n )for (−− i ; i >= 0 ; −− i )

r e t |= ( per−>read ( x + i ) ) << i ∗ 8 ;


elsefor ( ; j < i ; j++)

r e t |=( per−>read ( x + i ) ) << ( i − 1 − j ) ∗ 8 ;

return r e t ;}

stat ic ints i z e i n b y t e s (ACCESS TYPE type ){

int s i z e = 0 ;

switch ( type ){case BYTE ACCESS:

s i z e = s izeof (BYTE) ;break ;

case HALF WORD ACCESS:s i z e = s izeof ( word ) / 2 ;break ;

case WORD ACCESS:s i z e = s izeof ( word ) ;break ;

}return s i z e ;

}

voida c t u a l i z e p e r i p h e r a l ( void ){

int i = 0 ;for ( ; i < NPER; i++)

i f ( permap [ i ] ){

permap [ i ] ( per ) ;per−>a c t u a l i z e ( ) ;

}}


Es conveniente destacar que existe una tabla de punteros a funcion apun-tando a las funciones de seleccion para cada dispositivo. Para seleccionar eldispositivo se utiliza la direccion de memoria que, adecuadamente transfor-mada, sirve para indexar la tabla de punteros.

De momento, solo existen tres de estos punteros en la tabla, que corres-ponden a los dispositivos que se han implementado en este proyecto, peroesta arquitectura esta abierta a la inclusion de nuevos perifericos del micro-controlador de manera muy sencilla. Tan solo habrıa que realizar la definicionde las funciones de la interfaz en un nuevo fichero de codigo y modificar latabla de punteros con la funcion de seleccion de dispositivo en el lugar queindica el mapa de memoria.

4.2.3. Puertos

El primero de los dispositivos que se han implementado en este proyectoha sido el bloque de los puertos del microcontrolador. Este bloque correspon-de a las patas de que dispone el chip.

Muchos de estas patas asociadas con la interfaz externa pueden usarsepara varios propositos diferentes. Su funcion principal es la de proporcionaruna interfaz externa hacia los recursos que estan fuera del chip. Cuando nose usan para su funcion primordial, muchas de las patas se pueden utilizarcomo entradas y salidas digitales (I/O).

En cualquier caso, estos detalles corresponden al programador de siste-mas empotrados que trabajen con el microcontrolador MMC2107 y se puedenencontrar en su manual de referencia. Por supuesto, tanto la forma de fun-cionar de los puertos como las direcciones de memoria donde se encuentranse han estudiado a fondo para tenerlos en cuanto a la hora de simularlos enlos ficheros que se muestran a continuacion y pueden consultarse aquı.

Lo que sı serıa destacable es que se han implementado todas las funcionescorrespondientes a la interfaz propuesta para los perifericos del simulador deMCore. Lo que ocurre con la funcion de actualizacion, que no tiene definicion,es que este bloque no tiene una logica interna que altere el estado de los bytesque lo forman. Dicho de otro modo, la forma que tiene el microprocesadorde interactuar con sus puertos es mediante la lectura y la escritura, pero losbytes que se leen y se escriben no cambian de estado por sı solos.

Esto no ocurre con otros dispositivos, que sı presentan una logica interna,como podrıa ser un temporizador. Este periferico sı cambia su estado sin queel microprocesador intervenga en ello, por lo que serıa necesario implementarde algun modo este cambio en la funcion de actualizacion.

Tambien es conveniente hacer notar la funcion de seleccion de periferico.Se puede comprobar en el codigo fuente que lo unico que hace esta funcion


es asignar a los punteros de la estructura peripheral que se le pasa comoparametro las direcciones de las funciones correspondientes a este dispositivo.

#ifndef PORTS H#define PORTS H

#include ” p e r i p h e r a l . h”

#define NPORTS 0x3c

#define PORTA 0x00#define PORTB 0x01#define PORTC 0x02#define PORTD 0x03#define PORTE 0x04#define PORTF 0x05#define PORTG 0x06#define PORTH 0x07#define PORTI 0x08

#define PORTx RESET 0 x f f

#define DDRA 0x0c#define DDRB 0x0d#define DDRC 0x0e#define DDRD 0 x0f#define DDRE 0x10#define DDRF 0x11#define DDRG 0x12#define DDRH 0x13#define DDRI 0x14

#define DDRx RESET 0x00

#define PORTAP SETA 0x18#define PORTBP SETB 0x19#define PORTCP SETC 0x1a#define PORTDP SETD 0x1b#define PORTEP SETE 0x1c#define PORTFP SETF 0x1d


#define PORTGP SETG 0x1e#define PORTHP SETH 0 x1f#define PORTIP SETI 0x20

#define CLRA 0x24#define CLRB 0x25#define CLRC 0x26#define CLRD 0x27#define CLRE 0x28#define CLRF 0x29#define CLRG 0x2a#define CLRH 0x2b#define CLRI 0x2c

#define CLRx RESET 0x00

#define PCDPAR 0x30#define PCDPAR RESET 0x00

#define PEPAR 0x31#define PEPAR RESET 0x00

void s e l e c t p o r t s ( p e r i p h e r a l ∗ per ) ;

#endif /∗ PORTS H ∗/

#include ” por t s . h”

#define GROUP 0x0c#define NGROUPS (NPORTS / GROUP)

BYTE mem[NPORTS] ;

void i n i t p o r t s ( void ) ;void w r i t e p o r t s (ADDRESS x , word v ) ;int r e ad po r t s (ADDRESS x ) ;void a c t u a l i z e p o r t s ( void ) ;

void


s e l e c t p o r t s ( p e r i p h e r a l ∗ per ){

per−> i n i t = i n i t p o r t s ;per−>wr i t e = w r i t e p o r t s ;per−>read = read po r t s ;per−>a c t u a l i z e = a c t u a l i z e p o r t s ;

}

voidi n i t p o r t s ( void ){

int i ;

for ( i = PORTA; i <= PORTI; i++)mem[ i ] = PORTx RESET;

for ( i = DDRA; i <= DDRI; i++)mem[ i ] = DDRx RESET;

for ( i = CLRA; i <= CLRI ; i++)mem[ i ] = CLRx RESET;

mem[PCDPAR] = PCDPAR RESET;mem[PEPAR] = PEPAR RESET;

}

voidw r i t e p o r t s (ADDRESS x , word v ){

ADDRESS r e s t ;unsigned int group ;

x −= PORTS BASE ADDRESS;x %= NPORTS;group = x / GROUP;r e s t = x %GROUP;

/∗ r e s e r v e d ∗/i f ( r e s t > GROUP − 3)

return ;


/∗ r e s e r v e d ∗/i f ( group == GROUP − 1 && x > PEPAR)

return ;

/∗ i f ( x == PCDPAR)mem[ x ] = ; ∗/

mem[ x ] = v ;}

intr e ad po r t s (ADDRESS x ){

ADDRESS r e s t ;int group ;

x −= PORTS BASE ADDRESS;x %= NPORTS;group = x / GROUP;r e s t = x %GROUP;

/∗ r e s e r v e d ∗/i f ( r e s t > GROUP − 3)

return 0 ;

/∗ CLRx ∗/i f ( group == GROUP − 2)

return 0 ;

/∗ r e s e r v e d ∗/i f ( group == GROUP − 1 && x > PEPAR)

return 0 ;

i f ( x == PCDPAR)return (mem[ x ] & 0x80 ) ;

return mem[ x ] ;}

voida c t u a l i z e p o r t s ( void )


{}

4.2.4. SCI

Los otros dispositivos perifericos que se han implementado en este pro-yecto han sido los modulos de comunicacion serie (Serial CommunicationsInterface). Estos modulos permiten la comunicacion serie asıncrona con otrosdispostivos externos e, incluso, otros microcontroladores.

El MMC2107 tiene dos modulos SCI identicos, cada uno con su registrode control y sus patas de entrada/salida.

Como se ha mencionado para los puertos, los detalles del funcionamientointerno de estos bloques no van a describirse aquı, pues tambien puedenencontrarse en el manual de referencia del microcontrolador.

Del mismo modo, se aplica aquı lo que se dijo para los puertos sobre lasfunciones de actualizacion y seleccion.

#ifndef SCI H#define SCI H

#include ” p e r i p h e r a l . h”

#define NREGS 0x10

#define SCIBDH 0x00#define SCIBDL 0x01#define SCICR1 0x02#define SCICR2 0x03#define SCISR1 0x04#define SCISR2 0x05#define SCIDRH 0x06#define SCIDRL 0x07#define SCIPURD 0x08#define SCIPORT 0x09#define SCIDDR 0x0a

void s e l e c t s c i 1 ( p e r i p h e r a l ∗ per ) ;void s e l e c t s c i 2 ( p e r i p h e r a l ∗ per ) ;

#endif /∗ SCI H ∗/


#include ” s c i . h”

BYTE mem1[NREGS] , mem2[NREGS] ;

stat ic void s e l e c t s c i (BYTE ∗ mem,p e r i p h e r a l ∗ per ) ;

void i n i t s c i 1 ( void ) ;void i n i t s c i 2 ( void ) ;stat ic void i n i t s c i (BYTE ∗ mem) ;void w r i t e s c i 1 (ADDRESS x , word v ) ;void w r i t e s c i 2 (ADDRESS x , word v ) ;stat ic void w r i t e s c i (BYTE ∗ mem, ADDRESS x ,

word v ) ;int r e a d s c i 1 (ADDRESS x ) ;int r e a d s c i 2 (ADDRESS x ) ;stat ic int r e a d s c i (BYTE ∗ mem, ADDRESS x ) ;void a c t u a l i z e s c i 1 ( void ) ;void a c t u a l i z e s c i 2 ( void ) ;stat ic void a c t u a l i z e s c i (BYTE ∗ mem) ;

voids e l e c t s c i 1 ( p e r i p h e r a l ∗ per ){

s e l e c t s c i (mem1, per ) ;}

voids e l e c t s c i 2 ( p e r i p h e r a l ∗ per ){

s e l e c t s c i (mem2, per ) ;}

stat ic voids e l e c t s c i (BYTE ∗ mem, p e r i p h e r a l ∗ per ){

i f (mem == mem1){

per−> i n i t = i n i t s c i 1 ;per−>wr i t e = w r i t e s c i 1 ;per−>read = r e a d s c i 1 ;


per−>a c t u a l i z e = a c t u a l i z e s c i 1 ;}

else{

per−> i n i t = i n i t s c i 2 ;per−>wr i t e = w r i t e s c i 2 ;per−>read = r e a d s c i 2 ;per−>a c t u a l i z e = r e a d s c i 2 ;

}}

voidi n i t s c i 1 ( void ){

i n i t s c i (mem1) ;}

voidi n i t s c i 2 ( void ){

i n i t s c i (mem2) ;}

stat ic voidi n i t s c i (BYTE ∗ mem){

int i ;

for ( i = SCIBDH; i <= SCIDDR; i++)mem[ i ] = 0x00 ;

mem[ SCISR1 ] = 0xc0 ;}

voidw r i t e s c i 1 (ADDRESS x , word v ){

w r i t e s c i (mem1, x , v ) ;}

void


w r i t e s c i 2 (ADDRESS x , word v ){

w r i t e s c i (mem2, x , v ) ;}

stat ic voidw r i t e s c i (BYTE ∗ mem, ADDRESS x , word v ){

x −=(mem ==mem1) ? SCI1 BASE ADDRESS :

SCI2 BASE ADDRESS ;

i f ( x >= NREGS)/∗ bus error e x c e p t i o n ∗/return ;

i f ( x > SCIDDR)/∗ r e s e r v e d ∗/return ;

switch ( x ){case SCIBDH:

/∗ mem[ x ] = ; ∗/break ;

case SCISR1 :case SCISR2 :

break ;

case SCIDRH:/∗ mem[ x ] = ; ∗/break ;

case SCIPURD:/∗ mem[ x ] = ; ∗/break ;

default :mem[ x ] = v ;


break ;}

}

intr e a d s c i 1 (ADDRESS x ){

r e a d s c i (mem1, x ) ;}

intr e a d s c i 2 (ADDRESS x ){

r e a d s c i (mem2, x ) ;}

stat ic intr e a d s c i (BYTE ∗ mem, ADDRESS x ){

x −=(mem ==mem1) ? SCI1 BASE ADDRESS :

SCI2 BASE ADDRESS ;

i f ( x >= NREGS)/∗ bus error e x c e p t i o n ∗/return 0 ;

i f ( x > SCIDDR)/∗ r e s e r v e d ∗/return 0 ;

switch ( x ){case SCIBDH:

return (mem[ x ] & 0 x1f ) ;break ;

case SCISR2 :return (mem[ x ] & 0x01 ) ;break ;


case SCIDRH:return (mem[ x ] & 0xc0 ) ;break ;

case SCIPURD:return (mem[ x ] & 0xb3 ) ;break ;

default :return mem[ x ] ;break ;

}}

voida c t u a l i z e s c i 1 ( void ){

a c t u a l i z e s c i (mem1) ;}

voida c t u a l i z e s c i 2 ( void ){

a c t u a l i z e s c i (mem2) ;}

stat ic voida c t u a l i z e s c i (BYTE ∗ mem){}

Capıtulo 5

Aplicacion grafica KMcsim

Para demostrar la potencia de la librerıa GCA desarrollada en este pro-yecto, se ha construido un aplicacion grafica de depuracion de sistemas em-potrados. Esta aplicacion no es mas que un front end para gdb, pues se apoyaen su interfaz de comandos mi1, pero no lo hace directamente, sino a travesde la capa intermedia que supone la biblioteca GCA.

Ya se ha comentado que la gran ventaja que aporta la creacion de estabiblioteca es la de aislar a posibles aplicaciones como esta de los detalles de lacomunicacion con gdb. Es mucho mas facil, entonces, construir un front end,porque el programador tan solo tiene que preocuparse de utilizar las funcionesadecuadas de la librerıa y presentar los datos que estas le proporcionan demanera adecuada, ya sea en una interfaz grafica o en una consola.

5.1. Detalles del diseno con Qt/KDE

No se va a entrar en detalle en este capıtulo sobre la programacion utili-zando las librerıas de KDE y su creacion con su entorno de desarrollo KDe-velop, entre otras cosas porque eso harıa extensısimo dicha seccion y porqueno es este el proposito de este documento ni de este proyecto.

Para inciarse en la programacion de aplicaciones graficas usando KDEno tiene mas que acudir a la multitud de tutoriales que se encuentran eninternet o a una de las obras a las que se hace referencia en la bibliografıa[7].

Sin embargo, sı se van a dar algunas ideas generales sobre este tipo deaplicaciones y sobre algunos aspectos de la aplicacion desarrollada.

100 Aplicacion grafica KMcsim

5.1.1. Modelo vista-documento

La aplicacion KMcsim (Microcontroller simulator) se ha construido con laayuda de KDevelop 3.2.0, que usa KDE 3.3.2. Se ha elegido ası por la enormefacilidad que presta este entorno de desarrollo a la hora de crear aplicacionesgraficas.

Tanto es ası, que, nada mas iniciar un proyecto con KDevelop, este crea elesqueleto basico para la creacion de una aplicacion. Si se compila y se ejecuta,puede comprobarse que este marco inicial es toda una ventana principal conbarras de menus, de herramientas y de estado.

No vamos a entrar en detalle de como se trabaja con KDevelop para crearuna aplicacion en KDE, pero sı vamos a dar las directrices generales de comoestan construidas las aplicaciones que este genera.

La estructura de las aplicaciones que crea KDevelop se basan en el modelovista-documento. Este es un modelo que trata de separar la parte grafica dela aplicacion de la parte correspondiente a los datos dicha aplicacion maneja.Este modelo no esta ligado a KDE o a un lenguaje particular (C++ en estecaso), sino que se trata de un concepto que tiene que ver con la ingenierıadel software y que, por tanto, puede aplicarse en la construccion de todo tipode aplicaciones graficas, sea cual sea el entorno y en el lenguaje en el que seprogramen.

Siguiendo este modelo, KDevelop crea la clase aplicacion, que es el widgetde alto nivel que proporciona las barras de herramientas, de menus y deestado, a la vez que el marco de la aplicacion grafica propiamente dicha. Es,en resumidas cuentas, la ventana principal de alto nivel de una aplicacionKDE.

Esta clase, se ocupa, por tanto, de la geometrıa de sus hijos, entre los quedebe encontrarse el widget principal de la aplicacion, que es una instancia dela clase vista.

Esta clase, por otro lado, se ocupa de los detalles de presentacion de datosen pantalla, ası como de la comunicacion con la clase documento para recibirdichos datos.

Es tarea del programador anadir la clase documento y anadir todos loselementos necesarios en las otras clases que ese esqueleto central no propor-ciona.

La clase documento es la que en realidad se comunica con el objeto conel trata la aplicacion. De esta forma, se intenta separar lo que es la parteexclusivamente grafica, de la que se encargan las clases aplicacion y vista,de la parte que tiene que ver con el manejo de los datos de la aplicacion,la parte no grafica, si se puede decir. Por poner un ejemplo sencillo, en uneditor de textos grafico el documento serıa precisamente eso, el documento

5.1 Detalles del diseno con Qt/KDE 101

que se esta editando, esto es, el archivo que la aplicacion esta modificando.En la aplicacion KMcsim desarrollada, que es, basicamente, un depurador

grafico, el documento es una sesion de depuracion con gdb a traves de labiblioteca GCA. Es decir, la clase documento se encarga aquı de comunicarsecon la biblioteca GCA para aislar al resto de partes de la aplicacion de losdetalles de la librerıa.

Un ejemplo paradigmatico de este aspecto que se esta comentando es latransformacion de tipos necesaria para trabajar con la librerıa GCA, puestoque no debe olvidarse que esta biblioteca esta construida en C. Es sabidoque C++ maneja todos los tipos C (de hecho, C++ contiene a C), pero nosucede ası al contrario, de manera que, en esta aplicacion, la clase documentodebe encargarse de transformar adecuadamente todos los datos C++ que lellegan de la clase vista en datos C para que la librerıa GCA los entienda.Tambien se encarga de la transformacion contraria (datos C se convierten endatos C++), para que el resto de la aplicacion no tenga por que conocer losdetalles especıficos de la librerıa.

Este enfoque es muy util y muy flexible, pues si cambia algun aspecto dela biblioteca, como puede ser el prototipo de alguna funcion, tan solo hayque modificar la clase documento, pero el resto de la aplicacion no tiene porque enterarse de nada si esta disenada segun este modelo de vista-documento.

5.1.2. Detalles especıficos

Sobre el marco de referencia que proporciona KDevelop se ha construidouna sencilla a la vez que completa aplicacion para la depuracion de sistemasempotrados. En el proximo capıtulo se pueden ver algunas capturas de pan-talla que muestran la apariencia de la interfaz construida y como se utilizaen una sesion de depuracion. No obstante, se abordara aquı el resumen desus caracterısticas principales.

La aplicacion dispone de varias vistas. La principal es la vista de codigofuente, que permite ver el codigo del programa mientras esta siendo depurado.Esta vista cambia entre los diversos ficheros que forman el fichero objeto amedida que la ejecucion del mismo va pasando por las funciones definidas enellos.

Precisamente para conocer todos los ficheros fuente que componen el eje-cutable y poder, ademas, navegar entre ellos, existe una vista de fuentes delfichero. Esto permite cambiar el fichero de codigo que se esta visualizando enun momento determinado para, por ejemplo, insertar un punto de rupturaen otro punto totalmente diferente del programa1.

1Se consigue haciendo doble click sobre una lınea de codigo.


Otra de las vistas que proporciona la aplicacion es la de los puntos deruptura. El usuario puede conocer, entonces, los datos concretos de los puntosde ruptura que hay incrustados en el codigo. Ademas, puede deshabilitarloso eliminarlos a traves de un menu de la barra de menus o mediante unmenu contextual que aparece al pulsar con el boton derecho del raton sobreel punto de ruptura que queremos modificar.

Con vistas a la simulacion de sistemas empotrados, el resto de vistas deque dispone la aplicacion construida son las de la memoria, los registros delmicro y la pila de llamadas. Estas vistas se actualizan cada vez que se sumi-nistra una accion de paso de ejecucion mediante el menu correspondiente, suasociacion de teclas o el icono que lo representa en la barra de herramientas.

Uno de los aspectos mas interesantes y que mas facilitan la programacionen KDE es la definicion de interfaces graficas mediante ficheros XML.

Esto hace que el programador tan solo tenga que crear las acciones, peroel resto de la informacion relativa a ellas debe especificarla en un ficheromyappui.rc, donde puede ubicar dichas acciones en las distintas barras de laaplicacion y definir su comportamiento.

Figura 5.1: Menu de acciones para controlar la ejecucion.

Ası se ha hecho, por ejemplo, para todas las acciones que estan relaciona-das con la ejecucion controlada del programa (figura 5.1), que se han anadidoa la aplicacion tanto en el codigo como en el fichero ui.rc. En el codigo tan

5.1 Detalles del diseno con Qt/KDE 103

solo es necesario crear las acciones (y ni siquiera es necesario mantener unpuntero para ellas). Todos los demas detalles se especifican mediante XML yes la aplicacion la que se encarga de extraer esa informacion y transformarlapara introducirla en la aplicacion.

De esta manera, se tiene una forma muy sencilla de gestionar las accionesque maneja una aplicacion.

XML esta tambien irrumpiendo en KDE a la hora de gestionar las opcio-nes de configuracion del sistema. Con ayuda de algunas herramientas adicio-nales (kconfig-compiler) se puede tener un acceso muy comodo a las opcionesguardades de la aplicacion. Es lo que se ha hecho en este ejemplo, cuyas op-ciones de configuracion son el simulador que se utiliza y los registros del micro(figura 5.2) y la memoria que se desea visualizar (figura 5.3) en sus zonascorrespondientes.

Figura 5.2: Pagina de configuracion para seleccionar los registros del micro.

En el caso de la configuracion del sistema no es tan sencillo como a la horade crear las interfaces graficas, pero lo es muchısimo mas que hacerlo a basede codigo. La idea es, al igual que con las acciones, especificar mediante XMLlos atributos de la aplicacion y la herramienta kconfig-compiler se encarga degenerar las clases que modifican y acceden a esos atributos.


Figura 5.3: Pagina de configuracion para seleccionar la zona de memoria.

Capıtulo 6

Ejemplo de aplicacion

Se va a presentar, finalmente, un ejemplo sencillo de lo que podrıa serun programa para el microcontrolador MMC2107 de Freescale y su posteriorsimulacion utilizando la aplicacion desarrollada KMcsim.

6.1. Programa para el microcontrolador

El programa que se ha utilizado para probar los cambios en el simuladores un sencillo programa que se limita a cambiar periodicamente el valor deun determinado byte de memoria. Este byte de memoria corresponde a unbloque de puertos del micro.

Viendo el nombre de la constante que apuntan a las direccion de estebyte de memoria se puede intuir que el programa es como si encendiera unaserie de LEDs conectados a esos puertos, de manera que lo que se verıa enrealidad en el laboratorio si cargaramos el programa en el micro serıan tresLEDs que van parpadeando sucesivamente.

Lo que se vera mediante la aplicacion grafica KMcsim sera, aparte de sufuncionamiento durante una simulacion completa, como cambia el valor dela posicion de memoria que corresponde al bloque de puertos donde estan losLEDs.

El programa esta compuesto de una serie de ficheros que se muestran acontinuacion.

El fichero main.c es donde se encuentra la funcion principal. Esta es unbucle for que se ejecuta diez veces y enciende sucesivamente los tres LEDsque estaran en algun bloque de puertos del micro. El tiempo que transcurreentre que un LED se apaga y se enciende el siguiente viene marcado por lafuncion delay.

106 Ejemplo de aplicacion

#include ” m2107 led . h”

void delay1 ( void ) ;

main ( void )

{int i ;

s e t l e d (ALL,OFF) ;

for ( i = 0 ; i <= 10 ; i++){

s e t l e d (0 ,ON) ;de lay1 ( ) ;

s e t l e d (1 ,ON) ;de lay1 ( ) ;

s e t l e d (2 ,ON) ;de lay1 ( ) ;

s e t l e d (3 ,ON) ;de lay1 ( ) ;

}}

void delay1 ( void )

{int count = 0 ;

while ( count < LED TEST DELAY){

count++;}

}

En el fichero de cabecera m2107 led.h se pueden encontrar las definicionesque se utilizan a lo largo del programa. Cabe destacar que aquı se encuentra

6.1 Programa para el microcontrolador 107

la direccion de memoria donde se van a colocar los LEDs. Comparando con elmapa de memoria del microcontrolador MMC2107 se puede comprobar quelos diodos se han colocado en el primer bloque de puertos.

// b i t s t a t e s

#define OFF 0#define ON 1

// b i t p o s i t i o n s in the ” l e d b y t e ”

#define LED 0 0x01#define LED 1 0x02#define LED 2 0x04#define LED 3 0x08#define PROG V 0x10

#define ALL 0xFF

// b i t m i n i p u l a t i o n

#define BIT SET( value , b i t ) ( va lue |= (1 << b i t ) )#define BIT CLR( value , b i t ) ( va lue &= ˜(1 << b i t ) )

#define SWITCH MASK 0x0E#define LED TEST DELAY 50000

#define LED ADDRESS \(∗ ( volat i le unsigned char ∗)0 x00c00000 )

#define SWITCH ADDRESS \(∗ ( volat i le unsigned char ∗)0 x00c00008 )

// Function d e c l a r a t i o n s

void s e t l e d (unsigned char , unsigned char ) ;unsigned char r ead sw i t ch ( void ) ;

Finalmente, en el fichero m2107 led.c es donde se encuentra la funcion quese encarga de encender y apagar los LEDs que hay colocados en el primerbloque de puertos del micro.


#include ” m2107 led . h”

void s e t l e d (unsigned char led , unsigned char s t a t e )

{volat i le unsigned char ∗ l e d by t e = &LED ADDRESS;unsigned char temp = 0x00 ;

temp = (unsigned char )∗ l e d by t e ;temp &= (unsigned char )0x0F ;

i f ( l ed == ALL){

i f ( s t a t e == ON)temp = 0x0F ; // A l l ON

elsetemp = 0x00 ; // A l l OFF

}else{

switch ( l ed ){

case 0 :∗ l e d by t e = LED 0 & 0x0F ;break ;




}}

∗ l e d by t e = temp & (unsigned char )0x0F ;∗ l e d by t e = temp & 0x07 ;

}

unsigned char r ead sw i t ch ( void )


{volat i le unsigned char ∗ sw i t ch byte = &SWITCH ADDRESS;volat i le unsigned char d ip sw i t ch ;

d ip sw i t ch = (∗ sw i t ch byte ) & SWITCH MASK;return ( d ip sw i t ch ) ;

}Pero no solo hacen falta estos ficheros para tener un programa comple-

to. Para programar un sistema empotrado en C debe haber al menos unfichero fuente ensamblador para la inicializacion del sistema. El que proponeFreescale para que se use junto con las herramientas GNU para un comienzorapido del sistema se puede ver a continuacion.

En esta inicializacion se puede comprobar que lo que hace el sistema esdarle un valor inicial a la pila (se carga el valor de comienzo en el puntero depila o stack pointer, que es el registro r0). Dicho valor de comienzo es unaconstante que tendra que ser definida a la hora de compilar el programa

. export s t a r t

s t a r t :

lrw r1 , SP INITmov r0 , r1j b s r main

. export i n i t// . a l i g n 2

i n i t :sub i r0 , 8stw r15 , ( r0 , 0 )

// Return from i n i t

ldw r15 , ( r0 , 0 )addi r0 , 8// jmp r15. export f i n i

// . a l i g n 2


f i n i :sub i r0 , 8stw r15 , ( r0 , 0 )

// Return from f i n i

ldw r15 , ( r0 , 0 )addi r0 , 8

// jmp r15

. export main// . a l i g n 2

main :sub i r0 , 8stw r15 , ( r0 , 0 )ldw r15 , ( r0 , 0 )addi r0 , 8

// jmp r15

Se incluye tambien un fichero con la tabla de excepciones del micropro-cesador. Como se indica, esta tabla debe estar al comienzo de la seccion.text. Las excepciones de reset provocan que el programa comience de nuevo,mientras que todas las demas haran que se ejecute la funcion set led con unosvalores determinados para sus parametros (un LED quedara encendido comoaviso de que se ha producido un error).

La forma que tiene el micro de trabajar con las excepciones es acudir aesta tabla y saltar a la direccion que indica la entrada correspondiente a laexcepcion que se ha producido.

. a l i g n 2

. t ex t

. export i n t e r r u p t v e c t o r

. extern s t a r t

. extern s e t l e d

// This must be at l o c a t i o n 0 o f the load f i l e

i n t e r r u p t v e c t o r :


. long s t a r t // 0 − r e s e t

. long t u r n o n l e d e r r o r // 1 − misa l i gned f a u l t

. long t u r n o n l e d e r r o r // 2 − acces s f a u l t

. long t u r n o n l e d e r r o r // 3 − r e s e r v e d

. long t u r n o n l e d e r r o r // 4 − i l l e g a l i n s t f a u l t

. long t u r n o n l e d e r r o r // 5 − p r i v i l e g e f a u l t

. long t u r n o n l e d e r r o r // 6 − t r a c e t rap

. long t u r n o n l e d e r r o r // 7 − b r e a k p o i n t t rap

. long t u r n o n l e d e r r o r // 8 − u n r e c o v e r a b l e f a u l t

. long s t a r t // 9 − s o f t r e s e t

. long t u r n o n l e d e r r o r // 10 − normal i n t e r r u p t

. long t u r n o n l e d e r r o r // 11 − f a s t i n t e r r u p t

. long t u r n o n l e d e r r o r // 12 − HAI f a u l t

. long t u r n o n l e d e r r o r // 13 −



. long t u r n o n l e d e r r o r // v e c t #16




t u r n o n l e d e r r o r :

movi r2 , 0x02 // arg1 , l i g h t l e d 1 ( b i t −2)movi r3 , 0x01 // arg2 , s t a t e ONl rw r4 , s e t l e djmp r4

br t u r n o n l e d e r r o r

Para compilar este fichero es necesario un Makefile como el que se muestraa continuacion. Este fichero es sencillo, pues no contiene nada mas que lasreglas habituales para ensamblar y, posteriormente, compilar una serie deficheros objetos. Tambien contiene un par de reglas para obtener algunosficheros de salida que resultan muy utiles a la hora de analizar como haquedado el codigo en la memoria.


TOOLS PATH := ˜/ proyecto / t o o l s / bin

LIB PATH := ˜/ proyecto / t o o l s /mcore/ l i b

CC := $ (TOOLS PATH)/ mcore−e l f−gccAS := $ (TOOLS PATH)/ mcore−e l f−asLD := $ (TOOLS PATH)/ mcore−e l f−ldOD := $ (TOOLS PATH)/ mcore−e l f−objdump

OBJS := e x c e p t i o n v e c t o r . o i n i t . o main . o m2107 led . o

CFLAGS := −g −S

LFLAGS := − l c −lm −l g

sample . l s t : sample . e l f$ (OD) −x −h −D −r −S $< > $@

sample . e l f : $ (OBJS)$ (LD) −o $@ −N −EB \$ (OBJS) \−T l i n k e r \$ (LFLAGS) −Map sample . map

%.o : %.s$ (AS) −EB $< −o $@

main . s : main . c$ (CC) $ (CFLAGS) $< −o $@

m2107 led . s : m2107 led . c$ (CC) $ (CFLAGS) $< −o $@

.PHONY: c l ean

c l ean :$ (RM) main . s m2107 led . s ∗ . o ∗ . l s t ∗ .map ∗ . e l f

Pero lo mas destacable de este Makefile se encuentra en el uso del linkerscript. En este se encuentran las ordenes adecuadas que deben darse al enla-zador para que distribuya correctamente las diferentes secciones que forman


un fichero objeto.

En primer lugar, se hace una descripcion de los distintos tipos de memoria:se especifica cual es su tamano y donde comienzan. El definir estos sımbolostan solo tiene el sentido de permitir despues una mayor legibilidad del script,pues para referirse a una zona de memoria concreta se utiliza su etiqueta yno su direccion real.

Tambien se define en el scipt el punto de entrada (entry point), que esel lugar (direccion de memoria) por donde empieza el sistema a ejecutar elprograma. En este ejemplo, el punto de entrada es una etiqueta que se hadefinido en el fichero de inicializacion y que daba lugar a la asignacion delpuntero de pila.

Otra tarea que se realiza en este script es darle valor a otra constanteque tambien se usa en el fichero de inicializacion. Es el valor de comienzo delpuntero de pila. Se puede comprobar que es un valor al final de la memoriaRAM (la pila crece hacia direcciones bajas de memoria en el MCore).

Y, finalmente, las ultimas ordenes que se dan en el linker script son lascorrespondencias entre las distintas secciones de los ficheros objetos y el lugarque deben ocupar en la memoria del sistema. Se puede comprobar que laseccion .text se carga en la zona de memoria ROM, al tratarse de una parteque no cambia (constantes, instrucciones, . . . ). La seccion .data se cargaprimero en ROM y una vez que se da inicio al programa se lleva a RAM; estaseccion corresponde a variables con un valor inicial. Por ultimo, las variablessin iniciar (seccion .bss) se instalan directamnente en RAM.

MEMORY{

rom ( rx ) : ORIGIN = 0 , LENGTH = 128Kram ( ! rx ) : ORIGIN = 0x800000 , LENGTH = 8K

}

ENTRY ( s t a r t )

SP INIT = 0x800000 + 8K − 8 ;

SECTIONS{

. t ex t : { ∗ ( . t ex t ) } >rom

. data : { ∗ ( . data ) } >ram AT>rom

. bss : { ∗ . ( bss ) } >ram}


Para obtener el ejecutable tan solo hay que teclear make en la lınea decomandos y se obtendra un fichero de salida llamado sample.elf.

Resulta interesante estudiar el resultado de los ficheros .map y .lst. Elprimero de ellos contiene la configuracion de la memoria para el ejecutable,de manera que se puede encontrar en este fichero sobre todos los sımbolos delprograma y su direccion de memoria correspondiente. El fichero .lst corres-ponde al desensamblado del codigo ejecutable, ası que puede ser muy util sise quiere conocer cual es el detalle del funcionamiento del microprocesadory de su juego de instrucciones.

6.2. Simulacion paso a paso

Una vez que se tiene compilado el programa, se puede ejecutar la apli-cacion KMcsim para iniciar una sesion de depuracion y comprobar que elprograma funciona correctamente.

Figura 6.1: Asistente para la localizacion del simulador.

En primer lugar, la primera vez que se ejecuta la aplicacion se abrira unapequena ventana preguntando por el path completo donde se encuentra elsimulador(figura 6.1). Esto es ası porque este simulador no tiene por que estarinstalado en una ubicacion estandar del sistema, de modo que es mejor queel usuario indique su ubicacion.

Esta es una de las opciones de configuracion de la aplicacion, de modo queel usuario podra cambiar el simulador que esta utilizando para pasar a de-purar otro programa. Como es logico, ese cambio no puede tener lugar hastaque se cierre esa ejecucion de la aplicacion y vuelva a abrirse una nueva, puesno tiene sentido que el cambio se haga de manera que la sesion de depuracionpermanezca activa si lo que se quiere es cambiar el simulador. Ademas, porla propia naturaleza de la depuracion cruzada, sera obligatorio que el usuarioindique otro codigo que se ajuste al nuevo simulador seleccionado.

Una vez introducido el path del simulador se podra cargar el fichero conla accion estandar de Abrir fichero. Al iniciar esta accion se abre un selector

6.2 Simulacion paso a paso 115

de ficheros (figura 6.2) sobre el que se puede navegar para localizar el ficheroejecutable que se quiere simular. En el caso que se esta siguiendo sera elfichero sample.elf.

Estos pasos haran que el contenido del fichero fuente se muestre en lavista principal del simulador. En una vista que aparece arriba a la izquierdade esta se muestran todos los ficheros que forman el ejecutable con el quese esta trabajando. Si se hace click con el raton sobre los distintos ficherosira cambiando el codigo que se muestra en pantalla.

Se pueden insertar puntos de ruptura simplemente con pinchar dos vecessobre una lınea del codigo fuente. Hay que decir que esta claro que no se pue-den insertar puntos de ruptura en ficheros de cabecera, aunque la aplicacionno hara nada si el usuario lo intenta. Inmediatamente, abajo y a la izquier-da aparece una vista con informacion sobre el punto de ruptura introducido(figura 6.3).

Estos puntos de ruptura pueden eliminarse seleccionandolos en ese visory pulsando sobre el boton derecho del raton. Aparece un menu muy simpleque tambien nos da la oportunidad de, simplemente, deshabilitar el punto deruptura.

Una vez que se introduce un punto de ruptura se habilita el menu de

Figura 6.2: Selector de ficheros para cargar un ejecutable dentro de la apli-cacion.


comenzar con la depuracion del programa. Si se acciona este menu, el pro-grama empieza a ejecutarse y se detiene en el primer punto de ruptura queencuentra. Los visores de memoria, registros y pila del sistema se actualizanen cada paso de ejecucion con sus valores correspondientes (figura 6.4).

Una vez aquı, el usuario puede manejar la ejecucion del programa a suantojo, al disponer de todas la instrucciones de flujo de programa en sumenu correspondiente y de una serie de iconos en la barra de herramientas.viendo en los visores correspondientes como cambian los valores que al usuariole interesen.

La lınea de codigo por la que va ejecutandose el programa aparece co-loreada en amarillo, al tiempo que esta indicada, junto con el nombre delfichero correspondiente, en la barra de estado.

Ni que decir tiene que el fichero fuente que se muestra en cada momentoes el que corresponde a la lınea que esta ejecutando el micro. Luego, a medidaque el codigo y la ejecucion van saltando de fichero en fichero tambien lo vahaciendo esta vista del codigo.

Hay que decir que existe tambien una opcion para cambiar la configura-cion del sistema. Se puede cambiar, por ejemplo, la zona de memoria que sedesea visualizar, de manera que, siguiendo el ejemplo con el que se esta tra-bajando, es posible ver como cambia el valor de la direccion de memoria

Figura 6.3: Informacion sobre los puntos de ruptura insertados en el codigo.

6.2 Simulacion paso a paso 117

correspondiente al primer bloque de puertos del micro.

Asımismo, tambien es posible seleccionar de la lista de registros del microaquellos cuyo valor considere el usuario que son interesantes, como podrıa serel contador de programa, el registro de pila o los que se usan para pasar argu-mentos de funciones. En cualquier caso, es el usuario el que elige los registrosque la aplicacion le muestra en pantalla mediante el menu de configuracionde la aplicacion.

En cualquier caso, esta aplicacion, aunque completa, tan solo pretendeser una muestra de lo que ha intentado conseguir este proyecto, que es unamejor compresion del funcionamiento de los simuladores en gdb y de uno enconcreto, el del microprocesador MCore de Freescale, aparte de la definicionde una interfaz para la construccion de aplicaciones de este tipo. Es poresta razon que esta aplicacion se puede complicar y perfeccionar todo lo quepermite la librerıa GCA o, si se desea, construir desde cero haciendo uso dedicha biblioteca.

Una funcionalidad muy potente que ofrece GCA es el mecanismo de call-back. Mediante estas funciones se puede conseguir que la biblioteca se ocupede realizar las tareas que el programador desee sin tener que hacerlo explıci-tamente. De esta manera, se podrıa, por ejemplo, registrar una funcion de

Figura 6.4: Programa en ejecucion con informacion sobre la memoria, losregistros y la pila.


callback para que vigilara en cada ejecucion de una lınea de codigo el valordel primer bloque de puertos (por seguir con el programa que se ha venidoutilizando hasta ahora).

A la aplicacion grafica podrıa anadırsele entonces la posibilidad de mos-trar mediante un widget personalizado para este bloque que su estado hacambiado, en lugar de hacerlo tan solo mostrando su valor numerico.

Una idea interesante que ofrece esta arquitectura es la de construir modu-los independientes a la aplicacion, pero que esta pueda utilizar de algun modopara conectarlos a los perifericos que se han anadido al simulador. Se podrıatener, por ejemplo, un modulo que representase graficamente un banco deLED y que pudiera conectarse a una direccion concreta de memoria. De estamanera, podrıa simularse graficamente el comportamiento del programa deejemplo.

Apendice A

Codigo fuente de la bibliotecaGCA

En este apendice se muestra el codigo fuente de la librerıa GCA completa.En un capıtulo anterior se ha visto cada una de las declaraciones de lasfunciones que forman la interfaz y en las siguientes secciones se puede estudiarla definicion de dichas funciones.

No se va a volver a explicar el significado de cada uno de los ficherosde la interfaz, puesto que, como se ha dicho, ya se encuentra ampliamentedetallado en una seccion precedente. Sı se daran algunas notas, sin embargo,de aquellos ficheros internos a la biblioteca, que no pertenecen a la interfazy, por tanto, no fueron presentados con anterioridad.

Hay que decir, no obstante, que esta seccion se presenta como documen-to de consulta para un estudio mas detallado de la implementacion de lalibrerıa. El programador que tan solo quiera hacer uso de ella puede hacer-lo sin tener que acudir a este apendice y refiriendose exclusivamente a sucapıtulo correspondiente.

A.1. common.h

En este fichero se encuentran definiciones de constantes de uso obligatorioo muy frecuente en el resto de ficheros, ası como algunas definiciones defunciones basicas para el funcionamiento de la biblioteca. Es por ello queeste fichero se incluye en el resto de ficheros de cabecera de la librerıa.

#ifndef GCA COMMON H#define GCA COMMON H 1

120 Codigo fuente de la biblioteca GCA

#i f HAVE CONFIG H# include ” c o n f i g . h”#endif /∗ HAVE CONFIG H ∗/

#include <s t d i o . h>#include <sys / types . h>

#ifde f HAVE STDLIB H# include <s t d l i b . h>#endif /∗ HAVE STDLIB H ∗/

#ifndef PARAMS# ifde f STDC# ifndef NOPROTOS# define PARAMS( args ) args# endif /∗ !NOPROTOS ∗/# endif /∗ STDC ∗/# ifndef PARAMS# define PARAMS( args ) ( )# endif /∗ !PARAMS ∗/#endif /∗ !PARAMS ∗/

#ifde f c p l u s p l u s# define BEGIN C DECLS extern ”C” {# define END C DECLS }#else /∗ ! c p l u s p l u s ∗/# define BEGIN C DECLS# define END C DECLS#endif /∗ c p l u s p l u s ∗/

#ifde f STDCtypedef void ∗PTR;#else /∗ ! STDC ∗/typedef char ∗PTR;#endif /∗ STDC ∗/

#ifndef GCA STMT START# define GCA STMT START do# define GCA STMT END while (0 )#endif /∗ !GCA STMT START ∗/

A.1 common.h 121

#ifndef FALSE# define FALSE 0# define TRUE 1#endif /∗ !FALSE ∗/

#ifndef EXIT SUCCESS# define EXIT SUUCESS 0# define EXIT FAILURE 1#endif /∗ ! EXIT SUCCESS ∗/

#ifndef FAILURE# define SUCCESS 0# define FAILURE −1#endif /∗ !FAILURE ∗/

#ifndef ARRAY SIZE# define ARRAY SIZE( tab l e ) \

( s izeof ( t ab l e ) / s izeof ( t a b l e [ 0 ] ) )#endif /∗ !ARRAY SIZE ∗/

#ifndef r e t u r n v a l i f f a i l# define r e t u r n v a l i f f a i l ( expr , va l ) \

i f ( ! ( expr ) ) return va l ;#endif /∗ ! r e t u r n v a l i f f a i l ∗/

#define XCALLOC( type , num) \( ( type ∗) x c a l l o c ( (num) , s izeof ( type ) ) )

#define XMALLOC( type , num) \( ( type ∗) xmalloc ( (num) ∗ s izeof ( type ) ) )

#define XREALLOC( type , p , num) \( ( type ∗) x r e a l l o c ( ( p ) , (num) ∗ s izeof ( type ) ) )

#define XFREE( s t a l e ) \i f ( s t a l e ) { f r e e ( (PTR) s t a l e ) ; s t a l e = 0 ; }

BEGIN C DECLSextern PTR x c a l l o c

PARAMS ( ( s i z e t num, s i z e t s i z e ) ) ;extern PTR xmalloc PARAMS ( ( s i z e t num ) ) ;extern PTR x r e a l l o c PARAMS ( (PTR p , s i z e t num ) ) ;extern char ∗xstrdupPARAMS ( ( const char ∗ s t r i n g ) ) ;


extern char ∗ x s t r s t rPARAMS ( ( const char ∗haystack ,

const char ∗ need le ) ) ;extern char ∗ xs t r ch rPARAMS ( ( const char ∗s , int c ) ) ;

END C DECLS

#endif /∗ !GCA COMMON H ∗/

A.2. string.h

Para el manejo de cadenas de caracteres dinamicas se ha definido un tipoString al modo que lo hace, salvando las distancias, glib. De esta forma, estetipo no es mas que una estructura con su puntero a caracter para contener lacadena y con un par de miembros que tienen la informacion sobre la longitudde la cadena y sobre el espacio reservado para ella.

Todas las funciones que trabajan con este tipo se ocupan, entonces, demanejar el tamano de la cadena, reservando para ella mas espacio si es ne-cesario.

#ifndef STRING H#define STRING H 1

#include ”common . h”

BEGIN C DECLS

#define DOUBLE QUOTES ’ \” ’

typedef struct{

char ∗ s t r ;s i z e t l en ;s i z e t a l l o c a t e d l e n ;

} St r ing ;

extern St r ing ∗ s t r ing newPARAMS ( ( const char ∗ i n i t ) ) ;

A.2 string.h 123

extern St r ing ∗ s t r i n g n e w l e nPARAMS ( ( const char ∗ i n i t , s i z e t l en ) ) ;extern St r ing ∗ s t r i n g s i z e d n e wPARAMS ( ( s i z e t d f l s i z e ) ) ;extern char ∗ s t r i n g t e x tPARAMS ( ( St r ing ∗ s t r i n g ) ) ;extern St r ing ∗ s t r i n g a s s i g nPARAMS ( ( St r ing ∗ s t r i ng , const char ∗ r v a l ) ) ;extern St r ing ∗ s t r i n g a s s i g n l e nPARAMS ( ( St r ing ∗ s t r i ng , const char ∗ rva l ,

s i z e t l en ) ) ;extern St r ing ∗ s t r i n g a p p e n d p r i n t fPARAMS ( ( St r ing ∗ s t r i ng , const char ∗ format ,

. . . ) ) ;extern St r ing ∗ s t r ing appendPARAMS ( ( St r ing ∗ s t r i ng , const char ∗ va l ) ) ;extern St r ing ∗ s t r i ng append cPARAMS ( ( St r ing ∗ s t r i ng , char c ) ) ;extern St r ing ∗ s t r i ng p r eppend cPARAMS ( ( St r ing ∗ s t r i ng , char c ) ) ;extern St r ing ∗ s t r i n g t r u n c a t ePARAMS ( ( St r ing ∗ s t r i ng , s i z e t l en ) ) ;extern St r ing ∗ s t r i n g s e t s i z ePARAMS ( ( St r ing ∗ s t r i ng , s i z e t l en ) ) ;extern void s t r i n g f r e ePARAMS ( ( St r ing ∗ s t r i n g ) ) ;extern int s t r i n g t o i n tPARAMS ( ( St r ing ∗ s t r i n g ) ) ;extern St r ing ∗ s t r i n g q u o t e t e x tPARAMS ( ( St r ing ∗ s t r i n g ) ) ;

END C DECLS

#endif /∗ STRING H ∗/

#i f HAVE CONFIG H# include <c o n f i g . h>#endif

#i f HAVE STDARG H


# include <s tdarg . h>#endif

#include ” s t r i n g . h”

#define DFL SIZE 15

St r ing ∗s t r ing new ( i n i t )

const char ∗ i n i t ;{

St r ing ∗new = NULL;i f ( i n i t ){

new = XCALLOC ( Str ing , 1 ) ;i f (new && (new−>s t r = xstrdup ( i n i t ) ) ){

new−>l en = s t r l e n (new−>s t r ) ;new−>a l l o c a t e d l e n = new−>l en + 1 ;

}else{

XFREE (new ) ;new = NULL;

}}

return new ;}

St r ing ∗s t r i n g n e w l e n ( i n i t , l en )

const char ∗ i n i t ;s i z e t l en ;

{St r ing ∗new = NULL ; ;i f ( i n i t ){

new = XCALLOC ( Str ing , 1 ) ;i f (new

&& (new−>s t r = XCALLOC (char , l en + 1 ) ) ){

A.2 string.h 125

st rncpy (new−>s t r , i n i t , l en ) ;new−>s t r [ l en ] = 0 ;new−>l en = len ;new−>a l l o c a t e d l e n = len + 1 ;

}else{

XFREE (new ) ;new = NULL;

}}

return new ;}

St r ing ∗s t r i n g s i z e d n e w ( d f l s i z e )

s i z e t d f l s i z e ;{

St r ing ∗new = XCALLOC ( Str ing , 1 ) ;i f (new)

i f (new−>s t r = XCALLOC (char , d f l s i z e + 1) ){

new−>l en = 0 ;new−>a l l o c a t e d l e n = d f l s i z e + 1 ;

}else

XFREE (new ) ;return new ;

}

char ∗s t r i n g t e x t ( s t r i n g )

S t r ing ∗ s t r i n g ;{

return s t r i n g ? s t r i ng−>s t r : NULL;}

St r ing ∗s t r i n g a s s i g n ( s t r i ng , r v a l )

S t r ing ∗ s t r i n g ;const char ∗ r v a l ;


{int l en ;i f ( r v a l ){

l en = s t r l e n ( r v a l ) ;return s t r i n g a s s i g n l e n ( s t r i ng , rva l ,

l en ) ;}

elsereturn NULL;

}

St r ing ∗s t r i n g a s s i g n l e n ( s t r i ng , rva l , l en )

S t r ing ∗ s t r i n g ;const char ∗ r v a l ;s i z e t l en ;

{i f ( r v a l ){

i f ( s t r i n g = s t r i n g s e t s i z e ( s t r i ng , l en ) ){

st rncpy ( s t r i ng−>s t r , rva l , l en ) ;s t r i ng−>l en = len ;

}}

elses t r i n g = NULL;

return s t r i n g ;}

St r ing ∗#i f HAVE STDARG Hs t r i n g a p p e n d p r i n t f ( S t r ing ∗ s t r i ng ,

const char ∗ format , . . . )#else /∗ !HAVE STDARG H ∗/s t r i n g a p p e n d p r i n t f ( s t r i ng , format , v a a l i s t )

S t r ing ∗ s t r i n g ;const char ∗ format ;va dc l ;

#endif /∗ HAVE STDARG H ∗/

A.2 string.h 127

{int l en ;v a l i s t ap ;S t r ing ∗ va l ;r e t u r n v a l i f f a i l ( s t r i ng , NULL) ;va l = s t r i n g s i z e d n e w (DFL SIZE ) ;r e t u r n v a l i f f a i l ( val , NULL) ;v a s t a r t ( ap , format ) ;do{

l en =v s n p r i n t f ( val−>s t r , val−>a l l o c a t e d l e n ,

format , ap ) ;val−>l en = val−>a l l o c a t e d l e n − 1 ;i f ( l en > val−>a l l o c a t e d l e n )

i f ( ! s t r i n g s e t s i z e ( val , l en ) )s t r i n g = NULL;

}while ( val−>l en < l en − 1 && s t r i n g ) ;s t r i n g = str ing append ( s t r i ng , val−>s t r ) ;s t r i n g f r e e ( va l ) ;va end ( ap ) ;return s t r i n g ;

}

St r ing ∗s t r ing append ( s t r i ng , va l )

S t r ing ∗ s t r i n g ;const char ∗ va l ;

{int i = 0 ;char ∗end ;r e t u r n v a l i f f a i l ( s t r i ng , NULL) ;r e t u r n v a l i f f a i l ( val , s t r i n g ) ;i f ( s t r i n g = s t r i n g s e t s i z e ( s t r i ng ,

s t r i ng−>l en +s t r l e n ( va l ) ) )

{for ( end = s t r i ng−>s t r + s t r i ng−>l en ;

i < s t r l e n ( va l ) ; )end [ i ++] = va l [ i ] ;


s t r i ng−>l en += i ;}


St r ing ∗s t r i ng append c ( s t r i ng , c )

S t r ing ∗ s t r i n g ;char c ;

{i f ( s t r i n g && ( s t r i n g = s t r i n g s e t s i z e

( s t r i ng , s t r i ng−>l en + 1 ) ) ){

s t r i ng−>s t r [ s t r i ng−>l en ] = c ;s t r i ng−>l en++;

}return s t r i n g ;

}

St r ing ∗s t r i ng p r eppend c ( s t r i ng , c )

S t r ing ∗ s t r i n g ;char c ;

{int i ;i f ( s t r i n g && ( s t r i n g = s t r i n g s e t s i z e

( s t r i ng , s t r i ng−>l en + 1 ) ) ){

for ( i = s t r i ng−>l en ; i >= 0 ; i−−)s t r i ng−>s t r [ i + 1 ] = s t r i ng−>s t r [ i ] ;

s t r i ng−>s t r [ 0 ] = c ;s t r i ng−>l en++;


}

St r ing ∗s t r i n g t r u n c a t e ( s t r i ng , l en )

S t r ing ∗ s t r i n g ;s i z e t l en ;

{

A.2 string.h 129

i f ( s t r i n g && len < s t r i ng−>l en ){

s t r i ng−>s t r [ l en ] = 0 ;s t r i ng−>l en = len ;


}

St r ing ∗s t r i n g s e t s i z e ( s t r i ng , l en )

S t r ing ∗ s t r i n g ;s i z e t l en ;

{char ∗tmp ;i f ( s t r i n g ){

i f ( s t r i ng−>a l l o c a t e d l e n < l en + 1){

i f (tmp =XREALLOC (char , s t r i ng−>s t r ,

l en + 1) ){

s t r i ng−>s t r = tmp ;s t r i ng−>a l l o c a t e d l e n = len + 1 ;s t r i ng−>s t r [ l en ] = 0 ;return s t r i n g ;

}else

return NULL;}

elsereturn s t r i n g t r u n c a t e ( s t r i ng , l en ) ;

}else

return NULL;}

voids t r i n g f r e e ( s t r i n g )



i f ( s t r i n g ){

XFREE ( s t r i ng−>s t r ) ;XFREE ( s t r i n g ) ;

}}

ints t r i n g t o i n t ( s t r i n g )


return s t r i n g ? ( int ) s t r t o l ( s t r i ng−>s t r , NULL,0) : FAILURE;

}

St r ing ∗s t r i n g q u o t e t e x t ( s t r i n g )


s t r i n g =s t r ing append c ( s t r i ng , DOUBLE QUOTES) ;

s t r i n g =s t r i ng p r eppend c ( s t r i ng , DOUBLE QUOTES) ;


A.3. xmalloc.c, xstrdup.c, xstrstr.c

En el primero de estos ficheros estan todas las funciones que manejandinamicamente la memoria de sistema. No son mas que una envoltura paralas funciones de la librerıa estandar de C, pero a las que se les ha anadidouna pequena parte de comprobacion de parametros.

Lo mismo se puede decir de los otros dos ficheros, que tambien proporcio-nan una serie de funciones que son envolturas con comprobacion de parame-tros para funciones de la librerıa estandar de C.


PTR

A.3 xmalloc.c, xstrdup.c, xstrstr.c 131

x c a l l o c (num, s i z e )s i z e t num;s i z e t s i z e ;

{#i f HAVE CALLOC

PTR new = c a l l o c (num, s i z e ) ;i f ( ! new)

p r i n t f ( ”Memory exhausted ” ) ;#else

PTR new = xmalloc (num ∗ s i z e ) ;bzero (new , num ∗ s i z e ) ;

#endifreturn new ;

}

PTRxmalloc (num)

s i z e t num;{

PTR new = mal loc (num ) ;i f ( ! new)

p r i n t f ( ”Memory exhausted ” ) ;return new ;

}

PTRx r e a l l o c (p , num)

PTR p ;s i z e t num;

{PTR new ;i f ( ! p )

return xmalloc (num ) ;new = r e a l l o c (p , num ) ;i f ( ! new)

p r i n t f ( ”Memory exhausted ” ) ;return new ;

}

#ifndef WITH DMALLOC


#include <s t r i n g . h>

#i f HAVE CONFIG H# include <c o n f i g . h>#endif /∗ !HAVE CONFIG H ∗/


char ∗xstrdup ( s t r i n g )

const char ∗ s t r i n g ;{

char ∗new ;r e t u r n v a l i f f a i l ( s t r i ng , NULL) ;new = XMALLOC (char , s t r l e n ( s t r i n g ) + 1 ) ;return new ? s t r cpy (new , s t r i n g ) : new ;

}

#endif /∗ !WITH DMALLOC ∗/


#i f HAVE CONFIG H# include <c o n f i g . h>#endif /∗ !HAVE CONFIG H ∗/


char ∗x s t r s t r ( haystack , need l e )

const char ∗haystack ;const char ∗ need le ;

{return haystack ? s t r s t r ( haystack ,

need l e ) : NULL;}

char ∗xs t r ch r ( s , c )

A.4 result.h 133

const char ∗ s ;int c ;

{return s ? s t r c h r ( s , c ) : NULL;

}

A.4. result.h

En este fichero se encuentra el motor de procesamiento de la salida de loscomandos mi1 de gdb. Un result no es mas que una estructura que tiene lainformacion de una variable tal como la entiende la salida de un comandomi1. Esta informacion es el nombre de dicha variable y su valor. Lo que ocurrees que este valor puede ser una cadena de caracteres, una lista de cadenas,un result a su vez o una lista de results.

#ifndef RESULT H#define RESULT H 1

#include ”common . h”#include ”gca−command . h”#include ”gca−v a r i a b l e . h”

BEGIN C DECLS

typedef int (∗ setmemberfunc )PARAMS ( (PTR, char ∗ ) ) ;

#define VARIABLE(name) #name”=”

typedef struct r e s u l t Result ;

typedef enum{

RESULT TYPE CSTRING = 0 ,RESULT TYPE CSTRING LIST,RESULT TYPE TUPLE,RESULT TYPE TUPLE LIST

} ResultType ;


extern void r e s u l t f r e e PARAMS ( (PTR r s l t ) ) ;extern char ∗ r e s u l t v a r i a b l ePARAMS ( ( Result ∗ r s l t ) ) ;extern PTR r e s u l t v a l u e PARAMS ( ( Result ∗ r s l t ) ) ;extern Result ∗ r e s u l t g e t v a r i a b l ePARAMS ( ( char ∗varname , GcaCommand ∗ cmd ) ) ;extern Result ∗ r e s u l t v a l u e t o u i n tPARAMS ( ( Result ∗ r s l t , u int ∗ va lptr ,

const char ∗varname ) ) ;extern Result ∗ r e s u l t v a l u e t o b o o l e a nPARAMS ( ( Result ∗ r s l t , u int ∗ va lptr ,

const char ∗varname , const char ∗ value ) ) ;extern Result ∗ r e s u l t v a l u e t o c h a r p t rPARAMS ( ( Result ∗ r s l t , PTR st ruc tp t r ,

setmemberfunc func ,const char ∗varname ) ) ;

extern Result ∗ r e s u l t v a l u e t o v a r i a b l ePARAMS ( ( Result ∗ r s l t , GcaVariable ∗ var ,

const char ∗varname ) ) ;

END C DECLS

#endif /∗ !RESULT H ∗/


#include ”gca−command . h”#include ”gca−v a r i a b l e . h”#include ” l i s t . h”#include ” r e s u l t . h”#include ” s t r i n g . h”#include ” v a r i a b l e . h”

#define COMMA ’ , ’#define EQUAL SIGN ’=’#define DOUBLE QUOTES ’ \” ’#define ESCAPE ’ \\ ’#define LEFT BRACKET ’ { ’#define RIGHT BRACKET ’ } ’#define LEFT SQUARE BRACKET ’ [ ’

A.4 result.h 135

#define RIGHT SQUARE BRACKET ’ ] ’

struct r e s u l t{

struct r e s u l t ∗next ;char ∗ v a r i a b l e ;ResultType type ;PTR value ;} ;

stat ic Result ∗ r e su l t new PARAMS ( ( void ) ) ;stat ic int r e s u l t s e t v a r i a b l ePARAMS ( ( Result ∗ r s l t , char ∗ v a r i a b l e ) ) ;stat ic int r e s u l t s e t v a l u ePARAMS ( ( Result ∗ r s l t , char ∗ value ) ) ;stat ic char ∗ r e s u l t s e t t u p l e v a r i a b l ePARAMS ( ( Result ∗ r s l t , char ∗out ) ) ;stat ic char ∗ r e s u l t s e t c s t r i n gPARAMS ( ( Result ∗ r s l t , char ∗out ) ) ;stat ic char ∗ r e s u l t s e t c s t r i n g l i s tPARAMS ( ( Result ∗ r s l t , char ∗out ) ) ;stat ic char ∗ r e s u l t s e t t u p l e l i s tPARAMS ( ( Result ∗ r s l t , char ∗out , int ∗depth ) ) ;stat ic char ∗ r e s u l t s e t t u p l ePARAMS ( ( Result ∗ r s l t , char ∗out , int ∗depth ) ) ;stat ic int r e s u l t s e t g c a v a r i a b l ePARAMS ( ( Result ∗ r s l t , GcaVariable ∗ var ) ) ;

stat ic Result ∗r e su l t new ( void ){

return XCALLOC ( Result , 1 ) ;}

voidr e s u l t f r e e ( r s l t )

PTR r s l t ;{

Result ∗ r s = ( Result ∗) r s l t , ∗tmp ;i f ( r s )

switch ( rs−>type )


{case RESULT TYPE CSTRING:

XFREE ( rs−>v a r i a b l e ) ;XFREE ( rs−>value ) ;XFREE ( r s ) ;break ;

case RESULT TYPE CSTRING LIST :XFREE ( rs−>v a r i a b l e ) ;l i s t f r e e ( ( GcaList ∗) rs−>value ,

l i s t d a t a f r e e ) ;XFREE ( r s ) ;break ;

case RESULT TYPE TUPLE:XFREE ( rs−>v a r i a b l e ) ;l i s t f r e e ( ( GcaList ∗) rs−>value ,

r e s u l t f r e e ) ;XFREE ( r s ) ;break ;

case RESULT TYPE TUPLE LIST :XFREE ( rs−>v a r i a b l e ) ;while ( rs−>value ){

tmp = rs−>value ;rs−>value = (PTR) tmp−>next ;l i s t f r e e ( ( GcaList ∗)

g c a l i s t d a t a ( ( GcaList ∗)tmp ) ,

r e s u l t f r e e ) ;XFREE (tmp ) ;

}XFREE ( r s ) ;break ;

}}

char ∗r e s u l t v a r i a b l e ( r s l t )

Result ∗ r s l t ;{

return r s l t ? r s l t−>v a r i a b l e : NULL;}

A.4 result.h 137

stat ic intr e s u l t s e t v a r i a b l e ( r s l t , v a r i a b l e )

Result ∗ r s l t ;char ∗ v a r i a b l e ;

{i f ( r s l t ){

XFREE ( r s l t−>v a r i a b l e ) ;return ( r s l t−>v a r i a b l e =

xstrdup ( v a r i a b l e ) ) ? SUCCESS :FAILURE;

}else

return FAILURE;}

PTRr e s u l t v a l u e ( r s l t )

Result ∗ r s l t ;{

return r s l t ? r s l t−>value : NULL;}

stat ic intr e s u l t s e t v a l u e ( r s l t , va lue )

Result ∗ r s l t ;char ∗ value ;

{i f ( r s l t ){

XFREE ( r s l t−>value ) ;return ( r s l t−>value =

(PTR) xstrdup ( va lue ) ) ? SUCCESS :FAILURE;

}else

return FAILURE;}

stat ic char ∗


r e s u l t s e t t u p l e v a r i a b l e ( r s l t , out )Result ∗ r s l t ;char ∗out ;

{St r ing ∗var ;char ∗tmp = NULL;i f ( r s l t && out ){

tmp = xs t r ch r ( out , EQUAL SIGN ) ;var = s t r i n g n e w l e n ( out , tmp − out ) ;i f ( r e s u l t s e t v a r i a b l e

( r s l t , s t r i n g t e x t ( var ) ) < 0)tmp = NULL;

s t r i n g f r e e ( var ) ;}

return tmp ;}

stat ic char ∗r e s u l t s e t c s t r i n g ( r s l t , out )

Result ∗ r s l t ;char ∗out ;

{St r ing ∗var ;char ∗tmp = NULL;i f ( r s l t && out ){

tmp = out++;do

tmp = xs t r c h r (++tmp , DOUBLE QUOTES) ;while (∗ ( tmp − 1) == ESCAPE) ;var = s t r i n g n e w l e n ( out , tmp − out ) ;i f ( r e s u l t s e t v a l u e

( r s l t , s t r i n g t e x t ( var ) ) < 0)tmp = NULL;

r s l t−>type = RESULT TYPE CSTRING;s t r i n g f r e e ( var ) ;

}return tmp ;

}

A.4 result.h 139

stat ic char ∗r e s u l t s e t c s t r i n g l i s t ( r s l t , out )

Result ∗ r s l t ;char ∗out ;

{St r ing ∗var ;char ∗ s t r , ∗tmp = NULL;GcaList ∗new ;i f ( r s l t && out ){

var = s t r i n g s i z e d n e w ( 1 5 ) ;tmp = out ;do{

out = xs t r ch r (tmp , DOUBLE QUOTES) ;do

tmp = xs t r ch r (++out , DOUBLE QUOTES) ;while (∗ ( tmp − 1) == ESCAPE) ;i f ( s t r i n g a s s i g n l e n

( var , out , tmp − out ) )i f ( s t r = xstrdup ( var−>s t r ) )

i f (new = l i s t n e w ( (PTR) s t r ) ){

r s l t−>value =(PTR) l i s t a p p e n d ( ( GcaList ∗)

r s l t−>value ,new ) ;

continue ;}

elseXFREE ( s t r ) ;

tmp = NULL;}

while (∗tmp && ∗++tmp == COMMA) ;s t r i n g f r e e ( var ) ;r s l t−>type = RESULT TYPE CSTRING LIST ;

}return tmp ;

}


stat ic char ∗r e s u l t s e t t u p l e l i s t ( r s l t , out , depth )

Result ∗ r s l t ;char ∗out ;int ∗depth ;

{Result ∗rnew ;GcaList ∗ lnew ;i f ( r s l t && out ){

do{

i f ( rnew = re su l t new ( ) )i f ( lnew = l i s t n e w ( (PTR) rnew ) ){

r s l t−>value =(PTR) l i s t a p p e n d ( ( GcaList ∗)

r s l t−>value ,lnew ) ;

out =r e s u l t s e t t u p l e ( rnew , out ,

depth ) ;continue ;

}else

XFREE ( rnew ) ;out = NULL;

}while ( out && ∗++out == COMMA) ;r s l t−>type = RESULT TYPE TUPLE LIST ;

}return out ;

}

stat ic char ∗r e s u l t s e t t u p l e ( r s l t , out , depth )

Result ∗ r s l t ;char ∗out ;int ∗depth ;

{out = r e s u l t s e t t u p l e v a r i a b l e ( r s l t , out ) ;

A.4 result.h 141

r e t u r n v a l i f f a i l ( out , NULL) ;switch (∗++out ){case DOUBLE QUOTES:

out = r e s u l t s e t c s t r i n g ( r s l t , out ) ;break ;

case LEFT BRACKET:(∗ depth)++;r s l t−>type = RESULT TYPE TUPLE;r s l t−>value = (PTR) re su l t new ( ) ;out =

r e s u l t s e t t u p l e ( ( Result ∗) r s l t−>value ,++out , depth ) ;

break ;case LEFT SQUARE BRACKET:

(∗ depth)++;switch (∗++out ){case DOUBLE QUOTES:

out =r e s u l t s e t c s t r i n g l i s t ( r s l t , out ) ;

break ;case LEFT BRACKET:

(∗ depth)++;out =

r e s u l t s e t t u p l e l i s t ( r s l t , ++out ,depth ) ;

break ;case RIGHT SQUARE BRACKET:

(∗ depth)−−;r s l t−>value = NULL;break ;

default :r s l t−>value = (PTR) re su l t new ( ) ;out =

r e s u l t s e t t u p l e ( ( Result ∗) r s l t−>value , out , depth ) ;

break ;}

break ;}


i f ( out && ∗depth )switch (∗++out ){case COMMA:

r s l t−>next = re su l t new ( ) ;out =

r e s u l t s e t t u p l e ( r s l t−>next , ++out ,depth ) ;

break ;default :

(∗ depth)−−;break ;

}return out ;

}

Result ∗r e s u l t g e t v a r i a b l e ( varname , cmd)

char ∗varname ;GcaCommand ∗cmd ;

{Result ∗head = NULL, ∗new = NULL;int depth = 0 ;char ∗out = gca command output (cmd ) ;while ( out = x s t r s t r ( out , varname ) ){

new = resu l t new ( ) ;out = r e s u l t s e t t u p l e (new , out , &depth ) ;head =

( Result ∗) l i s t a p p e n d ( ( GcaList ∗) head ,( GcaList ∗) new ) ;

i f ( ! out ){

l i s t f r e e ( (PTR) head , r e s u l t f r e e ) ;head = NULL;

}}

return head ;}

Result ∗

A.4 result.h 143

r e s u l t v a l u e t o u i n t ( r s l t , va lptr , varname )Result ∗ r s l t ;u int ∗ va lp t r ;const char ∗varname ;

{St r ing ∗ s t r i n g =

st r ing new ( r e s u l t v a r i a b l e ( r s l t ) ) ;i f ( s t r i n g ){

i f ( ! strcmp ( varname , s t r i ng−>s t r ) )i f ( s t r i n g a s s i g n

( s t r i ng , r e s u l t v a l u e ( r s l t ) ) ){∗ va lp t r =

( u int ) s t r i n g t o i n t ( s t r i n g ) ;i f ( r s l t−>next )

r s l t = r s l t−>next ;}

elser s l t = NULL;

s t r i n g f r e e ( s t r i n g ) ;}

elser s l t = NULL;

return r s l t ;}

Result ∗r e s u l t v a l u e t o b o o l e a n ( r s l t , va lptr , varname ,

va lue )Result ∗ r s l t ;u int ∗ va lp t r ;const char ∗varname , ∗ value ;




( s t r i ng , r e s u l t v a l u e ( r s l t ) ) )


{∗ va lp t r =

strcmp ( s t r i ng−>s t r ,va lue ) ? FALSE : TRUE;

i f ( r s l t−>next )r s l t = r s l t−>next ;

}else

r s l t = NULL;s t r i n g f r e e ( s t r i n g ) ;

}else

r s l t = NULL;return r s l t ;

}

Result ∗r e s u l t v a l u e t o c h a r p t r ( r s l t , s t ruc tp t r , func ,

varname )Result ∗ r s l t ;PTR s t r u c t p t r ;setmemberfunc func ;const char ∗varname ;




( s t r i ng , r e s u l t v a l u e ( r s l t ) ) ){

i f ( ! ( ∗ func ) ( s t ruc tp t r , s t r i ng−>s t r ) ){

i f ( r s l t−>next )r s l t = r s l t−>next ;

}else

r s l t = NULL;}

else

A.4 result.h 145

r s l t = NULL;s t r i n g f r e e ( s t r i n g ) ;

}else

r s l t = NULL;return r s l t ;

}

Result ∗r e s u l t v a l u e t o v a r i a b l e ( r s l t , var , varname )

Result ∗ r s l t ;GcaVariable ∗var ;const char ∗varname ;



i f ( ! strcmp ( varname , s t r i ng−>s t r ) ){

i f ( r e s u l t s e t g c a v a r i a b l e ( r s l t , var )< 0)

r s l t = NULL;else i f ( r s l t−>next )

r s l t = r s l t−>next ;}

s t r i n g f r e e ( s t r i n g ) ;}

elser s l t = NULL;

return r s l t ;}

stat ic intr e s u l t s e t g c a v a r i a b l e ( r s l t , var )

Result ∗ r s l t ;GcaVariable ∗var ;

{int r e t v a l = SUCCESS;GcaList ∗ l i s t ;GcaVariable ∗new ;


i f ( r s l t ){

var = NULL;l i s t = ( GcaList ∗) r e s u l t v a l u e ( r s l t ) ;while ( l i s t ){

new = var iab l e new ( ) ;var =

( GcaVariable ∗)l i s t a p p e n d ( ( GcaList ∗) var ,

( GcaList ∗) new ) ;i f ( v a r i a b l e s e t v a l u e s

(new ,( Result ∗) g c a l i s t d a t a ( l i s t ) ) <

0){

g c a v a r i a b l e f r e e ( var ) ;var = NULL;r e t v a l = FAILURE;break ;

}l i s t = g c a l i s t n e x t ( l i s t ) ;

}}

elser e t v a l = FAILURE;

return r e t v a l ;}

A.5. gca-session.h

#ifndef GCA SESSION H#define GCA SESSION H 1

#include ”common . h”#include ”gca−c a l l b a c k . h”#include ”gca−command . h”

A.5 gca-session.h 147

BEGIN C DECLS

#define GCA SESSION MAX 1

typedef struct gcaSes s i on GcaSession ;

extern GcaSess ion ∗ g c a s e s s i o n i n i tPARAMS ( ( const char ∗gdb , const char ∗program ) ) ;extern int g c a s e s s i o n c l o s ePARAMS ( ( GcaSession ∗ s e s ) ) ;extern GcaCommand ∗gca sess ion commandPARAMS ( ( GcaSession ∗ s e s ) ) ;extern uint g c a s e s s i o n i s o p e nPARAMS ( ( GcaSession ∗ s e s ) ) ;extern int g c a s e s s i o n s e t c a l l b a c kPARAMS ( ( GcaSession ∗ ses , GcaCallbackType type ,

void (∗ func ) ( void ) ) ) ;extern void g c a s e s s i o n d e l e t e c a l l b a c kPARAMS ( ( GcaSession ∗ ses , u int numcbk ) ) ;extern int g c a s e s s i o n s e t c a l l b a c k t y p ePARAMS ( ( GcaSession ∗ ses , u int numcbk ,

GcaCallbackType type ) ) ;extern const char ∗ g c a s e s s i o n e r r o rPARAMS ( ( GcaSession ∗ s e s ) ) ;extern const char ∗ g c a s e s s i o n s i g n a l r e c e i v e dPARAMS ( ( GcaSession ∗ s e s ) ) ;extern GcaCommand ∗ gca sess ion execute commandPARAMS ( ( GcaSession ∗ ses , const char ∗op ) ) ;

END C DECLS

#endif /∗ ! GCA SESSION H ∗/

#ifndef SESSION H#define SESSION H 1

#include ” c a l l b a c k . h”#include ”gca− l i s t . h”#include ”gca−s e s s i o n . h”


BEGIN C DECLS

#ifndef READ# define READ 0# define WRITE 1#endif /∗ !READ ∗/

#define IS OPEN( s e s ) ( g c a s e s s i o n i s o p e n ( s e s ) )

typedefuint (∗ output handler )PARAMS ( (GcaCommand ∗ cmd ) ) ;

extern Cal lback ∗ s e s s i o n c a l l b a c kPARAMS ( ( GcaSession ∗ s e s ) ) ;extern int s e s s i o n s e t s i g n a l r e c e i v e dPARAMS ( (PTR ses , char ∗ s i g n a l r e c e i v e d ) ) ;extern int s e s s i o n s e t e r r o rPARAMS ( (PTR ses , char ∗ e r r o r ) ) ;extern GcaList ∗ s e s s i o n r e g i s t e r n a m e sPARAMS ( ( GcaSession ∗ s e s ) ) ;extern int s e s s i o n s e t r e g i s t e r n a m e sPARAMS ( ( GcaSession ∗ ses , GcaList ∗ names ) ) ;extern GcaList ∗ s e s s i o n s o u r c e sPARAMS ( ( GcaSession ∗ s e s ) ) ;extern int s e s s i o n s e t s o u r c e sPARAMS ( ( GcaSession ∗ ses , GcaList ∗ s ou r c e s ) ) ;extern int s e s s i o n f i l e d e s c r i p t o rPARAMS ( ( GcaSession ∗ ses , int mode ) ) ;extern int sess ion execute commandPARAMS ( ( GcaSession ∗ s e s ) ) ;extern int s e s s i on execute s ing l e commandPARAMS ( ( GcaSession ∗ ses , const char ∗op ,

output handler func ) ) ;

END C DECLS

#endif /∗ ! SESSION H ∗/

#include <sys / wait . h>


#include <uni s td . h>

#include ” c a l l b a c k . h”#include ”command . h”#include ”gca−command . h”#include ”gca− l i s t . h”#include ” r e s u l t . h”#include ” s e s s i o n . h”

#define GDB INTERPRETER ”−−i n t e r p r e t e r=mi1”

#define c l o s e f i l e d e s c r i p t o r ( fd , tag ) \i f ( c l o s e ( fd ) ) goto tag ;

struct gcaSes s i on{

GcaCommand ∗command ;u int sd ;u int open ;p i d t c h i l d ;int p2chfd [ 2 ] ;int ch2pfd [ 2 ] ;Cal lback ∗cbk ;char ∗ e r r o r ;char ∗ s i g n a l r e c e i v e d ;GcaList ∗ reg names ;GcaList ∗ sou r c e s ;

} ;

u int open se s [GCA SESSION MAX ] ;

stat ic GcaSess ion ∗ s e s s i on new PARAMS ( ( void ) ) ;stat ic void s e s s i o n f r e ePARAMS ( ( GcaSession ∗ s e s ) ) ;stat ic void s e s s i o n d e s c r i p t o r i n i tPARAMS ( ( void ) ) ;stat ic int s e s s i o n s d PARAMS ( ( void ) ) ;

GcaSession ∗g c a s e s s i o n i n i t ( gdb , program )

const char ∗gdb , ∗program ;


{GcaSession ∗ s e s ;char ∗prog [ 4 ] ={ gdb , program , GDB INTERPRETER, NULL } ;

char ∗noprog [ 3 ] ={ gdb , GDB INTERPRETER, NULL } ;

char ∗∗ args ;

r e t u r n v a l i f f a i l ( gdb , NULL) ;s e s s i o n d e s c r i p t o r i n i t ( ) ;i f ( s e s = se s s i on new ( ) ){

int tmp = s e s s i o n s d ( ) ;i f (tmp < 0)

return NULL;else

ses−>sd = tmp ;}

elsereturn NULL;

args = program ? prog : noprog ;i f ( p ipe ( ses−>p2chfd ) | | pipe ( ses−>ch2pfd ) )

goto e r r o r ;i f ( ( ses−>c h i l d = fo rk ( ) ) < 0)

goto e r r o r ;else i f ( ! ses−>c h i l d ){

c l o s e f i l e d e s c r i p t o r ( ses−>p2chfd [WRITE] ,e r r o r ) ;

c l o s e f i l e d e s c r i p t o r ( ses−>ch2pfd [READ] ,e r r o r ) ;

i f ( dup2 ( ses−>p2chfd [READ] , STDIN FILENO) <0| | dup2 ( ses−>ch2pfd [WRITE] ,

STDOUT FILENO) < 0)goto e r r o r ;

i f ( execv ( gdb , args ) < 0)goto e r r o r ;

}else{


c l o s e f i l e d e s c r i p t o r ( ses−>p2chfd [READ] ,e r r o r ) ;

c l o s e f i l e d e s c r i p t o r ( ses−>ch2pfd [WRITE] ,e r r o r ) ;

ses−>open = TRUE;i f ( command output read

( ses−>command ,s e s s i o n f i l e d e s c r i p t o r ( ses ,

READ) ) < 0)goto e r r o r ;

return s e s ;}

e r r o r :s e s s i o n f r e e ( s e s ) ;return NULL;

}

intg c a s e s s i o n c l o s e ( s e s )

GcaSession ∗ s e s ;{

int ret , s t a t u s ;const char op [ ] = ”−gdb−e x i t ” ;output handler func = gca command output i s ex i t ;r e t u r n v a l i f f a i l ( IS OPEN ( s e s ) , FAILURE) ;i f ( ( r e t =

waitp id ( ses−>ch i ld , &status ,WNOHANG) ) < 0)

goto e r r o r ;i f ( ! r e t ){

i f ( ( r e t =se s s i on execute s ing l e command ( ses ,

op ,func ) )

< 0)goto e r r o r ;

i f ( ( r e t =waitp id ( ses−>ch i ld , &status , 0 ) ) < 0)

goto e r r o r ;}


c l o s e f i l e d e s c r i p t o r ( s e s s i o n f i l e d e s c r i p t o r( ses , READ) , e r r o r ) ;

c l o s e f i l e d e s c r i p t o r ( s e s s i o n f i l e d e s c r i p t o r( ses , WRITE) , e r r o r ) ;

open se s [ ses−>sd ] = FALSE;r e t =

WIFEXITED ( s t a t u s ) ? SUCCESS :WTERMSIG ( s t a t u s ) ;

e r r o r :s e s s i o n f r e e ( s e s ) ;return r e t ;

}

stat ic GcaSession ∗s e s s i on new ( ){

GcaSession ∗new = XCALLOC ( GcaSession , 1 ) ;i f (new){

new−>command = command new ( ) ;i f ( ! new−>command)

XFREE (new ) ;}

return new ;}

stat ic voids e s s i o n f r e e ( s e s )


i f ( s e s ){

command free ( ses−>command ) ;XFREE ( ses−>e r r o r ) ;XFREE ( ses−>s i g n a l r e c e i v e d ) ;g c a l i s t f r e e ( ses−>reg names ) ;g c a l i s t f r e e ( ses−>s ou r c e s ) ;XFREE ( s e s ) ;

}}


stat ic voids e s s i o n d e s c r i p t o r i n i t ( void ){

int i = 0 ;while ( i < GCA SESSION MAX)

open se s [ i ++] = 0 ;}

stat ic ints e s s i o n s d ( void ){

int sd = 0 ;while ( sd < GCA SESSION MAX)

i f ( open se s [ sd ] )sd++;

elsebreak ;

i f ( sd == GCA SESSION MAX)sd = FAILURE;

return sd ;}

GcaCommand ∗gca sess ion command ( s e s )


return IS OPEN ( s e s ) ? ses−>command : NULL;}

uintg c a s e s s i o n i s o p e n ( s e s )


return s e s ? ses−>open : FALSE;}

Cal lback ∗s e s s i o n c a l l b a c k ( s e s )


return IS OPEN ( s e s ) ? ses−>cbk : NULL;


}

const char ∗g c a s e s s i o n e r r o r ( s e s )


return IS OPEN ( s e s ) ? ses−>e r r o r : NULL;}

ints e s s i o n s e t e r r o r ( ses , e r r o r )

PTR s e s ;char ∗ e r r o r ;

{GcaSession ∗tmp = ( GcaSess ion ∗) s e s ;i f ( s e s ){

XFREE (tmp−>e r r o r ) ;return (tmp−>e r r o r =

xstrdup ( e r r o r ) ) ? SUCCESS :FAILURE;

}else

return FAILURE;}

const char ∗g c a s e s s i o n s i g n a l r e c e i v e d ( s e s )


return IS OPEN ( s e s ) ? ses−>s i g n a l r e c e i v e d : NULL;

}

ints e s s i o n s e t s i g n a l r e c e i v e d ( ses , s i g n a l r e c e i v e d )

PTR s e s ;char ∗ s i g n a l r e c e i v e d ;

{GcaSession ∗tmp = ( GcaSess ion ∗) s e s ;i f (tmp)


{XFREE (tmp−>s i g n a l r e c e i v e d ) ;return (tmp−>s i g n a l r e c e i v e d =

xstrdup ( s i g n a l r e c e i v e d ) ) ? SUCCESS: FAILURE;

}else

return FAILURE;}

GcaList ∗s e s s i o n r e g i s t e r n a m e s ( s e s )


return IS OPEN ( s e s ) ? ses−>reg names : NULL;}

ints e s s i o n s e t r e g i s t e r n a m e s ( ses , names )

GcaSession ∗ s e s ;GcaList ∗names ;

{int r e t v a l = FAILURE;i f ( s e s && names ){

XFREE ( ses−>reg names ) ;ses−>reg names = names ;r e t v a l = SUCCESS;

}return r e t v a l ;

}

GcaList ∗s e s s i o n s o u r c e s ( s e s )


return IS OPEN ( s e s ) ? ses−>sou r c e s : NULL;}

ints e s s i o n s e t s o u r c e s ( ses , s ou r c e s )


GcaSession ∗ s e s ;GcaList ∗ s ou r c e s ;

{int r e t v a l = FAILURE;i f ( s e s && sourc e s ){

XFREE ( ses−>sou r c e s ) ;ses−>sou r c e s = sourc e s ;r e t v a l = SUCCESS;


}

intg c a s e s s i o n s e t c a l l b a c k ( ses , type , func )

GcaSession ∗ s e s ;GcaCallbackType type ;void (∗ func ) ( void ) ;

{stat ic uint number = 0 ;Cal lback ∗new ;int r e t v a l = FAILURE;i f (IS OPEN ( s e s ) )

i f (new = ca l lback new (number , type , func ) ){

ses−>cbk =( Cal lback ∗) l i s t a p p e n d ( ( GcaList ∗)

ses−>cbk ,( GcaList ∗)new ) ;

r e t v a l = number++;}


voidg c a s e s s i o n d e l e t e c a l l b a c k ( ses , numcbk)

GcaSession ∗ s e s ;u int numcbk ;

{i f (IS OPEN ( s e s ) )


ses−>cbk = c a l l b a c k d e l e t e ( ses−>cbk , numcbk ) ;}

intg c a s e s s i o n s e t c a l l b a c k t y p e ( ses , numcbk , type )

GcaSession ∗ s e s ;u int numcbk ;GcaCallbackType type ;

{int r e t v a l = FAILURE;i f (IS OPEN ( s e s ) )

r e t v a l =c a l l b a c k s e t t y p e ( ses−>cbk , numcbk , type ) ;


ints e s s i o n f i l e d e s c r i p t o r ( ses , mode)

GcaSession ∗ s e s ;int mode ;

{r e t u r n v a l i f f a i l ( IS OPEN ( s e s ) , FAILURE) ;return mode ==

READ ? ses−>ch2pfd [ mode ] : ses−>p2chfd [ mode ] ;}

intsess ion execute command ( s e s )


int r e t = FAILURE, rfd , wfd ;S t r ing ∗com =

str ing new ( gca command input( gca session command ( s e s ) ) ) ;

i f ( s t r i ng append c (com , ’ \n ’ ) ){

wfd = s e s s i o n f i l e d e s c r i p t o r ( ses , WRITE) ;r f d = s e s s i o n f i l e d e s c r i p t o r ( ses , READ) ;i f ( wr i t e ( wfd , com−>s t r , com−>l en ) >= 0)

r e t =command output read ( ses−>command , r f d ) ;


}else

command set output ( gca sess ion command ( s e s ) ,NULL) ;

s t r i n g f r e e (com ) ;return r e t ;

}

GcaCommand ∗gca sess ion execute command ( ses , op )

GcaSession ∗ s e s ;const char ∗op ;

{command set input ( gca session command ( s e s ) ,

op ) ;sess ion execute command ( s e s ) ;return ses−>command ;

}

ints e s s i on execute s ing l e command ( ses , op , func )

GcaSession ∗ s e s ;const char ∗op ;output handler func ;

{int r e t v a l ;Result ∗ r s l t ;GcaCommand ∗cmd = gca session command ( s e s ) ;command set input (cmd , op ) ;sess ion execute command ( s e s ) ;r e t v a l = (∗ func ) (cmd) ? SUCCESS : FAILURE;i f ( r e t v a l < 0)

i f ( gca command output i s er ror (cmd) ){

r s l t =r e s u l t g e t v a r i a b l e (VARIABLE (msg ) ,

cmd ) ;r e s u l t v a l u e t o c h a r p t r ( r s l t , (PTR) ses ,

s e s s i o n s e t e r r o r ,”msg” ) ;

r e s u l t f r e e ( r s l t ) ;

A.6 gca-list.h 159


}

A.6. gca-list.h

#ifndef GCA LIST H#define GCA LIST H 1


BEGIN C DECLS

typedef struct l i s t GcaList ;

extern PTR g c a l i s t d a t aPARAMS ( ( GcaList ∗ elmt ) ) ;extern GcaList ∗ g c a l i s t n e x tPARAMS ( ( GcaList ∗ elmt ) ) ;extern GcaList ∗ g c a l i s t t a i lPARAMS ( ( GcaList ∗ elmt ) ) ;extern GcaList ∗ g c a l i s t n t hPARAMS ( ( GcaList ∗ head , s i z e t n ) ) ;extern s i z e t g c a l i s t l e n g t hPARAMS ( ( GcaList ∗ head ) ) ;extern void g c a l i s t f r e ePARAMS ( ( GcaList ∗ head ) ) ;

END C DECLS

#endif /∗ ! GCA LIST H ∗/

#ifndef LIST H#define LIST H 1

#include ”gca− l i s t . h”

BEGIN C DECLS


typedef void (∗ f r e e h a n d l e r ) PARAMS ( (PTR) ) ;

extern GcaList ∗ l i s t n e w PARAMS ( (PTR userdata ) ) ;extern void l i s t d a t a f r e e PARAMS ( (PTR elmt ) ) ;extern GcaList ∗ l i s t p r e p p e n dPARAMS ( ( GcaList ∗ head , GcaList ∗ f i r s t ) ) ;extern GcaList ∗ l i s t a p p e n dPARAMS ( ( GcaList ∗ head , GcaList ∗ t a i l ) ) ;extern GcaList ∗ l i s t c o n sPARAMS ( ( GcaList ∗ elmt , GcaList ∗ next ) ) ;extern GcaList ∗ l i s t d e l e t e n t hPARAMS ( ( GcaList ∗ head , s i z e t n ) ) ;extern void l i s t f r e ePARAMS ( ( GcaList ∗ head , f r e e h a n d l e r func ) ) ;

END C DECLS

#endif /∗ ! GCA LIST H ∗/

#include ” l i s t . h”

struct l i s t{

struct l i s t ∗next ;PTR userdata ;} ;

GcaList ∗l i s t n e w ( userdata )

PTR userdata ;{

GcaList ∗new = XCALLOC ( GcaList , 1 ) ;i f (new){

new−>next = NULL;new−>userdata = userdata ;

}return new ;

}

A.6 gca-list.h 161

voidl i s t d a t a f r e e ( elmt )

PTR elmt ;{

GcaList ∗tmp = ( GcaList ∗) elmt ;i f (tmp){

XFREE (tmp−>userdata ) ;XFREE (tmp ) ;

}}

PTRg c a l i s t d a t a ( elmt )

GcaList ∗ elmt ;{

return elmt ? elmt−>userdata : NULL;}

GcaList ∗l i s t p r e p p e n d ( head , f i r s t )

GcaList ∗head ;GcaList ∗ f i r s t ;

{f i r s t −>next = head ;head = f i r s t ;return f i r s t ;

}

GcaList ∗l i s t a p p e n d ( head , t a i l )

GcaList ∗head ;GcaList ∗ t a i l ;

{GcaList ∗tmp = head ;i f (tmp){

while (tmp−>next )tmp = tmp−>next ;

tmp−>next = t a i l ;}


elsehead = t a i l ;

return head ;}

GcaList ∗l i s t c o n s ( elmt , next )

GcaList ∗ elmt ;GcaList ∗next ;

{elmt−>next = next ;return elmt ;

}

GcaList ∗g c a l i s t n e x t ( elmt )

GcaList ∗ elmt ;{

return elmt ? elmt−>next : NULL;}

GcaList ∗g c a l i s t t a i l ( elmt )

GcaList ∗ elmt ;{

i f ( elmt )while ( elmt−>next )

elmt = elmt−>next ;return elmt ;

}

GcaList ∗l i s t d e l e t e n t h ( head , n)

GcaList ∗head ;s i z e t n ;

{GcaList ∗prev = NULL, ∗tmp = head ;i f ( ! tmp)

return tmp ;for ( ; n > 0 && tmp ; n−−){

A.6 gca-list.h 163

prev = tmp ;tmp = tmp−>next ;

}i f ( prev )

prev−>next = tmp ? tmp−>next : tmp ;else

head = tmp−>next ;XFREE (tmp ) ;return head ;

}

GcaList ∗g c a l i s t n t h ( head , n)

GcaList ∗head ;s i z e t n ;

{for ( ; n > 0 && head ; n−−)

head = head−>next ;return head ;

}

s i z e tg c a l i s t l e n g t h ( head )

GcaList ∗head ;{

s i z e t n ;for (n = 0 ; head ; n++)

head = head−>next ;return n ;

}

voidl i s t f r e e ( head , func )

GcaList ∗head ;f r e e h a n d l e r func ;

{GcaList ∗tmp ;while ( head ){

tmp = head ;head = head−>next ;


(∗ func ) ( (PTR) tmp ) ;}

}

voidg c a l i s t f r e e ( head )

GcaList ∗head ;{

l i s t f r e e ( head , l i s t d a t a f r e e ) ;}

A.7. gca-callback.h

#ifndef GCA CALLBACK H#define GCA CALLBACK H 1


BEGIN C DECLS

typedef enum{

GCA CALLBACK TYPE CONTINUE,GCA CALLBACK TYPE FINISH,GCA CALLBACK TYPE NEXT,GCA CALLBACK TYPE NEXT INSTRUCTION,GCA CALLBACK TYPE RETURN,GCA CALLBACK TYPE RUN,GCA CALLBACK TYPE STEP,GCA CALLBACK TYPE STEP INSTRUCTION,GCA CALLBACK TYPE UNTIL

} GcaCallbackType ;

END C DECLS

#endif /∗ !GCA CALLBACK H ∗/

#ifndef CALLBACK H#define CALLBACK H 1

A.7 gca-callback.h 165

#include ”gca−c a l l b a c k . h”

BEGIN C DECLS

typedef struct c a l l b a c k Cal lback ;

typedef void (∗ cbk handler ) PARAMS ( ( void ) ) ;

extern Cal lback ∗ ca l lback newPARAMS ( ( u int number , GcaCallbackType type ,

cbk handler func ) ) ;extern Cal lback ∗ c a l l b a c k d e l e t ePARAMS ( ( Cal lback ∗ cbk , u int number ) ) ;extern int c a l l b a c k s e t t y p ePARAMS ( ( Cal lback ∗ cbk , u int number ,

GcaCallbackType type ) ) ;extern void c a l l b a c k e x ePARAMS ( ( Cal lback ∗ cbk , GcaCallbackType type ) ) ;extern void c a l l b a c k f r e ePARAMS ( ( Cal lback ∗ cbk ) ) ;

END C DECLS

#endif /∗ CALLBACK H ∗/

#include ” c a l l b a c k . h”#include ”gca− l i s t . h”

struct c a l l b a c k{

struct c a l l b a c k ∗next ;u int number ;GcaCallbackType type ;cbk handler func ;

} ;

Cal lback ∗ca l lback new (number , type , func )

u int number ;


GcaCallbackType type ;cbk handler func ;

{Cal lback ∗new = XCALLOC ( Callback , 1 ) ;i f (new){

new−>number = number ;new−>type = type ;new−>func = func ;

}return new ;

}

Cal lback ∗c a l l b a c k d e l e t e ( cbk , number )

Cal lback ∗cbk ;u int number ;

{int i = 0 ;Cal lback ∗tmp = cbk ;while ( cbk && cbk−>number == number ){

cbk = cbk−>next ;i ++;

}return ( Cal lback ∗) l i s t d e l e t e n t h ( ( GcaList ∗)

cbk , i ) ;}

intc a l l b a c k s e t t y p e ( cbk , number , type )

Cal lback ∗cbk ;u int number ;GcaCallbackType type ;

{int r e t v a l = FAILURE;while ( cbk )

i f ( cbk−>number == number ){

cbk−>type = type ;r e t v a l = SUCCESS;

A.8 gca-micro.h 167

}else

cbk = cbk−>next ;return r e t v a l ;

}

voidc a l l b a c k e x e ( cbk , type )

Cal lback ∗cbk ;GcaCallbackType type ;

{while ( cbk ){

i f ( cbk−>type == type )(∗ cbk−>func ) ( ) ;

cbk = cbk−>next ;}

}

voidc a l l b a c k f r e e ( cbk )

Cal lback ∗cbk ;{

l i s t f r e e ( ( GcaList ∗) cbk , f r e e ) ;}

A.8. gca-micro.h

#ifndef GCA MICRO H#define GCA MICRO H 1

#include <s t d i n t . h>


BEGIN C DECLS

typedef u i n t 3 2 t address ;

typedef i n t 3 2 t word ;


typedef u i n t 3 2 t uword ;

typedef i n t 1 6 t hword ;typedef u i n t 1 6 t uhword ;

typedef i n t 8 t byte ;typedef u i n t 8 t ubyte ;

END C DECLS

#endif /∗ !GCA MICRO H ∗/

A.9. gca-breakpoint.h

#ifndef GCA BREAKPOINT H#define GCA BREAKPOINT H 1

#include ”common . h”#include ”gca−micro . h”#include ”gca−s e s s i o n . h”

BEGIN C DECLS

#define ALL BREAKPOINTS 0

typedef struct gcaBreakpoint GcaBreakpoint ;

extern int gca breakpoint numberPARAMS ( ( GcaBreakpoint ∗ bkpt ) ) ;extern uint g ca b r e ak po i n t ty p e i s w a t c h p o i n tPARAMS ( ( GcaBreakpoint ∗ bkpt ) ) ;extern uint g c a b r e a k p o i n t d i s p o s i t i o n i s k e e pPARAMS ( ( GcaBreakpoint ∗ bkpt ) ) ;extern uint gca breakpo in t enab l edPARAMS ( ( GcaBreakpoint ∗ bkpt ) ) ;extern address g ca br eakpo in t addre s sPARAMS ( ( GcaBreakpoint ∗ bkpt ) ) ;extern const char ∗ g c a b r e a k p o i n t f u n c t i o nPARAMS ( ( GcaBreakpoint ∗ bkpt ) ) ;extern const char ∗ g c a b r e a k p o i n t f i l e

A.9 gca-breakpoint.h 169

PARAMS ( ( GcaBreakpoint ∗ bkpt ) ) ;extern int g c a b r e a k p o i n t l i n ePARAMS ( ( GcaBreakpoint ∗ bkpt ) ) ;extern const char ∗ gc a b r e ak po in t co n d i t i o nPARAMS ( ( GcaBreakpoint ∗ bkpt ) ) ;extern int gca breakpo in t t imesPARAMS ( ( GcaBreakpoint ∗ bkpt ) ) ;extern int g c a b r e a k p o in t i g no r ePARAMS ( ( GcaBreakpoint ∗ bkpt ) ) ;extern int g c a b r e a k p o i n t b r e a k a f t e rPARAMS ( ( GcaSession ∗ ses , u int number ,

u int count ) ) ;extern int gca b r eakpo in t b r eak co n d i t i o nPARAMS ( ( GcaSession ∗ ses , u int number ,

const char ∗cond ) ) ;extern int g c a b r e a k p o i n t d e l e t ePARAMS ( ( GcaSession ∗ ses , u int number ) ) ;extern int g c a b r e a k p o i n t d i s a b l ePARAMS ( ( GcaSession ∗ ses , u int number ) ) ;extern int gca breakpo in t enab l ePARAMS ( ( GcaSession ∗ ses , u int number ) ) ;extern GcaBreakpoint ∗ g c a b r e a k p o i n t i n f oPARAMS ( ( GcaSession ∗ ses , u int number ) ) ;extern int g c a b r e a k p o i n t i n s e r t i n a d d r e s sPARAMS ( ( GcaSession ∗ ses , address addr ) ) ;extern int g c a b r e a k p o i n t i n s e r t i n f u n c t i o nPARAMS ( ( GcaSession ∗ ses , const char ∗ funct ion ,

const char ∗ f i l e ) ) ;extern int g c a b r e a k p o i n t i n s e r t i n l i n ePARAMS ( ( GcaSession ∗ ses , u int l i n e ,

const char ∗ f i l e ) ) ;extern void g c a b r e a k p o i n t f r e ePARAMS ( ( GcaBreakpoint ∗ bkpt ) ) ;

END C DECLS

#endif /∗ !GCA BREAKPOINT H ∗/

#ifndef BREAKPOINT H#define BREAKPOINT H 1


#include ”gca−breakpoint . h”

BEGIN C DECLS

extern GcaBreakpoint ∗breakpoint newPARAMS ( ( void ) ) ;extern void b r e a k p o i n t f r e e PARAMS ( (PTR bkpt ) ) ;

END C DECLS

#endif /∗ !BREAKPOINT H ∗/

#include ” breakpoint . h”#include ”gca−command . h”#include ”gca− l i s t . h”#include ”gca−micro . h”#include ”gca−s e s s i o n . h”#include ” l i s t . h”#include ” r e s u l t . h”#include ” s t r i n g . h”

struct gcaBreakpoint{

struct gcaBreakpoint ∗next ;u int number ;u int watchpoint ;u int keep ;u int enabled ;address addr ;char ∗ func ;char ∗ f i l e ;u int l i n e ;char ∗cond ;u int t imes ;u int i gno r e ;

} ;

stat ic int b r e a k p o i n t s e t f u n c t i o nPARAMS ( (PTR bkpt , char ∗ func ) ) ;


stat ic int b r e a k p o i n t s e t f i l ePARAMS ( (PTR bkpt , char ∗ f i l e ) ) ;stat ic int breakpo in t s e t condPARAMS ( (PTR bkpt , char ∗cond ) ) ;stat ic int breakpoint s ingle commandPARAMS ( ( GcaSession ∗ ses , const char ∗op ,

u int number ) ) ;stat ic int b r e a k p o i n t s e t v a l u e sPARAMS ( ( GcaBreakpoint ∗ bkpt , Result ∗ r s l t ) ) ;stat ic int b r e a k p o i n t i n s e r tPARAMS ( ( GcaSession ∗ ses , const char ∗op ) ) ;

GcaBreakpoint ∗breakpoint new ( ){

return XCALLOC ( GcaBreakpoint , 1 ) ;}

voidb r e a k p o i n t f r e e ( bkpt )

PTR bkpt ;{

GcaBreakpoint ∗tmp = ( GcaBreakpoint ∗) bkpt ;i f (tmp){

XFREE (tmp−>func ) ;XFREE (tmp−> f i l e ) ;XFREE (tmp−>cond ) ;XFREE (tmp ) ;

}}

intgca breakpoint number ( bkpt )

GcaBreakpoint ∗bkpt ;{

return bkpt ? bkpt−>number : FAILURE;}

uintg c a b r ea k po i n t ty pe i s wa t c h p o i n t ( bkpt )



return bkpt ? bkpt−>watchpoint : FALSE;}

uintg c a b r e a k p o i n t d i s p o s i t i o n i s k e e p ( bkpt )


return bkpt ? bkpt−>keep : FALSE;}

uintgca breakpo in t enab l ed ( bkpt )


return bkpt ? bkpt−>enabled : FALSE;}

addressgca br eakpo in t addre s s ( bkpt )


return bkpt ? bkpt−>addr : 0 ;}

const char ∗gc a b r e a k p o i n t f u n c t i o n ( bkpt )


return bkpt ? bkpt−>func : NULL;}

stat ic intb r e a k p o i n t s e t f u n c t i o n ( bkpt , func )

PTR bkpt ;char ∗ func ;

{GcaBreakpoint ∗tmp = ( GcaBreakpoint ∗) bkpt ;i f (tmp){


XFREE (tmp−>func ) ;return (tmp−>func =

xstrdup ( func ) ) ? SUCCESS : FAILURE;}

elsereturn FAILURE;

}

const char ∗g c a b r e a k p o i n t f i l e ( bkpt )


return bkpt ? bkpt−> f i l e : NULL;}

stat ic intb r e a k p o i n t s e t f i l e ( bkpt , f i l e )

PTR bkpt ;char ∗ f i l e ;


XFREE (tmp−> f i l e ) ;return (tmp−> f i l e =

xstrdup ( f i l e ) ) ? SUCCESS : FAILURE;}

elsereturn FAILURE;

}

intg c a b r e a k p o i n t l i n e ( bkpt )


return bkpt ? bkpt−>l i n e : FAILURE;}

const char ∗gc a b r e a k po in t co nd i t i on ( bkpt )

GcaBreakpoint ∗bkpt ;


{return bkpt ? bkpt−>cond : NULL;

}

stat ic intb r e a k p o i n t s e t c o n d i t i o n ( bkpt , cond )

PTR bkpt ;char ∗cond ;


XFREE (tmp−>cond ) ;return (tmp−>cond =

xstrdup ( cond ) ) ? SUCCESS : FAILURE;}

elsereturn FAILURE;

}

intgca breakpo in t t imes ( bkpt )


return bkpt ? bkpt−>t imes : FAILURE;}

intgc a b r e a kp o i n t i g n o r e ( bkpt )


return bkpt ? bkpt−>i gno r e : FAILURE;}

intg c a b r e a k p o i n t b r e a k a f t e r ( ses , number , count )

GcaSession ∗ s e s ;u int number , count ;

{const char op [ ] = ”−break−a f t e r ” ;int r e t = FAILURE;


St r ing ∗com = str ing new ( op ) ;i f ( s t r i n g a p p e n d p r i n t f

(com , ” %u %u” , number , count ) )i f ( ! s e s s i on execute s ing l e command

( ses , com−>s t r ,gca command output is done ) )

r e t = SUCCESS;s t r i n g f r e e (com ) ;return r e t ;

}

intgca b r eakpo in t b r eak cond i t i o n ( ses , number , cond )

GcaSession ∗ s e s ;u int number ;const char ∗cond ;

{const char op [ ] = ”−break−cond i t i on ” ;int r e t = FAILURE;St r ing ∗com , ∗quoted ;quoted = st r ing new ( cond ) ;i f ( s t r i n g q u o t e t e x t ( quoted ) ){

com = str ing new ( op ) ;i f ( s t r i n g a p p e n d p r i n t f

(com , ” %u %s ” , number , quoted−>s t r ) )i f ( ! s e s s i on execute s ing l e command


r e t = SUCCESS;s t r i n g f r e e (com ) ;

}s t r i n g f r e e ( quoted ) ;return r e t ;

}

stat ic intbreakpoint s ingle command ( ses , op , number )

GcaSession ∗ s e s ;const char ∗op ;u int number ;


{int r e t = FAILURE;St r ing ∗com , ∗tmp ;com = tmp = st r ing new ( op ) ;i f ( number != ALL BREAKPOINTS)

tmp =s t r i n g a p p e n d p r i n t f (com , ” %u” , number ) ;

i f ( ! s e s s i on execute s ing l e command( ses , s t r i n g t e x t (tmp) ,

gca command output is done ) )r e t = SUCCESS;


}

intg c a b r e a k p o i n t d e l e t e ( ses , number )

GcaSession ∗ s e s ;u int number ;

{const char op [ ] = ”−break−d e l e t e ” ;return breakpoint s ingle command ( ses , op ,

number ) ;}

intg c a b r e a k p o i n t d i s a b l e ( ses , number )


{const char op [ ] = ”−break−d i s a b l e ” ;return breakpoint s ingle command ( ses , op ,

number ) ;}

intgca breakpo in t enab l e ( ses , number )


{const char op [ ] = ”−break−enable ” ;


return breakpoint s ingle command ( ses , op ,number ) ;

}

GcaBreakpoint ∗g c a b r e a k p o i n t i n f o ( ses , number )


{GcaBreakpoint ∗bkpt = NULL, ∗new ;const char op [ ] = ”−break−i n f o ” ;Result ∗head , ∗ r s l t ;i f ( ! breakpoint s ingle command

( ses , op , number ) ){

head = r s l t =r e s u l t g e t v a r i a b l e (VARIABLE ( bkpt ) ,

gca session command( s e s ) ) ;

do{

new = breakpoint new ( ) ;bkpt =

( GcaBreakpoint ∗)l i s t a p p e n d ( ( GcaList ∗) bkpt ,

( GcaList ∗) new ) ;i f ( b r e a k p o i n t s e t v a l u e s (new , r s l t ) <

0){

g c a b r e a k p o i n t f r e e ( bkpt ) ;bkpt = NULL;break ;

}}

while ( r s l t =( Result ∗) g c a l i s t n e x t ( ( GcaList ∗)

r s l t ) ) ;l i s t f r e e ( ( GcaList ∗) head , r e s u l t f r e e ) ;

}return bkpt ;

}


stat ic intb r e a k p o i n t s e t v a l u e s ( bkpt , r s l t )

GcaBreakpoint ∗bkpt ;Result ∗ r s l t ;

{Result ∗tmp ;int r e t v a l = FAILURE;i f ( bkpt ){

r s l t =r e s u l t v a l u e t o u i n t ( ( Result ∗)

r e s u l t v a l u e ( r s l t ) ,&bkpt−>number ,”number” ) ;

r s l t =r e s u l t v a l u e t o b o o l e a n ( r s l t ,

&bkpt−>watchpoint ,” type ” ,” watchpoint ” ) ;


&bkpt−>keep ,” d i sp ” , ”keep” ) ;


&bkpt−>enabled ,” enabled ” , ”y” ) ;

r s l t =r e s u l t v a l u e t o u i n t ( r s l t , &bkpt−>addr ,

”addr” ) ;r s l t =

r e s u l t v a l u e t o c h a r p t r ( r s l t ,(PTR) bkpt ,b r e a k p o i n t s e t f u n c t i o n ,” func ” ) ;

r s l t =r e s u l t v a l u e t o c h a r p t r ( r s l t ,

(PTR) bkpt ,b r e a k p o i n t s e t f i l e ,


” f i l e ” ) ;r s l t =

r e s u l t v a l u e t o u i n t ( r s l t , &bkpt−>l i n e ,” l i n e ” ) ;

r s l t =r e s u l t v a l u e t o c h a r p t r ( r s l t ,

(PTR) bkpt ,b r e a k p o i n t s e t c o n d i t i o n ,”cond” ) ;

tmp =r e s u l t v a l u e t o u i n t ( r s l t , &bkpt−>times ,

” t imes ” ) ;i f (tmp != r s l t )

tmp =r e s u l t v a l u e t o u i n t (tmp ,

&bkpt−>ignore ,” i gno r e ” ) ;

i f (tmp)r e t v a l = SUCCESS;


}

intg c a b r e a k p o i n t i n s e r t i n a d d r e s s ( ses , addr )

GcaSession ∗ s e s ;address addr ;

{int r e t v a l = FAILURE;const char op [ ] = ”−break−i n s e r t ” ;S t r ing ∗com = str ing new ( op ) ;i f ( s t r i n g a p p e n d p r i n t f (com , ” %x” , addr ) )

r e t v a l = b r e a k p o i n t i n s e r t ( ses , com−>s t r ) ;s t r i n g f r e e (com ) ;return r e t v a l ;

}

intg c a b r e a k p o i n t i n s e r t i n f u n c t i o n ( ses , func ,

f i l e )GcaSession ∗ s e s ;


const char ∗ func , ∗ f i l e ;{

int r e t v a l = FAILURE;const char op [ ] = ”−break−i n s e r t ” ;S t r ing ∗com , ∗tmp ;com = tmp = st r ing new ( op ) ;i f ( f i l e )

tmp =s t r i n g a p p e n d p r i n t f (com , ” %s : ” , f i l e ) ;

i f ( s t r i n g a p p e n d p r i n t f (tmp , ” %s ” , func ) )r e t v a l = b r e a k p o i n t i n s e r t ( ses , com−>s t r ) ;

s t r i n g f r e e (com ) ;return r e t v a l ;

}

intg c a b r e a k p o i n t i n s e r t i n l i n e ( ses , l i n e , f i l e )

GcaSession ∗ s e s ;u int l i n e ;const char ∗ f i l e ;

{int r e t v a l = FAILURE;const char op [ ] = ”−break−i n s e r t ” ;S t r ing ∗com = str ing new ( op ) ;i f ( s t r i n g a p p e n d p r i n t f

(com , ” %s: %u” , f i l e , l i n e ) )r e t v a l = b r e a k p o i n t i n s e r t ( ses , com−>s t r ) ;


}

stat ic intb r e a k p o i n t i n s e r t ( ses , op )

GcaSession ∗ s e s ;const char ∗op ;

{int r e t v a l = FAILURE;Result ∗ r s l t ;i f ( ! s e s s i on execute s ing l e command

( ses , op , gca command output is done ) ){

A.10 gca-command.h 181

r s l t =r e s u l t g e t v a r i a b l e (VARIABLE ( number ) ,


i f ( ! r e s u l t v a l u e t o u i n t( r s l t , &re tva l , ”number” ) )

r e t v a l = FAILURE;l i s t f r e e ( ( GcaList ∗) r s l t , r e s u l t f r e e ) ;


}

voidg c a b r e a k p o i n t f r e e ( bkpt )


l i s t f r e e ( ( GcaList ∗) bkpt , b r e a k p o i n t f r e e ) ;}

A.10. gca-command.h

#ifndef GCA COMMAND H#define GCA COMMAND H 1


BEGIN C DECLS

typedef struct gcaCommand GcaCommand ;

extern char ∗gca command inputPARAMS ( (GcaCommand ∗ cmd ) ) ;extern char ∗gca command outputPARAMS ( (GcaCommand ∗ cmd ) ) ;extern uint gca command output is connectedPARAMS ( (GcaCommand ∗ cmd ) ) ;extern uint gca command output is donePARAMS ( (GcaCommand ∗ cmd ) ) ;extern uint gca command output i s er rorPARAMS ( (GcaCommand ∗ cmd ) ) ;


extern uint gca command output i s ex i tPARAMS ( (GcaCommand ∗ cmd ) ) ;extern uint gca command output is runningPARAMS ( (GcaCommand ∗ cmd ) ) ;extern uint gca command output is stoppedPARAMS ( (GcaCommand ∗ cmd ) ) ;

END C DECLS

#endif /∗ !GCA COMMAND H ∗/

#ifndef COMMANDH#define COMMANDH 1

#include ”gca−command . h”#include ” s t r i n g . h”

BEGIN C DECLS

extern GcaCommand ∗command new PARAMS ( ( void ) ) ;extern void command freePARAMS ( (GcaCommand ∗ cmd ) ) ;extern int command set inputPARAMS ( (GcaCommand ∗ cmd , const char ∗ input ) ) ;extern int command set outputPARAMS ( (GcaCommand ∗ cmd , char ∗output ) ) ;extern int command output readPARAMS ( (GcaCommand ∗ cmd , int fd ) ) ;

END C DECLS

#endif /∗ !COMMANDH ∗/

#include ”command . h”#include ” s t r i n g . h”

#define DFL SIZE 32

#define NL ’ \n ’


#define ESCAPE ’ \\ ’

#define PROMPT ” ( gdb ) ”

typedef enum{

OUTPUT RESULT CLASS CONNECTED = 0 ,OUTPUT RESULT CLASS DONE,OUTPUT RESULT CLASS ERROR,OUTPUT RESULT CLASS EXIT,OUTPUT RESULT CLASS RUNNING

} OutputResultClass ;

char ∗ r e s u l t c l a s s [ ] = { ”ˆ connected ” ,”ˆdone” ,”ˆ e r r o r ” ,”ˆ e x i t ” ,”ˆ running ”

} ;

#define EXIT r e s u l t c l a s s [OUTPUT RESULT CLASS EXIT]

typedef enum{

OUTPUT ASYNC CLASS STOPPED = 0} OutputAsyncClass ;

char ∗ a s y n c c l a s s [ ] = { ”∗ stopped ” } ;

struct gcaCommand{

char ∗ input ;char ∗output ;

} ;

stat ic St r ing ∗ command read output l inePARAMS ( ( St r ing ∗ l i n e , int fd ) ) ;stat ic uint command output result checkPARAMS ( (GcaCommand ∗ cmd , OutputResultClass rc ) ) ;stat ic uint command output async checkPARAMS ( (GcaCommand ∗ cmd , OutputAsyncClass ac ) ) ;


GcaCommand ∗command new ( ){

return XCALLOC (GcaCommand, 1 ) ;}

voidcommand free (cmd)

GcaCommand ∗cmd ;{

i f (cmd){

XFREE (cmd−>input ) ;XFREE (cmd−>output ) ;XFREE (cmd ) ;

}}

char ∗gca command input (cmd)


return cmd ? cmd−>input : NULL;}

intcommand set input (cmd , input )

GcaCommand ∗cmd ;const char ∗ input ;

{i f (cmd){

XFREE (cmd−>input ) ;return (cmd−>input =

xstrdup ( input ) ) ? SUCCESS :FAILURE;

}else

return FAILURE;}


char ∗gca command output (cmd)


return cmd ? cmd−>output : NULL;}

intcommand set output (cmd , output )

GcaCommand ∗cmd ;char ∗output ;

{i f (cmd){

XFREE (cmd−>output ) ;return (cmd−>output =

xstrdup ( output ) ) ? SUCCESS :FAILURE;

}else

return FAILURE;}

intcommand output read (cmd , fd )

GcaCommand ∗cmd ;int fd ;

{uint read ing = TRUE;St r ing ∗ l i n e , ∗tmp ;l i n e = s t r i n g s i z e d n e w (DFL SIZE ) ;while ( read ing ){

tmp = command read output l ine ( l i n e , fd ) ;i f (tmp)

l i n e = tmp ;else

break ;i f ( ! l i n e−>s t r [ 0 ]

| | x s t r s t r ( l i n e−>s t r , PROMPT)


| | x s t r s t r ( l i n e−>s t r , EXIT) )read ing = FALSE;

}command set output (cmd ,

tmp ? l i n e−>s t r : NULL) ;s t r i n g f r e e ( l i n e ) ;return tmp ? SUCCESS : FAILURE;

}

stat ic St r ing ∗command read output l ine ( l i n e , fd )

S t r ing ∗ l i n e ;int fd ;

{int i = 0 , r e t = FAILURE;u int read ing = TRUE;char buf [ DFL SIZE + 1 ] ;i f ( l i n e )

while ( read ing&& ( r e t = read ( fd , &buf [ i ] , 1 ) ) > 0)

{i ++;i f ( i == DFL SIZE | | buf [ i − 1 ] == NL){

buf [ i ] = 0 ;l i n e = st r ing append ( l i n e , buf ) ;i f ( ! l i n e ){

r e t = FAILURE;break ;

}i f ( i == DFL SIZE)

i = 0 ;else

read ing = FALSE;}

}return r e t <= 0 ? NULL : l i n e ;

}

stat ic uint


command output result check (cmd , rc )GcaCommand ∗cmd ;OutputResultClass rc ;

{r e t u r n v a l i f f a i l (cmd , FALSE) ;return x s t r s t r (cmd−>output ,

r e s u l t c l a s s [ r c ] ) ? TRUE : FALSE;}

uintgca command output is connected (cmd)


OutputResultClass rc = OUTPUT RESULT CLASS CONNECTED;return command output result check (cmd , rc ) ;

}

uintgca command output is done (cmd)


OutputResultClass rc = OUTPUT RESULT CLASS DONE;return command output result check (cmd , rc ) ;

}

uintgca command output i s er ror (cmd)


OutputResultClass rc = OUTPUT RESULT CLASS ERROR;return command output result check (cmd , rc ) ;

}

uintgca command output i s ex i t (cmd)


OutputResultClass rc = OUTPUT RESULT CLASS EXIT;return command output result check (cmd , rc ) ;

}


uintgca command output is running (cmd)


OutputResultClass rc = OUTPUT RESULT CLASS RUNNING;return command output result check (cmd , rc ) ;

}

stat ic uintcommand output async check (cmd , ac )

GcaCommand ∗cmd ;OutputAsyncClass ac ;

{r e t u r n v a l i f f a i l (cmd , FALSE) ;return x s t r s t r (cmd−>output ,

a s y n c c l a s s [ ac ] ) ? TRUE : FALSE;}

uintgca command output is stopped (cmd)


OutputAsyncClass ac = OUTPUT ASYNC CLASS STOPPED;return command output async check (cmd ,

ac ) ;}

A.11. gca-data.h

#ifndef GCA DATA H#define GCA DATA H 1

#include ”common . h”#include ”gca− l i s t . h”#include ”gca−micro . h”#include ”gca−s e s s i o n . h”#include ”gca−v a r i a b l e . h”

BEGIN C DECLS

A.11 gca-data.h 189

#define ALL REGISTERS 1024

typedef struct gcaDataRegister GcaDataRegister ;

extern int gca data read memoryPARAMS ( ( GcaSession ∗ ses , address addr ,

ubyte ∗ bu f f e r , s i z e t s i z e ) ) ;GcaVariable ∗ g c a d a t a e v a l u a t e e x p r e s s i o nPARAMS ( ( GcaSession ∗ ses , char ∗ expr ) ) ;extern int gca data r eg i s t e r numberPARAMS ( ( GcaDataRegister ∗ reg ) ) ;extern word g c a d a t a r e g i s t e r v a l u ePARAMS ( ( GcaDataRegister ∗ reg ) ) ;extern GcaList ∗ gca da ta r eg i s t e r namePARAMS ( ( GcaSession ∗ ses , u int number ) ) ;extern int g c a d a t a r e g i s t e r g e t n u m b e rPARAMS ( ( GcaSession ∗ ses , const char ∗name ) ) ;extern GcaDataRegister ∗ g c a d a t a r e g i s t e r i n f oPARAMS ( ( GcaSession ∗ ses , u int number ) ) ;extern GcaList ∗ g c a d a t a c h a n g e d r e g i s t e r sPARAMS ( ( GcaSession ∗ s e s ) ) ;extern int g c a d a t a r e g i s t e r c o u n tPARAMS ( ( GcaSession ∗ s e s ) ) ;extern void g c a d a t a r e g i s t e r f r e ePARAMS ( ( GcaDataRegister ∗ reg ) ) ;

END C DECLS

#endif /∗ !GCA DATA H ∗/

#include ”gca−command . h”#include ”gca−data . h”#include ”gca− l i s t . h”#include ”gca−micro . h”#include ”gca−s e s s i o n . h”#include ” l i s t . h”#include ” r e s u l t . h”#include ” s e s s i o n . h”#include ” s t r i n g . h”#include ” v a r i a b l e . h”


struct gcaDataRegister{

struct gcaDataRegister ∗next ;u int number ;word value ;

} ;

stat ic int d a t a s e t b u f f e r b y t ePARAMS ( ( ubyte ∗ bu f f e r , Result ∗ r s l t ) ) ;stat ic GcaDataRegister ∗ d a t a r e g i s t e r n e wPARAMS ( ( void ) ) ;stat ic GcaList ∗ data r eg i s t e r namePARAMS ( ( GcaSession ∗ s e s ) ) ;stat ic int d a t a r e g i s t e r s e t v a l u e sPARAMS ( ( GcaDataRegister ∗ reg , Result ∗ r s l t ) ) ;

intgca data read memory ( ses , addr , bu f f e r , s i z e )

GcaSession ∗ s e s ;address addr ;ubyte ∗ b u f f e r ;s i z e t s i z e ;

{int r e t v a l = FAILURE;const char op [ ] = ”−data−read−memory” ;GcaList ∗ l i s t ;Result ∗head , ∗ r s l t ;S t r ing ∗com = str ing new ( op ) ;i f ( s t r i n g a p p e n d p r i n t f

(com , ” 0x %x x 1 %d 1” , addr , s i z e ) )i f ( ! s e s s i on execute s ing l e command


{head =

r e s u l t g e t v a r i a b l e (VARIABLE (memory ) ,gca session command( s e s ) ) ;

l i s t = ( GcaList ∗) r e s u l t v a l u e ( head ) ;r e t v a l = 0 ;

A.11 gca-data.h 191

while ( l i s t && r e t v a l < s i z e ){

r s l t =( Result ∗)g c a l i s t n e x t ( ( GcaList ∗)

g c a l i s t d a t a( l i s t ) ) ;

i f ( d a t a s e t b u f f e r b y t e( b u f f e r + re tva l , r s l t ) < 0)

{r e t v a l = FAILURE;break ;

}r e t v a l ++;l i s t = g c a l i s t n e x t ( l i s t ) ;

}l i s t f r e e ( ( GcaList ∗) head , r e s u l t f r e e ) ;

}s t r i n g f r e e (com ) ;return r e t v a l ;

}

stat ic intd a t a s e t b u f f e r b y t e ( bu f f e r , r s l t )

ubyte ∗ b u f f e r ;Result ∗ r s l t ;

{int r e t v a l = FAILURE, tmp ;char ∗ s t r ;i f ( b u f f e r ){

s t r =( char ∗) g c a l i s t d a t a ( ( GcaList ∗)

r e s u l t v a l u e( r s l t ) ) ;

tmp = ( int ) s t r t o l ( s t r , NULL, 0 ) ;i f (tmp >= 0){∗ b u f f e r = ( ubyte ) tmp & 0 x f f ;r e t v a l = SUCCESS;

}



}

GcaVariable ∗g c a d a t a e v a l u a t e e x p r e s s i o n ( ses , expr )

GcaSession ∗ s e s ;char ∗ expr ;

{const char ∗op = ”−data−eva luate−exp r e s s i on ” ;GcaVariable ∗var = NULL;Result ∗ r s l t ;S t r ing ∗com , ∗quoted ;quoted = st r ing new ( expr ) ;i f ( s t r i n g q u o t e t e x t ( quoted ) ){

com = str ing new ( op ) ;i f ( s t r i n g a p p e n d p r i n t f

(com , ” %s ” , quoted−>s t r ) )i f ( s e s s i on execute s ing l e command


{r s l t =

r e s u l t g e t v a r i a b l e (VARIABLE( value ) ,gca sess ion command( s e s ) ) ;

var = var iab l e new ( ) ;va r i ab l e s e t name ( (PTR) var , expr ) ;i f ( v a r i a b l e s e t v a l u e

( (PTR) var ,( char ∗) r e s u l t v a l u e ( r s l t ) ) <

0){

g c a v a r i a b l e f r e e ( var ) ;var = NULL;

}r e s u l t f r e e ( r s l t ) ;

}s t r i n g f r e e (com ) ;

A.11 gca-data.h 193

}s t r i n g f r e e ( quoted ) ;return var ;

}

stat ic GcaDataRegister ∗d a t a r e g i s t e r n e w ( ){

return XCALLOC ( GcaDataRegister , 1 ) ;}

intgca data r eg i s t e r number ( reg )

GcaDataRegister ∗ reg ;{

return reg ? reg−>number : FAILURE;}

wordg c a d a t a r e g i s t e r v a l u e ( reg )


return reg ? reg−>value : 0 ;}

GcaList ∗gca da ta r eg i s t e r name ( ses , number )


{GcaList ∗names = s e s s i o n r e g i s t e r n a m e s ( s e s ) ;i f ( ! names ){

names = data r eg i s t e r name ( s e s ) ;s e s s i o n s e t r e g i s t e r n a m e s ( ses , names ) ;

}return number ==

ALL REGISTERS ? names : g c a l i s t n t h ( names ,( s i z e t )number ) ;

}


stat ic GcaList ∗data r eg i s t e r name ( s e s )


GcaList ∗ l i s t , ∗names = NULL, ∗new ;const char op [ ] = ”−data−l i s t −r e g i s t e r−names” ;Result ∗ r s l t ;char ∗ s t r ;i f ( ! s e s s i on execute s ing l e command


r s l t =r e s u l t g e t v a r i a b l e (VARIABLE

( register −names ) ,gca sess ion command( s e s ) ) ;

l i s t = ( GcaList ∗) r e s u l t v a l u e ( r s l t ) ;while ( l i s t ){

i f ( s t r =xstrdup ( ( char ∗)

g c a l i s t d a t a ( l i s t ) ) )i f (new = l i s t n e w ( (PTR) s t r ) ){

names = l i s t a p p e n d ( names , new ) ;l i s t = g c a l i s t n e x t ( l i s t ) ;continue ;

}else

XFREE ( s t r ) ;l i s t f r e e ( names , l i s t d a t a f r e e ) ;names = NULL;break ;

}l i s t f r e e ( ( GcaList ∗) r s l t , r e s u l t f r e e ) ;

}return names ;

}

int

A.11 gca-data.h 195

g c a d a t a r e g i s t e r g e t n u m b e r ( ses , name)GcaSession ∗ s e s ;const char ∗name ;

{int i = FAILURE;GcaList ∗ l i s t =

gca da ta r eg i s t e r name ( ses , ALL REGISTERS ) ;i f (name && l i s t ){

i = 0 ;while ( l i s t ){

i f ( ! strcmp( ( char ∗) g c a l i s t d a t a ( l i s t ) ,name ) )

break ;l i s t = g c a l i s t n e x t ( l i s t ) ;i ++;

}}

return i ;}

GcaDataRegister ∗g c a d a t a r e g i s t e r i n f o ( ses , number )


{GcaDataRegister ∗new , ∗ reg = NULL;const char op [ ] =

”−data−l i s t −r e g i s t e r−va lue s x” ;S t r ing ∗com , ∗tmp ;Result ∗ r s l t ;GcaList ∗ l i s t ;com = tmp = str ing new ( op ) ;i f ( number != ALL REGISTERS)

tmp =s t r i n g a p p e n d p r i n t f (com , ” %u” , number ) ;

i f ( ! s e s s i on execute s ing l e command( ses , s t r i n g t e x t (tmp) ,

gca command output is done ) )


{r s l t =

r e s u l t g e t v a r i a b l e (VARIABLE( register −va lue s ) ,gca sess ion command( s e s ) ) ;


new = d a t a r e g i s t e r n e w ( ) ;reg =

( GcaDataRegister ∗)l i s t a p p e n d ( ( GcaList ∗) reg ,

( GcaList ∗) new ) ;i f ( d a t a r e g i s t e r s e t v a l u e s

(new ,( Result ∗) g c a l i s t d a t a ( l i s t ) ) <

0){

g c a d a t a r e g i s t e r f r e e ( reg ) ;reg = NULL;break ;



}s t r i n g f r e e (com ) ;return reg ;

}

stat ic intd a t a r e g i s t e r s e t v a l u e s ( reg , r s l t )

GcaDataRegister ∗ reg ;Result ∗ r s l t ;

{int r e t v a l = FAILURE;i f ( reg ){

r s l t =r e s u l t v a l u e t o u i n t ( r s l t ,

A.11 gca-data.h 197

( u int ∗) & reg−>number , ”number” ) ;

r s l t =r e s u l t v a l u e t o u i n t ( r s l t ,

( u int ∗) & reg−>value , ” va lue ” ) ;

i f ( r s l t )r e t v a l = SUCCESS;


}

GcaList ∗g c a d a t a c h a n g e d r e g i s t e r s ( s e s )


GcaList ∗ l i s t , ∗new , ∗ r e g l i s t = NULL;const char op [ ] =

”−data−l i s t −changed−r e g i s t e r s ” ;Result ∗ r s l t ;char ∗ s t r ;i f ( ! s e s s i on execute s ing l e command



( changed −r e g i s t e r s ) ,



i f ( s t r =xstrdup ( ( char ∗)

g c a l i s t d a t a ( l i s t ) ) )i f (new = l i s t n e w ( (PTR) s t r ) ){

r e g l i s t =l i s t a p p e n d ( r e g l i s t , new ) ;

l i s t = g c a l i s t n e x t ( l i s t ) ;


continue ;}

elseXFREE ( s t r ) ;

l i s t f r e e ( r e g l i s t , l i s t d a t a f r e e ) ;r e g l i s t = NULL;break ;


}return r e g l i s t ;

}

intg c a d a t a r e g i s t e r c o u n t ( s e s )


GcaList ∗names = s e s s i o n r e g i s t e r n a m e s ( s e s ) ;i f ( ! names ){

names = data r eg i s t e r name ( s e s ) ;s e s s i o n s e t r e g i s t e r n a m e s ( ses , names ) ;

}return g c a l i s t l e n g t h ( names ) ;

}

voidg c a d a t a r e g i s t e r f r e e ( reg )


l i s t f r e e ( ( GcaList ∗) reg , f r e e ) ;}

A.12. gca-file.h

#ifndef GCA FILE H#define GCA FILE H 1

#include ”common . h”#include ”gca− l i s t . h”

A.12 gca-file.h 199

#include ”gca−s e s s i o n . h”

BEGIN C DECLS

extern int g c a f i l e e x ePARAMS ( ( GcaSession ∗ ses , const char ∗ x f i l e ) ) ;extern GcaList ∗ g c a f i l e s o u r c e sPARAMS ( ( GcaSession ∗ s e s ) ) ;extern const char ∗ g c a f i l e m a i nPARAMS ( ( GcaSession ∗ s e s ) ) ;

END C DECLS

#endif /∗ ! GCA FILE H ∗/


#include ”gca− f i l e . h”#include ” l i s t . h”#include ” s e s s i o n . h”#include ” s t r i n g . h”

#define NL ’ \n ’#define DOUBLE QUOTES ’ \” ’#define C FILE EXTENSION ” . c”

stat ic GcaList ∗ f i l e s o u r c e sPARAMS ( ( GcaSession ∗ s e s ) ) ;stat ic GcaList ∗ f i l e s o u r c e n a m e sPARAMS ( ( char ∗ s t r ) ) ;stat ic St r ing ∗ f i l e m a i nPARAMS ( ( GcaSession ∗ s e s ) ) ;

intg c a f i l e e x e ( ses , x f i l e )

GcaSession ∗ s e s ;const char ∗ x f i l e ;

{int r e t v a l = FAILURE;const char op [ ] = ”− f i l e −exec−and−symbols ” ;


St r ing ∗com = str ing new ( op ) ;i f ( s t r i n g a p p e n d p r i n t f (com , ” %s ” , x f i l e ) )

i f ( ! s e s s i on execute s ing l e command( ses , com−>s t r ,

gca command output is done ) )r e t v a l = SUCCESS;


}

GcaList ∗g c a f i l e s o u r c e s ( s e s )


GcaList ∗ sou r c e s = s e s s i o n s o u r c e s ( s e s ) ;i f ( ! s ou r c e s ){

sou r c e s = f i l e s o u r c e s ( s e s ) ;s e s s i o n s e t s o u r c e s ( ses , s ou r c e s ) ;

}return s ou r c e s ;

}

stat ic GcaList ∗f i l e s o u r c e s ( s e s )


GcaList ∗ sou r c e s = NULL;const char op [ ] = ” i n f o sour c e s ” ;i f ( ! s e s s i on execute s ing l e command

( ses , op , gca command output is done ) )sou r c e s =

f i l e s o u r c e n a m e s ( gca command output( gca session command

( s e s ) ) ) ;return s ou r c e s ;

}

stat ic GcaList ∗f i l e s o u r c e n a m e s ( s t r )

char ∗ s t r ;

A.12 gca-file.h 201

{GcaList ∗names = NULL, ∗new ;St r ing ∗nm = NULL;char ∗end = str , ∗ s t a r t ;do{

end = s t a r t =x s t r s t r ( end , C FILE EXTENSION ) ;

i f ( end )end += s t r l e n (C FILE EXTENSION ) ;

while ( s t a r t && ! i s s p a c e (∗ s t a r t )&& ∗ s t a r t != DOUBLE QUOTES)

s ta r t −−;i f ( end && s t a r t ){

s t a r t ++;nm =

s t r i n g n e w l e n ( s ta r t , end − s t a r t ) ;i f (nm)

i f (new =l i s t n e w ( (PTR)

xstrdup (nm−>s t r ) ) ){

names = l i s t a p p e n d ( names , new ) ;s t r i n g f r e e (nm) ;continue ;

}l i s t f r e e ( names , l i s t d a t a f r e e ) ;names = NULL;break ;

}}

while ( end ) ;return names ;

}

const char ∗g c a f i l e m a i n ( s e s )


char ∗ f i l e = NULL;


St r ing ∗ s t r ;GcaList ∗ sou r c e s = s e s s i o n s o u r c e s ( s e s ) ;i f ( ! s ou r c e s ){

sou r c e s = f i l e s o u r c e s ( s e s ) ;s e s s i o n s e t s o u r c e s ( ses , s ou r c e s ) ;

}s t r = f i l e m a i n ( s e s ) ;i f ( s t r ){

while ( s ou r c e s&& strcmp ( ( char ∗)

g c a l i s t d a t a ( sou r c e s ) ,s t r i n g t e x t ( s t r ) ) )

s ou r c e s = g c a l i s t n e x t ( sou r c e s ) ;f i l e = ( char ∗) g c a l i s t d a t a ( sou r c e s ) ;s t r i n g f r e e ( s t r ) ;

}return f i l e ;

}

stat ic St r ing ∗f i l e m a i n ( s e s )


St r ing ∗name = NULL;const char op [ ] = ” i n f o func t i on main” ;char ∗end , ∗ s t a r t ;i f ( ! s e s s i on execute s ing l e command


end =x s t r s t r ( gca command output

( gca sess ion command ( s e s ) ) ,C FILE EXTENSION ) ;

i f ( s t a r t = end )end += s t r l e n (C FILE EXTENSION ) ;

while ( s t a r t && ! i s s p a c e (∗ s t a r t ) )s t a r t −−;

i f ( end && s t a r t ){

A.13 gca-stop.h 203

s t a r t ++;name =

s t r i n g n e w l e n ( s ta r t , end − s t a r t ) ;}

}return name ;

}

A.13. gca-stop.h

#ifndef GCA STOP H#define GCA STOP H 1


BEGIN C DECLS

typedef enum{

GCA STOP REASON BREAKPOINT HIT = 0 ,GCA STOP REASON END STEPPING RANGE,GCA STOP REASON FUNCTION FINISHED,GCA STOP REASON LOCATION REACHED,GCA STOP REASON SIGNAL RECEIVED,GCA STOP REASON EXITED NORMALLY,GCA STOP REASON EXITED

} GcaStopReason ;

extern const char ∗ gca s t op r ea son ( GcaStopReasonreason ) ;

END C DECLS

#endif /∗ !GCA STOP H ∗/

#ifndef STOP H#define STOP H 1

#include ”gca−stop . h”


#include ” r e s u l t . h”

BEGIN C DECLS

extern int s t op r ea so n in dexPARAMS ( ( const char ∗ s t r ) ) ;

END C DECLS

#endif /∗ !STOP H ∗/

#include ” r e s u l t . h”#include ” stop . h”

char ∗ r ea sons [ ] = { ” breakpoint−h i t ” ,”end−stepping−range ” ,” funct ion−f i n i s h e d ” ,” l o ca t i on−reached ” ,” s i gna l−r e c e i v e d ” ,” ex i ted−normally ” ,” ex i t ed ”

} ;

const char ∗gca s t op r ea son ( reason )

GcaStopReason reason ;{

return ( reason >= 0&& reason <ARRAY SIZE ( reasons ) ) ? reasons [ reason ]

: NULL;}

ints t op r ea son index ( s t r )

const char ∗ s t r ;{

int idx = FAILURE;i f ( s t r )

for ( idx = 0 ; idx < ARRAY SIZE ( reasons ) ;

A.14 gca-program-flow.h 205

idx++)i f ( ! strcmp ( reasons [ idx ] , s t r ) )

break ;return idx ;

}

A.14. gca-program-flow.h

#ifndef GCA PROGRAM FLOW H#define GCA PROGRAM FLOW H 1

#include ”common . h”#include ”gca−s e s s i o n . h”

BEGIN C DECLS

int gca program f low cont inuePARAMS ( ( GcaSession ∗ s e s ) ) ;int g c a p r o g r a m f l o w f i n i s hPARAMS ( ( GcaSession ∗ s e s ) ) ;int gca program f low nextPARAMS ( ( GcaSession ∗ s e s ) ) ;int g c a p r o g r a m f l o w n e x t i n s t r u c t i o nPARAMS ( ( GcaSession ∗ s e s ) ) ;int gca program f low returnPARAMS ( ( GcaSession ∗ s e s ) ) ;int gca program f low runPARAMS ( ( GcaSession ∗ s e s ) ) ;int gca program f low stepPARAMS ( ( GcaSession ∗ s e s ) ) ;int g c a p r o g r a m f l o w s t e p i n s t r u c t i o nPARAMS ( ( GcaSession ∗ s e s ) ) ;int gca p rog ram f l ow unt i lPARAMS ( ( GcaSession ∗ ses , const char ∗ l o c a t i o n ) ) ;

END C DECLS

#endif /∗ !GCA PROGRAM FLOW ∗/


#include ” c a l l b a c k . h”#include ”command . h”#include ”gca−c a l l b a c k . h”#include ”gca−command . h”#include ”gca−s e s s i o n . h”#include ” r e s u l t . h”#include ” s e s s i o n . h”#include ” stop . h”

stat ic int program flow commandPARAMS ( ( GcaSession ∗ ses , const char ∗op ,

GcaCallbackType type ) ) ;stat ic int program f low asynchronous outputPARAMS ( ( GcaSession ∗ s e s ) ) ;

intgca program f low cont inue ( s e s )


const char op [ ] = ”−exec−cont inue ” ;GcaCallbackType type =

GCA CALLBACK TYPE CONTINUE;return program flow command ( ses , op , type ) ;

}

intg c a p r o g r a m f l o w f i n i s h ( s e s )


const char op [ ] = ”−exec−f i n i s h ” ;GcaCallbackType type = GCA CALLBACK TYPE FINISH;return program flow command ( ses , op , type ) ;

}

intgca program f low next ( s e s )


const char op [ ] = ”−exec−next ” ;GcaCallbackType type = GCA CALLBACK TYPE NEXT;return program flow command ( ses , op , type ) ;


}

intg c a p r o g r a m f l o w n e x t i n s t r u c t i o n ( s e s )


const char op [ ] = ”−exec−next−i n s t r u c t i o n ” ;GcaCallbackType type =

GCA CALLBACK TYPE NEXT INSTRUCTION;return program flow command ( ses , op , type ) ;

}

intgca program f low re turn ( s e s )


const char op [ ] = ”−exec−r e turn ” ;GcaCallbackType type = GCA CALLBACK TYPE RETURN;int r e t = FAILURE;i f ( ! s e s s i on execute s ing l e command

( ses , op , gca command output is running ) ){

c a l l b a c k e x e ( s e s s i o n c a l l b a c k ( s e s ) , type ) ;r e t = SUCCESS;

}return r e t ;

}

intgca program f low run ( s e s )


const char op [ ] = ”−exec−run” ;GcaCallbackType type = GCA CALLBACK TYPE RUN;return program flow command ( ses , op , type ) ;

}

intgca program f low step ( s e s )



const char op [ ] = ”−exec−s tep ” ;GcaCallbackType type = GCA CALLBACK TYPE STEP;return program flow command ( ses , op , type ) ;

}

intg c a p r o g r a m f l o w s t e p i n s t r u c t i o n ( s e s )


const char op [ ] = ”−exec−step−i n s t r u c t i o n ” ;GcaCallbackType type =

GCA CALLBACK TYPE STEP INSTRUCTION;return program flow command ( ses , op , type ) ;

}

intgca prog ram f l ow unt i l ( ses , l o c a t i o n )

GcaSession ∗ s e s ;const char ∗ l o c a t i o n ;

{const char op [ ] = ”−exec−u n t i l ” ;GcaCallbackType type = GCA CALLBACK TYPE UNTIL;int r e t = FAILURE;St r ing ∗com = str ing new ( op ) ;i f ( s t r i n g a p p e n d p r i n t f (com , ” %s ” , l o c a t i o n ) )

r e t =program flow command ( ses , com−>s t r , type ) ;


}

stat ic intprogram flow command ( ses , op , type )

GcaSession ∗ s e s ;const char ∗op ;GcaCallbackType type ;

{int r e t = FAILURE;i f ( ! s e s s i on execute s ing l e command

( ses , op , gca command output is running ) )i f ( ( r e t =


program f low asynchronous output ( s e s ) )>= 0)

c a l l b a c k e x e ( s e s s i o n c a l l b a c k ( s e s ) , type ) ;return r e t ;

}

stat ic intprogram f low asynchronous output ( s e s )


int r e t = FAILURE;Result ∗ r s l t ;GcaCommand ∗cmd = gca session command ( s e s ) ;command output read (cmd ,

s e s s i o n f i l e d e s c r i p t o r( ses , READ) ) ;

i f ( gca command output is stopped (cmd) ){

r s l t =r e s u l t g e t v a r i a b l e (VARIABLE ( reason ) ,

cmd ) ;r e t =

s top r ea son index ( ( char ∗)r e s u l t v a l u e ( r s l t ) ) ;

r e s u l t f r e e ( r s l t ) ;i f ( r e t == GCA STOP REASON SIGNAL RECEIVED){


( s i g n a l − name ) ,cmd ) ;

r e s u l t v a l u e t o c h a r p t r ( r s l t ,(PTR) ses ,s e s s i o n s e t s i g n a l r e c e i v e d ,” s i gna l−name” ) ;

r e s u l t f r e e ( r s l t ) ;}

}else i f ( gca command output i s er ror (cmd) ){

r s l t =


r e s u l t g e t v a r i a b l e (VARIABLE (msg ) , cmd ) ;r e s u l t v a l u e t o c h a r p t r ( r s l t , (PTR) ses ,

s e s s i o n s e t e r r o r ,”msg” ) ;

r e s u l t f r e e ( r s l t ) ;}

return r e t ;}

A.15. gca-variable.h

#ifndef GCA VARIABLE H#define GCA VARIABLE H 1


BEGIN C DECLS

typedef struct v a r i a b l e GcaVariable ;

extern const char ∗ gca var iab l e namePARAMS ( ( GcaVariable ∗ var ) ) ;extern const char ∗ g c a v a r i a b l e v a l u ePARAMS ( ( GcaVariable ∗ var ) ) ;extern void g c a v a r i a b l e f r e ePARAMS ( ( GcaVariable ∗ var ) ) ;

END C DECLS

#endif /∗ !GCA VARIABLE H ∗/

#ifndef VARIABLE H#define VARIABLE H 1

#include ”gca−v a r i a b l e . h”#include ” r e s u l t . h”

BEGIN C DECLS

A.15 gca-variable.h 211

extern GcaVariable ∗ var iab l e newPARAMS ( ( void ) ) ;extern int va r i ab l e s e t namePARAMS ( (PTR var , char ∗name ) ) ;extern int v a r i a b l e s e t v a l u ePARAMS ( (PTR var , char ∗ value ) ) ;extern int v a r i a b l e s e t v a l u e sPARAMS ( ( GcaVariable ∗ var , Result ∗ r s l t ) ) ;

END C DECLS

#endif /∗ !VARIABLE H ∗/

#include ”gca− l i s t . h”#include ” v a r i a b l e . h”#include ” r e s u l t . h”

struct v a r i a b l e{

struct v a r i a b l e ∗next ;char ∗name ;char ∗ value ;

} ;

stat ic void v a r i a b l e f r e e PARAMS ( (PTR var ) ) ;

GcaVariable ∗var iab l e new ( void ){

return XCALLOC ( GcaVariable , 1 ) ;}

stat ic voidv a r i a b l e f r e e ( var )

PTR var ;{

GcaVariable ∗tmp = ( GcaVariable ∗) var ;i f (tmp){

XFREE (tmp−>name ) ;


XFREE (tmp−>value ) ;XFREE (tmp ) ;

}}

const char ∗gca var iab le name ( var )

GcaVariable ∗var ;{

return var ? var−>name : NULL;}

intva r i ab l e s e t name ( var , name)

PTR var ;char ∗name ;

{GcaVariable ∗tmp = ( GcaVariable ∗) var ;i f (tmp){

XFREE (tmp−>name ) ;return (tmp−>name =

xstrdup (name ) ) ? SUCCESS : FAILURE;}

elsereturn FAILURE;

}

const char ∗g c a v a r i a b l e v a l u e ( var )


return var ? var−>value : NULL;}

intv a r i a b l e s e t v a l u e ( var , va lue )

PTR var ;char ∗ value ;

{GcaVariable ∗tmp = ( GcaVariable ∗) var ;

A.15 gca-variable.h 213

i f (tmp){

XFREE (tmp−>value ) ;return (tmp−>value =

xstrdup ( value ) ) ? SUCCESS :FAILURE;

}else

return FAILURE;}

intv a r i a b l e s e t v a l u e s ( var , r s l t )

GcaVariable ∗var ;Result ∗ r s l t ;

{int r e t v a l = FAILURE;i f ( var ){

r s l t =r e s u l t v a l u e t o c h a r p t r ( r s l t , (PTR) var ,

var i ab l e s e t name ,”name” ) ;

r s l t =r e s u l t v a l u e t o c h a r p t r ( r s l t , (PTR) var ,

v a r i a b l e s e t v a l u e ,” va lue ” ) ;



}

voidg c a v a r i a b l e f r e e ( var )


l i s t f r e e ( ( GcaList ∗) var , v a r i a b l e f r e e ) ;}


A.16. gca-argument.h

#ifndef GCA ARGUMENT H#define GCA ARGUMENT H 1

#include ”common . h”#include ”gca−v a r i a b l e . h”

BEGIN C DECLS

typedef struct argument GcaArgument ;

extern int gca argument l eve lPARAMS ( ( GcaArgument ∗ arg ) ) ;extern GcaVariable ∗ gca argument var iab l ePARAMS ( ( GcaArgument ∗ arg ) ) ;extern void gca argument f r eePARAMS ( ( GcaArgument ∗ arg ) ) ;

END C DECLS

#endif /∗ !GCA ARGUMENT H ∗/

#ifndef ARGUMENT H#define ARGUMENT H 1

#include ”gca−argument . h”#include ” r e s u l t . h”

BEGIN C DECLS

extern GcaArgument ∗argument newPARAMS ( ( void ) ) ;extern int argument se t va lue sPARAMS ( ( GcaArgument ∗ arg , Result ∗ r s l t ) ) ;

END C DECLS

#endif /∗ !ARGUMENT H ∗/

A.16 gca-argument.h 215

#include ”argument . h”#include ”gca− l i s t . h”#include ” l i s t . h”#include ” r e s u l t . h”#include ” v a r i a b l e . h”

struct argument{

struct argument ∗next ;u int l e v e l ;GcaVariable ∗var ;

} ;

stat ic void argument f ree PARAMS ( (PTR arg ) ) ;stat ic int a rgument s e t va r i ab l ePARAMS ( ( GcaArgument ∗ arg , Result ∗ r s l t ) ) ;

GcaArgument ∗argument new ( void ){

return XCALLOC ( GcaArgument , 1 ) ;}

stat ic voidargument f ree ( arg )

PTR arg ;{

GcaArgument ∗tmp = ( GcaArgument ∗) arg ;i f (tmp){

g c a v a r i a b l e f r e e (tmp−>var ) ;XFREE (tmp ) ;

}}

intgca argument l eve l ( arg )

GcaArgument ∗arg ;{

return arg ? arg−>l e v e l : FAILURE;


}

GcaVariable ∗gca argument var iab l e ( arg )


return arg ? arg−>var : NULL;}

intargument se t va lue s ( arg , r s l t )

GcaArgument ∗arg ;Result ∗ r s l t ;

{int r e t v a l = FAILURE;i f ( arg ){


r e s u l t v a l u e ( r s l t ) ,&arg−>l e v e l ,” l e v e l ” ) ;

r e t v a l = argument s e t va r i ab l e ( arg , r s l t ) ;}


stat ic inta rgument s e t va r i ab l e ( arg , r s l t )

GcaArgument ∗arg ;Result ∗ r s l t ;

{int r e t v a l = SUCCESS;GcaList ∗ l i s t ;GcaVariable ∗var ;i f ( arg && r s l t ){

arg−>var = NULL;l i s t = ( GcaList ∗) r e s u l t v a l u e ( r s l t ) ;while ( l i s t ){

A.17 gca-stack-frame.h 217

var = var iab l e new ( ) ;arg−>var =

( GcaVariable ∗)l i s t a p p e n d ( ( GcaList ∗) arg−>var ,

( GcaList ∗) var ) ;i f ( v a r i a b l e s e t v a l u e s

( var ,( Result ∗) g c a l i s t d a t a ( l i s t ) ) <

0){

g c a v a r i a b l e f r e e ( var ) ;arg−>var = NULL;r e t v a l = FAILURE;break ;


}}

elser e t v a l = FAILURE;


voidgca argument f r ee ( arg )


l i s t f r e e ( ( GcaList ∗) arg , argument f ree ) ;}

A.17. gca-stack-frame.h

#ifndef GCA STACK FRAME H#define GCA STACK FRAME H 1

#include ”common . h”#include ”gca−argument . h”#include ”gca−micro . h”#include ”gca−s e s s i o n . h”#include ”gca−v a r i a b l e . h”


BEGIN C DECLS

#define INNERMOST FRAME 0#define OUTERMOST FRAME( s e s ) \

( gca s tack f rame depth ( s e s ) − 1)#define ALL FRAMES 1024

typedef struct gcaStackFrame GcaStackFrame ;

extern int g c a s t a c k f r a m e l e v e lPARAMS ( ( GcaStackFrame ∗ s f ) ) ;extern address g ca s t a ck f r ame addr e s sPARAMS ( ( GcaStackFrame ∗ s f ) ) ;extern const char ∗ g c a s t a c k f r a m e f u n c t i o nPARAMS ( ( GcaStackFrame ∗ s f ) ) ;extern GcaVariable ∗ g c a s t a c k f r a m e a r g sPARAMS ( ( GcaStackFrame ∗ s f ) ) ;extern const char ∗ g c a s t a c k f r a m e f i l ePARAMS ( ( GcaStackFrame ∗ s f ) ) ;extern int g c a s t a c k f r a m e l i n ePARAMS ( ( GcaStackFrame ∗ s f ) ) ;extern int gca s tack f rame depthPARAMS ( ( GcaSession ∗ s e s ) ) ;extern GcaStackFrame ∗ gca s ta ck f r ame back t ra c ePARAMS ( ( GcaSession ∗ s e s ) ) ;extern GcaStackFrame ∗ g c a s t a c k f r a m e i n f oPARAMS ( ( GcaSession ∗ ses , u int l e v e l ) ) ;extern GcaArgument ∗ gca stack f rame argumentsPARAMS ( ( GcaSession ∗ ses , u int l e v e l ) ) ;extern GcaVariable ∗ g c a s t a c k f r a m e l o c a l sPARAMS ( ( GcaSession ∗ ses , u int l e v e l ) ) ;extern void g c a s t a c k f r a m e f r e ePARAMS ( ( GcaStackFrame ∗ s f ) ) ;

END C DECLS

#endif /∗ !GCA STACK FRAME H ∗/

#ifndef STACK FRAME H


#define STACK FRAME H 1

#include ”gca−command . h”#include ”gca−stack−frame . h”#include ” r e s u l t . h”

BEGIN C DECLS

extern GcaStackFrame ∗ stack frame newPARAMS ( ( void ) ) ;extern void s t a c k f r a m e f r e e PARAMS ( (PTR s f ) ) ;extern int s t a c k f r a m e s e t v a l u e sPARAMS ( ( GcaStackFrame ∗ s f , Result ∗ r s l t ) ) ;

END C DECLS

#endif /∗ !STACK FRAME H ∗/

#include ”argument . h”#include ”command . h”#include ”gca−argument . h”#include ”gca−command . h”#include ”gca−s e s s i o n . h”#include ”gca− l i s t . h”#include ”gca−micro . h”#include ”gca−v a r i a b l e . h”#include ” l i s t . h”#include ” r e s u l t . h”#include ” s e s s i o n . h”#include ” stack−frame . h”#include ” s t r i n g . h”#include ” v a r i a b l e . h”

struct gcaStackFrame{

struct gcaStackFrame ∗next ;u int l e v e l ;address addr ;char ∗ func ;GcaVariable ∗ args ;


char ∗ f i l e ;u int l i n e ;

} ;

stat ic int s t a c k f r a m e s e t f u n c t i o nPARAMS ( (PTR sf , char ∗ func ) ) ;stat ic int s t a c k f r a m e s e t f i l ePARAMS ( (PTR sf , char ∗ f i l e ) ) ;

GcaStackFrame ∗stack frame new ( ){

return XCALLOC ( GcaStackFrame , 1 ) ;}

voids t a c k f r a m e f r e e ( s f )

PTR s f ;{

GcaStackFrame ∗tmp = ( GcaStackFrame ∗) s f ;i f (tmp){

XFREE (tmp−>func ) ;g c a v a r i a b l e f r e e (tmp−>args ) ;XFREE (tmp−> f i l e ) ;XFREE (tmp ) ;

}}

intg c a s t a c k f r a m e l e v e l ( s f )

GcaStackFrame ∗ s f ;{

return s f ? s f−>l e v e l : FAILURE;}

addressg ca s t a ck f r ame addr e s s ( s f )


return s f ? s f−>addr : 0 ;


}

const char ∗g c a s t a c k f r a m e f u n c t i o n ( s f )


return s f ? s f−>func : NULL;}

stat ic ints t a c k f r a m e s e t f u n c t i o n ( s f , func )

PTR s f ;char ∗ func ;

{GcaStackFrame ∗tmp = ( GcaStackFrame ∗) s f ;i f (tmp){

XFREE (tmp−>func ) ;return (tmp−>func =

xstrdup ( func ) ) ? SUCCESS : FAILURE;}

elsereturn FAILURE;

}

GcaVariable ∗g c a s t a c k f r a m e a r g s ( s f )


return s f ? s f−>args : NULL;}

const char ∗g c a s t a c k f r a m e f i l e ( s f )


return s f ? s f−> f i l e : NULL;}

stat ic ints t a c k f r a m e s e t f i l e ( s f , f i l e )


PTR s f ;char ∗ f i l e ;

{GcaStackFrame ∗tmp = ( GcaStackFrame ∗) s f ;i f (tmp){

XFREE (tmp−> f i l e ) ;return (tmp−> f i l e =

xstrdup ( f i l e ) ) ? SUCCESS : FAILURE;}

elsereturn FAILURE;

}

intg c a s t a c k f r a m e l i n e ( s f )


return s f ? s f−>l i n e : FAILURE;}

intgca s tack f rame depth ( s e s )


const char op [ ] = ”−stack−i n fo−depth” ;Result ∗ r s l t ;u int depth = 0 ;int r e t v a l = FAILURE;i f ( ! s e s s i on execute s ing l e command


r s l t =r e s u l t g e t v a r i a b l e (VARIABLE ( depth ) ,

gca sess ion command( s e s ) ) ;

i f ( r e s u l t v a l u e t o u i n t( r s l t , &depth , ”depth” ) )

r e t v a l = ( u int ) depth ;r e s u l t f r e e ( (PTR) r s l t ) ;

}



GcaStackFrame ∗gca s ta ck f r ame back t ra c e ( s e s )


return g c a s t a c k f r a m e i n f o ( ses , ALL FRAMES) ;}

GcaStackFrame ∗g c a s t a c k f r a m e i n f o ( ses , l e v e l )

GcaSession ∗ s e s ;u int l e v e l ;

{GcaStackFrame ∗new , ∗ s f = NULL;const char op [ ] = ”−stack−l i s t −f rames ” ;Result ∗head , ∗ r s l t ;S t r ing ∗com , ∗tmp ;com = tmp = str ing new ( op ) ;i f ( l e v e l != ALL FRAMES)

tmp =s t r i n g a p p e n d p r i n t f (com , ” %u %u” , l e v e l ,

l e v e l ) ;i f ( ! s e s s i on execute s ing l e command

( ses , s t r i n g t e x t (tmp) ,gca command output is done ) )

{head = r s l t =

r e s u l t g e t v a r i a b l e (VARIABLE ( frame ) ,gca session command( s e s ) ) ;

do{

new = stack frame new ( ) ;s f =

( GcaStackFrame ∗)l i s t a p p e n d ( ( GcaList ∗) s f ,

( GcaList ∗) new ) ;i f ( s t a c k f r a m e s e t v a l u e s (new , r s l t ) <

0)


{g c a s t a c k f r a m e f r e e ( s f ) ;s f = NULL;break ;

}}



}s t r i n g f r e e (com ) ;return s f ;

}

ints t a c k f r a m e s e t v a l u e s ( s f , r s l t )

GcaStackFrame ∗ s f ;Result ∗ r s l t ;

{int r e t v a l = FAILURE;i f ( s f ){


r e s u l t v a l u e ( r s l t ) ,&s f−>l e v e l ,” l e v e l ” ) ;

r s l t =r e s u l t v a l u e t o u i n t ( r s l t , &s f−>addr ,

”addr” ) ;r s l t =

r e s u l t v a l u e t o c h a r p t r ( r s l t , (PTR) s f ,s t a c k f r a m e s e t f u n c t i o n ,” func ” ) ;

r s l t =r e s u l t v a l u e t o v a r i a b l e ( r s l t , s f−>args ,

” args ” ) ;r s l t =

r e s u l t v a l u e t o c h a r p t r ( r s l t , (PTR) s f ,s t a c k f r a m e s e t f i l e ,


” f i l e ” ) ;r s l t =

r e s u l t v a l u e t o u i n t ( r s l t , &s f−>l i n e ,” l i n e ” ) ;



}

GcaArgument ∗gca stack f rame arguments ( ses , l e v e l )


{GcaArgument ∗arg = NULL, ∗new ;char op [ ] = ”−stack−l i s t −arguments” ;Result ∗head , ∗ r s l t ;S t r ing ∗com , ∗tmp ;com = tmp = str ing new ( op ) ;i f ( l e v e l != ALL FRAMES)

tmp =s t r i n g a p p e n d p r i n t f (com , ” 1 %u %u” ,

l e v e l , l e v e l ) ;i f ( ! s e s s i on execute s ing l e command

( ses , s t r i n g t e x t (tmp) ,gca command output is done ) )

{head = r s l t =

r e s u l t g e t v a r i a b l e (VARIABLE ( frame ) ,gca session command( s e s ) ) ;

do{

new = argument new ( ) ;arg =

( GcaArgument ∗)l i s t a p p e n d ( ( GcaList ∗) arg ,

( GcaList ∗) new ) ;i f ( a rgument se t va lue s (new , r s l t ) < 0){


gca argument f r ee ( arg ) ;arg = NULL;break ;

}}



}s t r i n g f r e e (com ) ;return arg ;

}

GcaVariable ∗g c a s t a c k f r a m e l o c a l s ( ses , l e v e l )


{GcaVariable ∗new , ∗var = NULL;char op [ ] = ”−stack−l i s t −l o c a l s ” ;GcaList ∗ l i s t ;Result ∗ r s l t ;S t r ing ∗com = str ing new ( op ) ;i f ( s t r i n g a p p e n d p r i n t f

(com , ” 1 %u %u” , l e v e l , l e v e l ) )i f ( ! s e s s i on execute s ing l e command


{r s l t =

r e s u l t g e t v a r i a b l e (VARIABLE ( l o c a l s ) ,gca session command( s e s ) ) ;

l i s t = ( GcaList ∗) r e s u l t v a l u e ( r s l t ) ;do{

new = var iab l e new ( ) ;var =

( GcaVariable ∗)l i s t a p p e n d ( ( GcaList ∗) var ,

A.18 gca-target.h 227

( GcaList ∗) new ) ;i f ( v a r i a b l e s e t v a l u e s

(new ,( Result ∗) g c a l i s t d a t a ( l i s t ) )

< 0){

g c a v a r i a b l e f r e e ( var ) ;var = NULL;break ;

}}

while ( l i s t = g c a l i s t n e x t ( l i s t ) ) ;l i s t f r e e ( ( GcaList ∗) r s l t , r e s u l t f r e e ) ;

}s t r i n g f r e e (com ) ;return var ;

}

voidg c a s t a c k f r a m e f r e e ( s f )


l i s t f r e e ( ( GcaList ∗) s f , s t a c k f r a m e f r e e ) ;}

A.18. gca-target.h

#ifndef GCA TARGET H#define GCA TARGET H 1

#include ”common . h”#include ”gca−s e s s i o n . h”

BEGIN C DECLS

typedef enum{

GCA TARGET TYPE SIMULATOR = 0} GcaTargetType ;


extern int g c a t a r g e t s e l e c t t y p ePARAMS ( ( GcaSession ∗ ses , GcaTargetType type ) ) ;extern int gca ta rge t l oad programPARAMS ( ( GcaSession ∗ s e s ) ) ;extern int g c a t a r g e t s t a r t s i m u l a t o rPARAMS ( ( GcaSession ∗ s e s ) ) ;

END C DECLS

#endif /∗ !GCA TARGET H ∗/

#include ”gca−command . h”#include ”gca−t a r g e t . h”#include ” s e s s i o n . h”#include ” s t r i n g . h”

char ∗ t a r g e t s [ ] = { ”sim” } ;

intg c a t a r g e t s e l e c t t y p e ( ses , type )

GcaSession ∗ s e s ;GcaTargetType type ;

{int r e t v a l = FAILURE;const char op [ ] = ”−target−s e l e c t ” ;output handler func = gca command output is connected ;S t r ing ∗com = str ing new ( op ) ;i f ( s t r i n g a p p e n d p r i n t f

(com , ” %s ” , t a r g e t s [ type ] ) )r e t v a l =

se s s i on execute s ing l e command ( ses ,com−>s t r ,func ) ;


}

intgca ta rge t l oad program ( s e s )

GcaSession ∗ s e s ;

A.18 gca-target.h 229

{const char op [ ] = ”−target−download” ;output handler func = gca command output is done ;return s e s s i on execute s ing l e command ( ses , op ,

func ) ;}

intg c a t a r g e t s t a r t s i m u l a t o r ( s e s )


int r e t v a l = FAILURE;GcaTargetType type = GCA TARGET TYPE SIMULATOR;i f ( ! g c a t a r g e t s e l e c t t y p e ( ses , type ) )

r e t v a l = gca ta rge t l oad program ( s e s ) ;return r e t v a l ;

}

Bibliografıa

[1] MMC2107 Technical Data, Motorola Inc., 2000.

[2] Richard M. Stallman and Roland H. Pesch: Debugging with GDB, FreeSoftware Foundation, 1994

[3] Todd D. Morton: Embedded Microcontrollers, Prentice-Hall, 2001.

[4] Ted Van Sickle: Programming microcontrollers in C, 2nd ed., LLH Pu-blishing, 2001.

[5] Kurt Wall: Programacion en Linux con ejemplos, Prentice-Hall, 2000

[6] Fco. Javier Ceballos Sierra: Programacion orientada a objetos con C++,3a ed., Ra-ma, 2003.

[7] Matthias Kalle Dalheimer: Programming with Qt, 2nd ed., O’Reilly, 2002.

sistema de simulaci on para un microcontrolador...

Documents