SoloCodigo

Programación General => C/C++ => Mensaje iniciado por: jvmjunior en Sábado 23 de Mayo de 2009, 00:37

Título: Pruebas en C
Publicado por: jvmjunior en Sábado 23 de Mayo de 2009, 00:37
Hola....directo a la pregunta..

Necesito crear un codigo en C para comprobar si el sistema Operativo que utilizo genera direcciones de memoria aleatorias en la memoria montón y en la pila.

Espero su ayuda.
Gracias.
Título: Re: Pruebas en C
Publicado por: m0skit0 en Lunes 25 de Mayo de 2009, 09:40
Pues entonces comprueba el valor de los registros involucrados. Como tampoco dices sobre qué arquitectura estás trabajando, no te puedo ser más específico.
Título: Re: Pruebas en C
Publicado por: jvmjunior en Lunes 25 de Mayo de 2009, 10:38
Gracias por contestarme....

Puees, es que soy muy nuevo en esto de C...... estoy trabajando con UBUNTU 9.04, en una portatil HP pavilion dv6000, no sé si es eso lo que querés saber. Y como te digo, me han pedido que haga cualquier programilla que compruebe si el Sist Op genera direcciones aleatorias en memoria monton y en la pila, personalmente no se cual es la diferencia entre esas memorias.....

Gracias.

Junior
Título: Re: Pruebas en C
Publicado por: m0skit0 en Lunes 25 de Mayo de 2009, 11:02
Cita de: "jvmjunior"
estoy trabajando con UBUNTU 9.04, en una portatil HP pavilion dv6000
Entonces es arquitectura x86 (Intel)

Cita de: "jvmjunior"
personalmente no se cual es la diferencia entre esas memorias.....
http://en.wikipedia.org/wiki/Dynamic_memory_allocation (http://en.wikipedia.org/wiki/Dynamic_memory_allocation" onclick="window.open(this.href);return false;)
http://en.wikipedia.org/wiki/Stack_(data_structure (http://en.wikipedia.org/wiki/Stack_(data_structure" onclick="window.open(this.href);return false;))

Para comprobar valores de pila y montón

Código: C
  1. int valor_pila()
  2. {
  3.     __asm__("push %espnt"
  4.             "pop %eax");
  5. }
  6.  
  7. int valor_monticulo()
  8. {
  9.     int *p, valor;
  10.    
  11.     p = malloc(sizeof(int));
  12.     valor = (int) p;
  13.     free(p);
  14.     return valor;
  15. }
  16.  
  17. int main(int argc, char *argv[])
  18. {
  19.     printf("Valor de la pila: %pn", valor_pila());
  20.     printf("Valor del monticulo: %pn", valor_monticulo());
  21.     system("PAUSE");
  22.     return 0;
  23. }
  24.  
Título: Re: Pruebas en C
Publicado por: jvmjunior en Lunes 25 de Mayo de 2009, 11:13
Muchas gracias por contestarme....ahoramismo lo probaré el código y luego te cuento  como me fué

Saludos.
Título: Re: Pruebas en C
Publicado por: jvmjunior en Lunes 25 de Mayo de 2009, 11:34
Me salen los siguientes errores en la compilación:

junior@JuNioR-Linux:~/Escritorio/Calidad$ gcc -g memoria.c -o memoria
memoria.c: En la función ‘valor_monticulo’:
memoria.c:13: aviso: la asignación crea un puntero desde un entero sin una conversión
memoria.c:15: aviso: declaración implícita incompatible de la función interna ‘free’
memoria.c: En la función ‘main’:
memoria.c:21: aviso: el formato ‘%p’ espera el tipo ‘void *’, pero el argumento 2 es de tipo ‘int’
memoria.c:22: aviso: el formato ‘%p’ espera el tipo ‘void *’, pero el argumento 2 es de tipo ‘int’
junior@JuNioR-Linux:~/Escritorio/Calidad$ gcc -g memoria.c -o memoria
memoria.c: En la función ‘valor_monticulo’:
memoria.c:12: aviso: declaración implícita incompatible de la función interna ‘malloc’
memoria.c:14: aviso: declaración implícita incompatible de la función interna ‘free’
memoria.c: En la función ‘main’:
memoria.c:20: aviso: el formato ‘%p’ espera el tipo ‘void *’, pero el argumento 2 es de tipo ‘int’
memoria.c:21: aviso: el formato ‘%p’ espera el tipo ‘void *’, pero el argumento 2 es de tipo ‘int’

Al código q me mandaste solo le he aumentado esta linea: #include <stdio.h> .
Que podrá ser, no??
Gracias por tu atención.
Saludos.
Título: Re: Pruebas en C
Publicado por: m0skit0 en Lunes 25 de Mayo de 2009, 11:42
No son errores, son avisos...  :P

¿Seguro que lo has copiado tal cual...? A mí no me da todos esos avisos.

Además, algo cambiaste, puesto que los errores que te da la primera vez, no son los de la segunda. De todas formas, te lo ha compilado, pero no lo has probado.
Título: Re: Pruebas en C
Publicado por: jvmjunior en Lunes 25 de Mayo de 2009, 18:14
Acabo de agregarle una libreria... #include <stdlib.h>... el coódigo esta de la siguiente manera:

#include <stdio.h>
#include <stdlib.h>
 int valor_pila()
 {
     __asm__("push %espnt"
             "pop %eax");
 }
 
 int valor_monticulo()
  {
      int *p, valor;
     
      p = malloc(sizeof(int));
      valor = (int) p;
      free(p);
      return valor;
  }
   
  int main(int argc, char *argv[])
  {
      printf("Valor de la pila: %pn", valor_pila());
      printf("Valor del monticulo: %pn", valor_monticulo());
      system("PAUSE");
      return 0;
  }

Luego de compilarlo, ya solo me salen los siguientes errores ó mensajes:

junior@JuNioR-Linux:~/Escritorio/Calidad$ gcc -g memoria.c -o memoria
memoria.c: En la función ‘main’:
memoria.c:21: aviso: el formato ‘%p’ espera el tipo ‘void *’, pero el argumento 2 es de tipo ‘int’
memoria.c:22: aviso: el formato ‘%p’ espera el tipo ‘void *’, pero el argumento 2 es de tipo ‘int’

Saludos.
Título: Re: Pruebas en C
Publicado por: m0skit0 en Lunes 25 de Mayo de 2009, 18:38
Aer, te lo corrijo, aunque deberías saber cómo corregirlo tú mismo, es muy sencillo. Yo es que estoy usando MinGW (un porte de gcc para Windows) en Win2000.

Código: C
  1. int valor_pila()
  2. {
  3.     __asm__("push %espnt"
  4.             "pop %eax");
  5. }
  6.  
  7. int valor_monticulo()
  8. {
  9.     int *p, valor;
  10.    
  11.     (void *)p = malloc(sizeof(int));
  12.     valor = (int) p;
  13.     free((void *)p);
  14.     return valor;
  15. }
  16.  
  17. int main(int argc, char *argv[])
  18. {
  19.     printf("Valor de la pila: %pn", (void *)valor_pila());
  20.     printf("Valor del monticulo: %pn", (void *)valor_monticulo());
  21.     return 0;
  22. }
  23.  

De todas formas, te funciona bien, y no te falta ninguna librería porque si no no te compilaría, nene. Puedes ver que la dirección de la pila y el montículo cambia, cosa que no ocurre en mi Win 2K donde siempre son la misma. Sólo espero que hayas entendido el código, porque si te preguntan sobre ello...  :blink:  :ph34r:
Título: Re: Pruebas en C
Publicado por: jvmjunior en Lunes 25 de Mayo de 2009, 19:18
Acaba de compilar sin ningun problema con una pequeñisima modificación.....adjunto la solución definitiva..

El programita hace lo que necesito, pero no lo entiendo el código , asi que me pondré a descifrarlo por que tengo que explicarle a mi profe como lo hice.

Te estoy infinitamente agradecido, muchisimas gracias por tu atención y tu paciencia!....ojalá hubieran mas personas como vos, el mundo sería mejor!!

Saludos. :hola:  :good:  :comp:  :hitcomp:
Título: Una Cosita mas
Publicado por: jvmjunior en Lunes 25 de Mayo de 2009, 19:27
Porfavor, puedes explicarnos este código ??  :


 int valor_pila()
 {
     __asm__("push %espnt"      
             "pop %eax");
 }

Gracias.
Saludos.
Título: Re: Pruebas en C
Publicado por: m0skit0 en Martes 26 de Mayo de 2009, 10:52
Usa las etiquetas de código, colega...

Código: C
  1. int valor_pila()
  2. {
  3.     __asm__("push %espnt"
  4.     "pop %eax");
  5. }
  6.  
Suponía que no entendrías esto  ^_^

Hay que tener en cuenta que el código en C primero se pasa a ensamblador y posteriormente se ensambla y enlaza. Si quieres ver el código en ensamblador correspondiente, usa el modificador -S con gcc. Con la función __asm__() lo que estamos diciéndole al compilador de C es que no compile la cadena que vaya dentro de ella, sino que simplemente la pase tal cual al ensamblador. Con ello ejecutamos código en ensamblador desde C.

Luego hay que entender ciertos aspectos internos de las CPU Intel. Éstas usan un registro llamado ESP para apuntar al elemento más alto de la pila. Ésta función devuelve el valor de ese registro (puedes ver %esp). También existe el registro EAX, que es dónde las funciones guardan el valor de retorno. Por ejemplo, cuando haces return 0;, en realidad la CPU pone un cero en el registro EAX antes de volver de la función.

Por tanto nuestro código en ensamblador es:

Código: ASM
  1. push %esp
  2. pop %eax
  3.  
La instrucción push inserta un elemento en la pila y la instrucción pop saca un elemento de la pila. Estas instrucciones se encargan internamente de cargar/salvar el valor de/en la pila en el registro correspondiente y modificar ESP para que apunte al siguiente valor. Entonces metemos el valor del registro ESP en la pila y luego sacamos ese mismo valor en EAX, así ya lo tenemos incluso como valor de retorno, así que finalizamos directamente la función.

Para los curiosos: no hemos hecho

Código: ASM
  1. mov %eax,%esp
  2.  
porque la instrucción mov en los procesadores x86 no acepta un registro de segmento como operando. Así que tenemos que recurrir al truco de la pila.
Título: Re: Pruebas en C
Publicado por: jvmjunior en Martes 26 de Mayo de 2009, 16:27
Perfecto....espero algun dia devolverte el favor.... sos muy bueno..


Muchas Gracias.

Saludos. :beer:  :good: