Est-il possible de compiler un code supplémentaire au moment de l'exécution en C ou C++?

Voici ce que je veux faire:

  1. L'exécution d'un programme et d'initialiser certaines structures de données.
  2. Ensuite compiler du code supplémentaire qui peut accéder/modifier les structures de données existantes.
  3. Répétez l'étape 2, si nécessaire.

Je veux être capable de le faire avec les deux C et C++ à l'aide de gcc (et éventuellement Java) sur les systèmes de type Unix (en particulier Linux et Mac OS X). L'idée est essentiellement de mettre en œuvre un read-eval-print loop pour ces langues, qui compile les expressions et les déclarations qu'ils sont entrés et l'utilise pour modifier les structures de données existantes (quelque chose qui se fait tout le temps dans les langages de script). Je suis en train d'écrire cet outil dans python, ce qui génère le C/C++ fichiers, mais cela ne devrait pas être pertinentes.

J'ai exploré le faire avec les bibliothèques partagées mais qui a appris que la modification des bibliothèques partagées n'affecte pas les programmes qui sont déjà en cours d'exécution. J'ai aussi essayé d'utiliser la mémoire partagée, mais ne pouvait pas trouver un moyen de charger une fonction sur le tas. J'ai également étudié à l'aide de code assembleur, mais n'ont pas encore tenté de le faire.

Je préfère ne pas utiliser les compilateurs autres que gcc à moins qu'il n'y a absolument aucun moyen de le faire dans gcc.

Si quelqu'un a des idées ou sait comment faire cela, toute aide sera appréciée.

  • Vous devriez regarder les version/clang. Mais un REPL pour le C ou le C++ ressemble tout à fait une tâche.
  • Quelque chose à faire avec ceci?
  • Je préfère utiliser le vrai langage de script, sauf que vous pouvez dire ce que tout cela pour
InformationsquelleAutor Matt | 2012-05-12
  1. 12

    Je pense que vous pouvez être en mesure d'accomplir cette tâche en utilisant les bibliothèques dynamiques de chargement et lors de l'exécution (à l'aide de dlopen et amis).

    void * lib = dlopen("mynewcode.so", RTLD_LAZY);
if(lib) {
    void (*fn)(void) = dlsym(lib, "libfunc");

    if(fn) fn();
    dlclose(lib);
}

    Vous devraient à l'évidence être de la compilation du nouveau code comme vous allez le long, mais si vous gardez le remplacement de mynewcode.so je pense que cela fonctionnera pour vous.

    • La charge doit être pris en charge, je ne suis pas sûr que un chargement est pris en charge dans tous les cas, cependant.
    • Je vais avouer que je suis présent d'un expert sur le chargement à l'exécution, mais la page de man m'amène à croire que les symboles sont déchargés à l'dlclose (en particulier le RTLD_NODELETE drapeau). Prendre tout cela avec un grain de sel bien :).
    InformationsquelleAutor Stephen Newell
  2. 12

    Il y a une solution simple:

    1. créer propre bibliothèque de fonctions spéciales
    2. charge créée bibliothèque
    3. exécuter des fonctions de cette bibliothèque, traverser les structures en fonction des variables

    À l'utilisation de vos structures, vous devez inclure le même en-tête des fichiers comme dans l'application hôte.

    des structures.h:

    struct S {
    int a,b;
};

    main.cpp:

    #include <iostream>
#include <fstream>
#include <dlfcn.h>
#include <stdlib.h>

#include "structs.h"

using namespace std;

int main ( int argc, char **argv ) {

    //create own program
    ofstream f ( "tmp.cpp" );
    f << "#include<stdlib.h>\n#include \"structs.h\"\n extern \"C\" void F(S &s) { s.a += s.a; s.b *= s.b; }\n";
    f.close();

    //create library
    system ( "/usr/bin/gcc -shared tmp.cpp -o libtmp.so" );

    //load library        
    void * fLib = dlopen ( "./libtmp.so", RTLD_LAZY );
    if ( !fLib ) {
        cerr << "Cannot open library: " << dlerror() << '\n';
    }

    if ( fLib ) {
        int ( *fn ) ( S & ) = dlsym ( fLib, "F" );

        if ( fn ) {
            for(int i=0;i<11;i++) {
                S s;
                s.a = i;
                s.b = i;

                //use function
                fn(s);
                cout << s.a << " " << s.b << endl;
            }
        }
        dlclose ( fLib );
    }

    return 0;
}

    de sortie:

    0 0
2 1
4 4
6 9
8 16
10 25
12 36
14 49
16 64
18 81
20 100

    Vous pouvez également créer mutable programme qui va changer lui-même (le code source), la recompilation de vous-même et puis le remplacer réels de l'exécution avec execv et d'économiser les ressources avec de la mémoire partagée.

    • très utile info mais comment vous y prendriez-vous, y compris les main.cpp dans le tmp.cpp?
    • Okey, je vais modifier la question pour vous répondre, mais il n'est pas nécessaire 🙂 Vous ne pouvez pas inclure le main.cpp dans tmp. Si vous voulez partager des données, alors vous devez utiliser l'en-tête (ou écrire directement dans un fichier) et de transmettre les structures créées dynamiquement en fonction 🙂
    • thnx! lors de l'utilisation d'en-têtes toutefois, les valeurs des variables partagées ne sont pas les mêmes. donc je finis par avoir à les passer à la fonction. je me demande si il y a encore du chemin à faire autour du passage de variables
    • Si vous incluez l'en-tête dans le rpc, c'est de même que si vous avez écrit de son contenu dans le rpc. Si vous vous retrouvez avec deux instances de variables ( main.cpp et dynamique de la bibliothèque ), mais si tu avais l'en-tête(définition des variables) inclus dans deux objets(rpc-s) dans la même bibliothèque, puis il va vous jeter d'erreur lors de la compilation. Vous devez utiliser le "extern" mot clé dans l'en-tête de, à dire compilateur, ces variables ne sont pas instanciés dans l'objet courant(rpc) et sera lié par l'éditeur de liens. Vous pouvez faire des variables "statique", ils seront instanciés privé dans chaque objet, mais vous ne pouvez pas partager quoi que ce soit de toute façon.
    InformationsquelleAutor kravemir
  3. 4

    Même si LLVM est maintenant, aujourd'hui utilisé principalement pour ses optimisations et backend rôles dans la compilation, comme son cœur, c'est le Bas Niveau de la Machine Virtuelle.

    LLVM pouvez JIT code, même si le type de retour peut être tout à fait opaque, donc si vous êtes prêt à emballer votre propre code autour d'elle et ne vous inquiétez pas trop à propos de l'jette qui vont avoir lieu, il peut vous aider.

    Cependant, C et C++ ne sont pas très sympa pour ce genre de chose.

    InformationsquelleAutor Matthieu M.
  4. 3

    Oui - vous pouvez le faire avec Runtime Compilé En C++ (ou de prendre un coup d'oeil à la RCC++ blog et les vidéos), ou de l'une de ses alternatives.

    InformationsquelleAutor Doug Binks
  5. 3

    Cela peut être fait de façon portable avec OpenCL

    OpenCL est un largement pris en charge standard, principalement utilisé pour le déchargement des calculs de matériels spécialisés, tels que les Gpu. Cependant, il fonctionne très bien sur Cpu et effectue au moment de l'exécution de la compilation de C99-comme le code comme l'une de ses caractéristiques principales (c'est la façon dont le matériel portabilité est atteint). Les versions plus récentes (2.1+) acceptent également d'un grand sous-ensemble de C++14.

    Un exemple de base d'un tel moment de l'exécution de la compilation & l'exécution pourrait ressembler à quelque chose comme ceci:

    #ifdef __APPLE__
#include<OpenCL/opencl.h>
#else
#include<CL/cl.h>
#endif
#include<stdlib.h>
int main(int argc,char**argv){//assumes source code strings are in argv
    cl_int e = 0;//error status indicator
    cl_platform_id platform = 0;
    cl_device_id device = 0;
    e=clGetPlatformIDs(1,&platform,0);                                      if(e)exit(e);
    e=clGetDeviceIDs(platform,CL_DEVICE_TYPE_ALL,1,&device,0);              if(e)exit(e);
    cl_context context = clCreateContext(0,1,&device,0,0,&e);               if(e)exit(e);
    cl_command_queue queue = clCreateCommandQueue(context,device,0,&e);     if(e)exit(e);
    //the lines below could be done in a loop, assuming you release each program & kernel
    cl_program program = clCreateProgramWithSource(context,argc,(const char**)argv,0,&e);
    cl_kernel kernel = 0;                                                   if(e)exit(e);
    e=clBuildProgram(program,1,&device,0,0,0);                              if(e)exit(e);
    e=clCreateKernelsInProgram(program,1,&kernel,0);                        if(e)exit(e);
    e=clSetKernelArg(kernel,0,sizeof(int),&argc);                           if(e)exit(e);
    e=clEnqueueTask(queue,kernel,0,0,0);                                    if(e)exit(e);
    //realistically, you'd also need some buffer operations around here to do useful work
}
    InformationsquelleAutor Ryan Hilbert
  6. 2

    Si rien d'autre ne fonctionne - en particulier, si le chargement d'une bibliothèque partagée finit par ne pas être pris en charge sur votre plate-forme d'exécution, vous pouvez le faire à la dure.

    1) utiliser system() ou n'importe quoi d'exécuter gcc ou faire ou que ce soit pour générer le code

    2) lier comme un plat binaire ou d'analyser quel que soit le format (elfe?) l'éditeur de liens sorties sur votre plate-forme vous-même

    3) trouvez-vous exécutable pages, soit par mmap () ing un fichier exécutable ou faire faire un mmap anonyme avec le bit d'exécution de définir et de copier/déballage de votre code (pas toutes les plates-formes de soins à ce sujet, mais nous supposons que vous avez un qui n')

    4) vider les données et les instructions de caches (depuis la cohérence entre les deux est généralement pas garanti)

    5) appeler par l'intermédiaire d'un pointeur de fonction, ou de quoi que

    Bien sûr, il y a une autre option, selon le niveau d'interaction que vous avez besoin, vous pourriez construire un programme séparé et soit de le lancer et d'attendre le résultat, ou bifurquer et lancez-le et parlez-lui par des tuyaux ou des sockets. Si cela peut répondre à vos besoins, il serait beaucoup moins difficile.

    InformationsquelleAutor Chris Stratton