Uso del depurador de M3gdb

Uso de m3gdb para ver el valor y tipo de variables

Uso del depurador para ver estadsticas del tiempo de
ejecucin.
Uso del depurador para alterar el varlor de los
parametros de la ejecucion en proceso.
Algunos comandos de ayuda durante

Modula-3

Modula-3 es un lenguaje de programacion orientado

objetos, caracterizado por su descendencia de
lenguajes de la familia Pascal; tiene excepciones,
hilos y recoleccion automatica de basura; la
equivalencia de tipos es de tipo estructural.
Es usado actualmente en la enseanza de la
programacion y mas exactamente durante los aos
90.
Aun en dia, se piensa en varias Universidades como
la alternativa preferida a la familia de lenguajes C.

m3gdb

La version del depurador para Modula-3 fue hecha en

las pimeras versiones en SRC (Systems Research
Center) basado en el deuprador gnud e la FSF. El
entorno de Modula-3 fue concebido con las
capacidades de usar codigo intermedio capaz de ser
portable a lenguaje de maquina de distintas
arquitecturas, con poca dificultad transportable a otras
arquitecturas.
inicialmente se tenia cuenta de 25 plataformas que
pueden correr el sistema de Modula-3.

Entrando a m3gdb

En la consola introducimos el nombre del depurador

Requerimientos m3gdb
Se debe contar con las librerias de tiempo de ejecucion si el ejecutable fue compilado
dinamicamente.

Se debe cargar el ejecutable (con lista de simbolos) y

tener listo la ubicacion de la(s) fuente(s).
m3gdb tiene como directorio de trabajo el actual desde donde
es llamado.

Puntos de parada (BreakPoint)

Podemos marcar cualquier linea para parar alli el

programa.
El primer breakpoint debe marcarse especificamente
en el archivo de codigo fuente que le pertenece al
ejecutable
En este caso debemos marcar la primera linea del
cuerpo del Modulo principal

Adicion y eliminacion de puntos

breakpoint

En otra corrida de m3gdb:

Informacion de la implementacion de
Modula-3

Con el comando info, se pide informacion y ayuda

sobre comandos del depurador. Tenemos la
posibilidad de consultar la informacion del
complador usado para producir el ejecutable, que
para este caso se identifica que el compilador es
cm3.

Arrancando el proceso
(m3gdb) start
No symbol "RTLinker__RunMainBody" in current context.
Function "RTLinker__RunMainBody" not defined.
Make breakpoint pending on future shared library load? (y or [n]) y
Breakpoint 2 (RTLinker__RunMainBody) pending.
Starting program: /home/danielb/as207/code/m3gdb/LINUXLIBC6/Main
Signal
Stop
Print Pass to program Description
SIG64
No
No Yes
Real-time event 64
[Thread debugging using libthread_db enabled]
[New Thread -1220450624 (LWP 23315)]

La seal SIG64 es pasada silenciosamente por encima para

que el programa no se interumpa

Llegada a los puntos de parada

Viendo los tipos de dato las variables

Breakpoint 1, multiplicar (a=5, b=8) at Main.m3:15

10
PROCEDURE multiplicar(a,b: INTEGER): INTEGER=
#0 multiplicar (a=5, b=8) at Main.m3:15
10
PROCEDURE multiplicar(a,b: INTEGER): INTEGER=
(m3gdb) ptype a
type = INTEGER
(m3gdb) ptype b
type = INTEGER
(m3gdb)

Viendo el codigo fuente

Program exited normally.
(m3gdb) list Main.m3:25
20 BEGIN
21
22
SIO.PutText("Entre dos enteros");
23
varA:=SIO.GetInt();
24
varB:=SIO.GetInt();
25
varC:=multiplicar(varA,varB);
26
SIO.PutText("Estadisticas del Heap");
27
RTHeapDebug.CheckHeap();
28 (*
RTHeapStats.ReportReachable();*)
29 (*
RTutils.Heap(FALSE,RTutils.HeapPresentation.ByTypecode,TRUE,LAST(CARDINA
L));*)

Llamadas a procedimientos

Si en los modulos importados por el programa, se pueden

llamar funciones de ellos, afectando el estado del
programa y su sistema de ejecucion (librerias).
Ejecutamos usando:
call <NombreModulo>.<NombreFuncion<(Params)>>

m3browser
RTutils.Heap(TRUE,RTutils.HeapPresentation.ByTypecode,TRUE,100)

Mostrar tipos sin instancias

Ordenar por codigo de tipo
Mostar jerarquia de tipos
Cantidad Maxima a mostrar

La cantidad de objetos de
tipo RTHooks.ChatBuffer es
4

La cantidad de objetos de
tipo RTHooks.ChatBuffer es
23, ha cambiado entre las
dos llamadas

RTHeapStats.ReportReachable

Esta funcion nos dice cuantos objetos son usables

(alcanzables) actualmente en el programa
Los organzia por Modulo, Stack del hilo ()

RTHeapStats.showReachable()

HEAP: 0xb7480000 .. 0xb74c0000 => 0.2 Mbytes

Threads: 1
Module globals:
# objects # bytes unit
--------- -------- ----------------11 16656 Stdio.i3
3
4168 SIO.m3
3
3108 RTHeapStats.m3
2
2516 RTutils.m3
13
264 Atom.m3
1
212 RTHeapDebug.m3
6
192 ThreadPThread.m3
4
64 ProcessPosix.m3
1
16 RTDebug.m3
1
16 DragonInt.m3
1
12 RegularFile.i3
1
12 FS.i3
1
12 Pipe.i3
1
12 FSPosix.m3
1
12 Terminal.i3

Global variable roots: variables globales

# objects # bytes
ref type
location
--------- -------- ---------- ----------------- -----------------------3 4168 0xb7480cd4 FileRd.T
SIO.m3 + 56
3 4168 0xb7480cd4 FileRd.T
Stdio.i3 + 52
3 4168 0xb7481d0c FileWr.T
Stdio.i3 + 56
3 4168 0xb7483010 FileWr.T
Stdio.i3 + 60
3 4168 0xb7485010 FileWr.T
Stdio.i3 + 64
2 2516 0xb74801a8 RTutils.Visitor RTutils.m3 + 312
1 1036 0xb7487040 <anon type>
RTHeapStats.m3 + 240
1 1036 0xb748744c <anon type>
RTHeapStats.m3 + 244
1 1036 0xb7487858 <anon type>
RTHeapStats.m3 + 248
12
248 0xb7480b8c Atom.NewAtomTbl Atom.m3 + 188
1
212 0xb74800d4 RTHeapDebug.WRList RTHeapDebug.m3 + 204
3
148 0xb748004c <anon type>
ThreadPThread.m3 + 580
1
16 0xb74800c4 Thread.Mutex
RTDebug.m3 + 56
1
16 0xb7480004 Thread.Mutex
ThreadPThread.m3 + 84
1
16 0xb74800a8 Thread.Mutex
ThreadPThread.m3 + 840
1
16 0xb7480b7c Thread.Mutex
Atom.m3 + 184
1
16 0xb7480c94 Thread.Mutex
ProcessPosix.m3 + 176
1
16 0xb7480ca4 Terminal.T
ProcessPosix.m3 + 184
1
16 0xb7480cb4 Terminal.T
ProcessPosix.m3 + 188
1
16 0xb7480cc4 Terminal.T
ProcessPosix.m3 + 192

Thread stacks (conservative page scan):

Objetos variables locales por stack (por hilo)
# objects # bytes thread [stack bounds]
--------- -------- ------------------------------8
7272 T.0 [0xbfeef7c8 .. 0xbfeef864]

# objects # bytes thread [stack bounds]

--------- -------- ------------------------------4 3116 T.0 [0xbfeef7c8 .. 0xbfeef864]

# objects # bytes thread [stack bounds]

--------- -------- ------------------------------46
6964 T.0 [0xbfeef7c8 .. 0xbfeef864]

Thread stack roots (optimistic):

local variables on the stack of each thread
# objects # bytes
ref type
location
--------- -------- ---------- ----------------- -----------------------1
8 0xb7487c64 RTHooks.RefInt
register in T.0
# objects # bytes
ref type
location
--------- -------- ---------- ----------------- -----------------------1
8 0xb7488c28 RTHooks.RefInt
register in T.0
# objects # bytes
ref type
location
--------- -------- ---------- ----------------- -----------------------1
8 0xb7489b30 RTHooks.RefInt
register in T.0

Thread stack roots (conservative page scan):

# objects # bytes
ref type
location
--------- -------- ---------- ----------------- -----------------------8
7272 0xb7487c64 RTHooks.RefInt sp+36 in T.0
8
7272 0xb7487c60 ?
sp+48 in T.0
8
7272 0xb7487c64 RTHooks.RefInt register in T.0
# objects # bytes
ref type
location
--------- -------- ---------- ----------------- -----------------------4
3116 0xb7488c28 RTHooks.RefInt sp+36 in T.0
4
3116 0xb7488c24 ?
sp+48 in T.0
4
3116 0xb7488c28 RTHooks.RefInt register in T.0
# objects # bytes
ref type
location
--------- -------- ---------- ----------------- -----------------------46 6964 0xb7489b30 RTHooks.RefInt sp+36 in T.0
46 6964 0xb7489b2c ?
sp+48 in T.0
46 6964 0xb7489b30 RTHooks.RefInt register in T.0

Thread stack dumps with references that reach at least:

1024 bytes under the optimistic scan or
3636 bytes under the conservative scan.

1024 bytes under the optimistic scan or

1558 bytes under the conservative scan.

1024 bytes under the optimistic scan or

3482 bytes under the conservative scan.

Thread T.0 stack [0xbfeef7c8 .. 0xbfeef864]

stack optimistic conservative
offset #objs # bytes #objs # bytes ref
------ ----- ------- ----- ------- -----------44
[PC 0xb76611e8] DumpStack + 1309 in RTHeapStats.m3
92
[PC 0xb766e684] PutChar + 12 in RTIO.m3
132
[PC 0x80489bd] Main_M3 in Main.m3
156
[PC 0xb7660c22] DumpStacks + 499 in RTHeapStats.m3
offset #objs # bytes #objs # bytes ref
------ ----- ------- ----- ------- -----------12
[PC 0xb766e922] PutText + 12 in RTIO.m3
44
[PC 0xb76611e8] DumpStack + 1309 in RTHeapStats.m3
92
[PC 0xb766e684] PutChar + 12 in RTIO.m3
132
[PC 0x80489bd] Main_M3 in Main.m3
156
[PC 0xb7660c22] DumpStacks + 499 in RTHeapStats.m3
offset #objs # bytes #objs # bytes ref
------ ----- ------- ----- ------- -----------12
[PC 0xb766e922] PutText + 12 in RTIO.m3
44
[PC 0xb76611e8] DumpStack + 1309 in RTHeapStats.m3
92
[PC 0xb766e684] PutChar + 12 in RTIO.m3
132
[PC 0x80489bd] Main_M3 in Main.m3
156
[PC 0xb7660c22] DumpStacks + 499 in RTHeapStats.m3

Salida normal de m3gdb

Program exited normally.
(m3gdb)