primer - taylor swift reputation producer
¿En qué idioma está escrito Swift? (3)
Bueno, como dice el título, ¿en qué idioma está escrito Swift ( Apple lenguaje de Apple , no el otro Swift)? Más específicamente, en qué está escrito el compilador. ¿Está escrito en C (como en cualquier otro idioma) o en algún otro Súper Lenguaje mágico, desconocido hasta ahora? ¿O es alguna extraña versión recursiva, ajustada al arranque de Swift? La web es extrañamente tranquila en este tema.
El código fuente acaba de estar disponible en Github , y parece que Swift está escrito principalmente en C++ , y su biblioteca estándar está escrita en Swift.
Para obtener más información, consulte este comunicado de prensa de Apple y el nuevo sitio web de Swift.org .
Se construye con el marco del compilador LLVM incluido en Xcode 6, y utiliza el tiempo de ejecución de Objective-C, lo que permite que los códigos C, Objective-C, C ++ y Swift se ejecuten dentro de un solo programa.
de Swift
Swift se implementa en C. Puede ver una descripción general del análisis de una persona aquí: https://github.com/rodionovd/SWRoute/wiki/Function-hooking-in-Swift
Con Swift pasando a ser de código abierto, imagino que esta pregunta será respondida más completamente en ese punto.
Incluiré una parte a continuación, pero definitivamente lea el análisis completo si está interesado:
func call_function(f : () -> Int) {
let b = f()
}
func someFunction() -> Int {
return 0
}
En Swift solo escribimos call_function (someFunction). Pero en lugar de realizar la llamada como call_function (& someFunction), el compilador Swift produce el código:
struct swift_func_wrapper *wrapper = ... /* configure wrapper for someFunction() */
struct swift_func_type_metadata *type_metadata = ... /* information about function''s arguments and return type */
call_function(wrapper->trampoline, type_metadata);
Una envoltura tiene la siguiente estructura:
struct swift_func_wrapper {
uint64_t **trampoline_ptr_ptr; // = &trampoline_ptr
uint64_t *trampoline_ptr;
struct swift_func_object *object;
}
¿Y qué es el tipo swift_func_object? Para crear este objeto, el tiempo de ejecución de Swift utiliza una constante global denominada metadatos [N] (que es única para cada llamada de función que toma su función como un argumento de un tipo genérico, así que para este código:
func callf(f: () -> ()) {
f();
}
callf(someFunction);
callf(someFunction);
se crearán dos constantes metadatos y metadatos2).
La estructura de un metadata [N] es algo así:
struct metadata {
uint64_t *destructor_func;
uint64_t *unknown0;
const char type:1; // I''m not sure about this and padding,
char padding[7]; // maybe it''s just a uint64_t too...
uint64_t *self;
}
Inicialmente, metadataN solo tiene dos campos establecidos: destructor_func y tipo. El primero es un puntero a una función que se usará para desasignar toda la memoria para un objeto creado con swift_allocObject (). Y el último es el identificador de tipo del objeto (0x40 o ''@'' para funciones / métodos), y es utilizado (de alguna manera) por swift_allocObject () para crear un objeto correcto para nuestra función:
swift_allocObject(&metadata2->type, 0x20, 0x7);
Una vez creado el objeto func, tiene la siguiente estructura:
struct swift_func_object {
uint64_t *original_type_ptr;
uint64_t *unknown0;
uint64_t function_address;
uint64_t *self;
}
El primer campo es un puntero a los metadatos correspondientes [N] -> valor de tipo, el segundo parece ser 0x4 | 1 << 24 (0x100000004) y eso indica algo tal vez (no sé qué). function_address es lo que realmente nos interesa para enganchar, y self es (de repente) un puntero a self (si nuestro objeto representa una función simple, este campo es NULL).