cómo rastrear llamada de función en C?

Question

Sin modificando el código fuente, cómo puedo rastrear qué funciones se llaman y con qué parámetros, cuando se invoca alguna función (digamos func100 en el siguiente ejemplo). Me gustaría que la salida sea la siguiente:

enter func100(p1001=xxx,p1002=xxx) 
     enter func110(p1101=xxx,p1102=xxx) 
     exit func110(p1101=xxx,p1102=xxx) 
     enter func120(p1201=xxx,p1202=xxx,p1203=xxx) 
       enter func121(p1211=xxx) 
       exit func121(p1211=xxx) 
     exit func120(p1201=xxx,p1202=xxx,p1203=xxx) 
exit func100(p1001=xxx,p1002=xxx) 

¿es esto factible? o ¿cuál es la solución con una modificación mínima del código fuente?

Answer 1

Si estuvo en linux, callgrind podría ayudar. Básicamente recopila estadísticas de lo que estás buscando, por lo que podría proporcionar una forma de acceder a sus datos brutos.

Answer 2

Puede ver en log4cxx, un proyecto alojado por la fundación apache. Sé que log4j, la variante de Java le permitió establecer la sensibilidad, y puede rastrear cada cosa que se hizo en el programa. Tal vez la variante de C++ sea la misma, pero hay varias alternativas: hay un compilador de C++ orientado a los aspectos, y puede definir un aspecto en todas las funciones y hacer que capture e imprima las variables. Otra alternativa es usar un depurador.

En resumen: depurador, log4cxx o AOP

Answer 3

Si utiliza gcc, se puede usar la bandera -finstrument-functions compilación. Agrega un código que llama a dos funciones, __cyg_profile_func_enter y __cyg_profile_func_exit, siempre que una función entre/salga.

Tendrá que implementar estas funciones, para hacer lo que quiera. Asegúrese de compilarlos sin la bandera, o con attribute((no_instrument_function)), para que no intenten llamarse a sí mismos.

El segundo parámetro de las funciones sería un puntero al sitio de la llamada (es decir, la dirección de retorno dentro de la función de llamada). Puede imprimirlo con %p, pero será algo difícil de usar. Puede usar nm para descubrir la función real que contiene esta dirección.

No puede obtener los parámetros de la función de esta manera.

Answer 4

Con la Biblioteca GNU C, puede usar el módulo backtrace. Este es un ejemplo de eso:

#include <stdio.h> 
#include <execinfo.h> 
#include <stdlib.h> 


void handler(char *caller) { 
    void *array[10]; 
    size_t size; 
    printf("Stack Trace Start for %s\n",caller); 
    size = backtrace(array, 10); 
    backtrace_symbols_fd(array, size, 2); 
    printf("Stack Trace End\n"); 
} 

void car() { 
    handler("car()"); 
    printf("Continue Execution"); 
} 
void baz() {car(); } 

void bar() { baz(); } 
void foo() { bar(); } 


int main(int argc, char **argv) { 
    foo(); 
} 

compilar con la opción de compilador -g -rdynamic para cargar los símbolos

gcc -g -rdynamic Test1.c -o Test 

verá una salida similar a

Stack Trace Start for car() 
./Test(handler+0x2d)[0x80486f1] 
./Test(car+0x12)[0x804872e] 
./Test(baz+0xb)[0x8048747] 
./Test(bar+0xb)[0x8048754] 
./Test(foo+0xb)[0x8048761] 
./Test(main+0xb)[0x804876e] 
/lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xe7)[0x126e37] 
./Test[0x8048631] 
Stack Trace End 
Continue Execution in car 

Puede escribir esta función de controlador y llame desde cualquier lugar de su programa en cualquier momento. Recuerde aumentar el tamaño de array según sea necesario.

Answer 5

Utilice un depurador para establecer puntos de interrupción con acciones asociadas. Por ejemplo, en gdb puede establecer un punto de interrupción al principio y al final de cada una de las funciones que desea rastrear. Usted puede dar a cada uno de esos puntos de interrupción de un comando a ejecutar, tales como:

printf("Enter func100(p1001=%d, p1002=%d)", p1001, p1002) 

Entonces, cuando se ejecuta el programa (en el depurador) que va a imprimir el texto de cada uno de sus comandos, junto con los parámetros asociados .

Eche un vistazo a relevant documentation for gdb.

Answer 6

A veces tengo que rastrear muchas llamadas a funciones, incluso para bibliotecas externas que no tengo ningún control, o no quiero modificar.

Hace algún tiempo, me di cuenta de que puedes combinar los puntos de interrupción de expresión regular de gdb (los normales también están bien) y luego ejecutar un conjunto de comandos cada vez que se activan esos puntos de interrupción. Ver: http://www.ofb.net/gnu/gdb/gdb_35.html

Por ejemplo, si desea realizar un seguimiento de todas las funciones que comienzan con "MPI_" prefijo, que puede hacer:

(gdb) rbreak MPI_ 
[...] 
(gdb) command 1-XX 
(gdb) silent 
(gdb) bt 1 
(gdb) echo \n\n 
(gdb) continue 
(gdb) end 

orden silenciosa se utiliza para ocultar los mensajes de GDB Cuando se encuentra un punto de interrupción . Normalmente imprimo un par de líneas vacías, para que sea más fácil de leer.

Entonces, simplemente ejecutar el programa: (BGF) corren

Una vez que el programa comienza a funcionar, el BGF imprimirá las más altas de N niveles backtrace.

#0 0x000000000040dc60 in MPI_Initialized@plt() 


#0 PMPI_Initialized (flag=0x7fffffffba78) at ../../src/mpi/init/initialized.c:46 


#0 0x000000000040d9b0 in MPI_Init_thread@plt() 


#0 PMPI_Init_thread (argc=0x7fffffffbe78, argv=0x7fffffffbde0, required=3, provided=0x7fffffffba74) at ../../src/mpi/init/initthread.c:946 


#0 0x000000000040e390 in MPI_Comm_rank@plt() 


#0 PMPI_Comm_rank (comm=1140850688, rank=0x7fffffffba7c) at ../../src/mpi/comm/comm_rank.c:53 


#0 0x000000000040e050 in MPI_Type_create_struct@plt() 


#0 PMPI_Type_create_struct (count=3, array_of_blocklengths=0x7fffffffba90, array_of_displacements=0x7fffffffbab0, array_of_types=0x7fffffffba80, newtype=0x69de20) at ../../src/mpi/datatype/type_create_struct.c:116 


#0 0x000000000040e2a0 in MPI_Type_commit@plt() 


#0 PMPI_Type_commit (datatype=0x69de20) at ../../src/mpi/datatype/type_commit.c:75 

Si desea información más detallada, la impresión de las variables locales de un punto de interrupción dada es también posible, basta con insertar más comandos entre command y end.

Consejo adicional: agregue todos estos a su archivo .gdbinit y canalice la ejecución en un archivo.