primer - taylor swift reputation producer

¿En qué idioma está escrito Swift?

Question

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.

Answer 1

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 .

Answer 2

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

Answer 3

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).