BloodSharp gracias por la sugerencia pero si, tendria que ser en C puro. De igual forma no podria ser una funcion lambda. Tendria que ser una funcion anidada "practicamente" a bajo nivel.
Es decir, que
int foo()
{
// ...
int subf()
{
return 0;
}
// ...
subf();
// ...
}
se compile a
foo:
; ...
subf:
mov rax, 0
ret
; ...
call subf
; ...
ret
RayR realmente era una forma de hacer lo que pretendia hacer. Ya halle otra manera, al final no me fue necesario usar funciones anidadas.
Mi problema vino con problematicas al generar codigo PIC con GCC justamente. da problemas cuando utilizas punteros a funciones e iba a intentar implementar la funcion como anidada a ver si asi el compilador cargaba el desplazamiento.
Por alguna razon, al hacer:
int (*__ptr__foo)();
__ptr__foo = &foo;
al intentar hacer cosas con __ptr__foo me di cuenta que el compilador simplemente omite las lineas que lo incluyen. Es decir, si hago algo como:
int (*__ptr__foo)();
__ptr__foo = &foo;
mostrar(__ptr__foo);
(
mostrar seria una funcion hipotetica. Para poner mejor en contexto cabe mencionar que no estoy enlazando ninguna libreria estandar o no estandar)
lo que me muestra es:
... $ ./main
0
es decir, o no lo incluye, o cuando se le requiere lo "optimiza" como 0.
la verdad no se por que ocurre.
lo que hice para solucionarlo fue un poco sucio. Cree una funcion llamada get_ptr:
void *get_ptr()
{
return __ptr__foo;
}
que se compila a:
get_ptr:
mov rax, 0
ret
(porque como digo, siempre interpreta punteros a funciones (locales, ojo, es decir, dentro del scope. Porque luego puedo apuntar a alguna API o syscall y la ejecuta con exito)
y lo que hice fue un programa que carga el .asm en memoria y reemplaza
get_ptr:
mov rax, 0
ret
por
get_ptr:
mov rax, foo
ret
ya se, una solucion medio barata pero no se me ocurre otra cosa
Comento el contexto por si a alguien le interesara aconsejar alguna practica mas eficiente/limpia o cualquier otro bonito adjetivo xd
Autor
En línea
