Charla de presentación del Aula de Software Libre de la UCO para el curso 2014/2015

1. ¿Por qué no funciona mi
práctica?
Aprende a usar el depurador de C: GDB
by @sgomez

2. ¿Quién soy?

3. ¿Quién soy?
Sergio Gómez @sgomez

5. KEEP
CALM
AND
SEGMENTATION
FAULT

6. KEEP
CALM
AND
AVOID
SEGMENTATION
FAULT

7. ¿Cómo se produce un Segmentation Fault?
Básicamente al acceder a una zona de memoria
a la que no tenemos acceso.

8. ¿Cómo se produce un Segmentation Fault?
Acceso a memoria de solo lectura
int main(void)
{
char *s = "hello world";
*s = 'H'; // Segfault
}

9. ¿Cómo se produce un Segmentation Fault?
Acceso a memoria de solo lectura
int main(void)
{
char s[] = "hello world";
*s = 'H'; // OK
}

10. ¿Cómo se produce un Segmentation Fault?
Referencias a punteros nulos
int main(void)
{
int *ptr = NULL;
printf("%d", *ptr); // Segfault
}

11. ¿Cómo se produce un Segmentation Fault?
Desbordamiento de buffer
int main(void)
{
char A[8] = "";
unsigned short B = 1979;
strcpy(A, "excessive");
}

12. ¿Cómo se produce un Segmentation Fault?
Desbordamiento de buffer
int main(void)
{
char A[8] = "";
unsigned short B = 1979;
strcpy(A, "excessive");
}

13. ¿Cómo se produce un Segmentation Fault?
Desbordamiento de pila
int main(void)
{
main();
return 0;
}

14. int main(void)
{
char *ptr = (char *) malloc (sizeof(char) * 4);
}
¿Cuál es el tamaño en bytes del bloque de
memoria reservado para ptr?
4 bytes 5 bytes (4 + ‘/0’)
Más de 5 Ninguna es correcta

15. int main(void)
{
char *ptr = (char *) malloc (sizeof(char) * 4);
}
¿Cuál es el tamaño en bytes del bloque de
memoria reservado para ptr?
5 bytes (4 + ‘/0’)
Más de 5

16. int main(void)
{
char *ptr = (char *) malloc (sizeof(char) * 4);
}
¿Cuál es el tamaño en bytes del bloque de
memoria reservado para ptr?
Más de 5

17. Empezamos… ¡Tenemos un bug!

20. function keep_calm() {
printf (“KEEPn”);
printf (“CALMn”);
printf (“ANDn”);
keep_calm();
}

21. Razones para no usar
printf

22. Razones para no usar
printf
1) No es una herramienta de depuración

23. Razones para no usar
printf
1) No es una herramienta de depuración
2) Nos obliga a ir probando para acotar el fallo

24. Razones para no usar
printf
1) No es una herramienta de depuración
2) Nos obliga a ir probando para acotar el fallo
3) Nos puede engañar

25. int mi_funcion(int *array, char *array2) {
asdasdksdsajdhljkdhsdhasdSDasd
asdasdasdasdsadaddssadsadsadsdas
asdasdasdsadSDSDsdasdasdsad
daSDSADASDASDDDSDSADJKSHDKLJKSAHDJHJADHASD
ASDHASJDHKJASDHASKJDHAS
DASDJÑASKLDJAKSLDJÑALSKDJÑASKLDJASKDJAKSDJÑALSD
ASDÑKASDJÑLKASDJÑASKDJ
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
ASDKJÑDKLJasñkdljsñkdjasñkld
askljdskaidsajdksdjsakdñad
}

26. int mi_funcion(int *array, char *array2) {
asdasdksdsajdhljkdhsdhasdSDasd
printf(“A”);
asdasdasdasdsadaddssadsadsadsdas
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
daSDSADASDASDDDSDSADJKSHDKLJKSAHDJHJADHASD
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
DASDJÑASKLDJAKSLDJÑALSKDJÑASKLDJASKDJAKSDJÑALSD
ASDÑKASDJÑLKASDJÑASKDJ
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
ASDKJÑDKLJasñkdljsñkdjasñkld
askljdskaidsajdksdjsakdñad
}

28. bash$ gcc code.c -o code

29. bash$ gcc code.c -o code
bash$ ./code

30. bash$ gcc code.c -o code
bash$ ./code
AB

31. bash$ gcc code.c -o code
bash$ ./code
AB
Segmentation fault.

32. bash$ gcc code.c -o code
bash$ ./code
AB
Segmentation fault.
bash$

33. bash$ gcc code.c -o code
bash$ ./code
AB
Segmentation fault.
bash$
¿Dónde está el fallo?
Entre A y B Entre B y C
Entre C y D Ninguna es correcta
int mi_funcion(int *array,
char *array2) {
printf(“A”);
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
askljdskaidsajdksdjsakdñad
}

34. bash$ gcc code.c -o code
bash$ ./code
AB
Segmentation fault.
bash$
¿Dónde está el fallo?
Entre C y D Ninguna es correcta
int mi_funcion(int *array,
char *array2) {
printf(“A”);
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
askljdskaidsajdksdjsakdñad
}

35. bash$ gcc code.c -o code
bash$ ./code
AB
Segmentation fault.
bash$
¿Dónde está el fallo?
Ninguna es correcta
int mi_funcion(int *array,
char *array2) {
printf(“A”);
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
askljdskaidsajdksdjsakdñad
}

36. printf usa el canal stdout
int mi_funcion(int *array,
char *array2) {
printf(“A”);
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
askljdskaidsajdksdjsakdñad
}
Buffer
Consola

37. printf usa el canal stdout
int mi_funcion(int *array,
char *array2) {
printf(“A”);
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
askljdskaidsajdksdjsakdñad
}
Buffer
Consola
A

38. printf usa el canal stdout
int mi_funcion(int *array,
char *array2) {
printf(“A”);
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
askljdskaidsajdksdjsakdñad
}
Buffer
Consola
A B

39. printf usa el canal stdout
int mi_funcion(int *array,
char *array2) {
printf(“A”);
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
askljdskaidsajdksdjsakdñad
}
Buffer
Consola
A B

40. printf usa el canal stdout
int mi_funcion(int *array,
char *array2) {
printf(“A”);
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
askljdskaidsajdksdjsakdñad
}
Buffer
Consola
A
B

41. printf usa el canal stdout
int mi_funcion(int *array,
char *array2) {
printf(“A”);
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
askljdskaidsajdksdjsakdñad
}
Buffer
Consola
A
B
C

42. printf usa el canal stdout
int mi_funcion(int *array,
char *array2) {
printf(“A”);
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
askljdskaidsajdksdjsakdñad
}
Buffer
Consola
A
B
C D

43. printf usa el canal stdout
int mi_funcion(int *array,
char *array2) {
printf(“A”);
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
askljdskaidsajdksdjsakdñad
}
Buffer
Consola
A
B
C D

44. printf usa el canal stdout
int mi_funcion(int *array,
char *array2) {
printf(“A”);
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
askljdskaidsajdksdjsakdñad
}
Buffer
Consola
A
B
C D

45. printf usa el canal stdout
int mi_funcion(int *array,
char *array2) {
printf(“A”);
asdasdasdsadSDSDsdasdasdsad
printf(“B”);
ASDHASJDHKJASDHASKJDHAS
printf(“C”);
sadkjadsÑKLjdsadkalsdjñlaskjdñaskldjñalS
printf(“D”);
askljdskaidsajdksdjsakdñad
}
Buffer
Consola
A
B
Segmentation fault.

46. Para depuración se usa el
canal stderr

47. Para depuración se usa el
canal stderr
fprintf(stderr, …)

48. Razones para no usar
printf
1) No es una herramienta de depuración
2) Nos obliga a ir probando para acotar el fallo
3) Nos puede engañar

49. Razones para no usar
fprintf
1) No es una herramienta de depuración
2) Nos obliga a ir probando para acotar el fallo
3) Nos puede engañar

50. Ahora sí… gdb

51. #include <stdlib.h>
#include <stdio.h>
int main (int argc, char* argv[])
{
int *s = NULL;
printf("A");
printf("B");
printf("%d", *s);
printf("C");
printf("D");
return 0;
}

53. bash$ gcc code.c -o code
bash$ ./code
Segmentation fault.
bash$

55. bash$ gcc code.c -o code -g

56. bash$ gcc code.c -o code -g
bash$ ./code

57. bash$ gcc code.c -o code -g
bash$ ./code
Segmentation fault.

58. bash$ gcc code.c -o code -g
bash$ ./code
Segmentation fault.
bash$ gdb code

59. bash$ gcc code.c -o code -g
bash$ ./code
Segmentation fault.
bash$ gdb code
(gdb) run
Program received signal SIGSEGV, Segmentation fault.

60. bash$ gcc code.c -o code -g
bash$ ./code
Segmentation fault.
bash$ gdb code
(gdb) run
Program received signal SIGSEGV, Segmentation fault.
0x08048439 in main (argc=1, argv=0xffffd364) at code.c:9

61. bash$ gcc code.c -o code -g
bash$ ./code
Segmentation fault.
bash$ gdb code
(gdb) run
Program received signal SIGSEGV, Segmentation fault.
0x08048439 in main (argc=1, argv=0xffffd364) at code.c:9
9 printf("%d", *s);

62. Órdenes usuales
- l, list Muestra las líneas de código
- b, break Crea un breakpoint
- d, delete Borra un breakpoint
- clear Borra uno o varios breakpoints
- info b Muestra la lista de breakpoints
- c, continue Continúa la ejecución
- n, next Ejecuta la siguiente línea
- s, step Como next pero entra en subrutinas
- display Muestra una expresión por parada
- print Muestra una expresión
- bt, where Muestra pila funciones (backtrace)
- set Asigna un valor a una variable

63. ¿Verdadero o Falso?
Verdadero Falso
int main(int argc, char const *argv[])
{
if ( 0.1 + 0.2 == 0.3 ) {
puts ("Verdadero");
} else {
puts ("Falso");
}
return 0;
}
Segmentation Fault Ninguna es correcta

64. ¿Verdadero o Falso?
Falso
int main(int argc, char const *argv[])
{
if ( 0.1 + 0.2 == 0.3 ) {
puts ("Verdadero");
} else {
puts ("Falso");
}
return 0;
}

65. Consejos
- Siempre inicializar las variables. SIEMPRE.
int i = 0;
for (i = 0; i < 10; i++);
- Usar calloc mejor que malloc.
int *ptr = (int *) malloc (sizeof(int) * 15);
int *ptr = (int ) calloc (15, sizeof(int));

66. Consejos- Código limpio, máximo 80 caracteres por linea.
printf(“%s %s %s”, game->player[1]->score, game-
>player[1]->highscore, game->player[1]->name);
printf(“%s %s %s”,
game->player[1]->score,
game->player[1]->highscore,
game->player[1]->name
);
- En las comparaciones, las constantes primero
if (variable = 6) {} // Compila
if (6 = variable) {} // No compila
if (6 == variable) {} // Correcto

67. ¿Por qué no funciona mi
práctica?
Aprende a usar el depurador de C: GDB
by @sgomez