GCCJIT, obtenir la taille d'un type

Question

Étant donné un pointeur gcc_jit_type est-il possible d'obtenir sa taille? J'ai regardé la documentation et je ne peux pas vraiment trouver un exemple de quelque chose comme l'opérateur sizeof. Je voudrais écrire une sorte de structure de données générique qui reçoit un gcc_jit_type et qui se compile à partir de ça. Un peu difficile à faire si je ne connais pas la taille du type.

Answer 1

J'ai réussi à bidouiller une solution, mais j'ai l'impression que c'était beaucoup plus difficile qu'elle n'aurait dû l'être. Il devrait y avoir quelque chose comme gcc_jit_type_sizeof(...) fonction ajoutée à l'API à mon avis.

J'ai réalisé que dans le code C sizeof(T) = (size_t)(1 + (T*)0) alors j'ai essayé de l'implémenter avec gccjit. En faisant, je me suis rendu compte qu'il n'y avait pas vraiment de moyen d'incrémenter un pointeur étant donné l'API. J'ai essayé d'utiliser l'opp binaire d'addition mais cela m'a donné une erreur puisque les deux opérandes doivent être du même type. L'ajout d'un int à un pointeur n'est pas valide dans gccjit. J'ai essayé d'assigner un pointeur à zéro et un autre à un et d'ajouter ceux-là mais cela a donné un résultat étrange. Je suppose que cela est logique puisque (int*)0 + (int*)1 est une erreur de compilation en C.

La prochaine chose que j'ai essayé était la ce C équivalent (size_t)&((T*)0)[1] - (size_t)((T*)0) qui a également omis de compiler becase dans gccjit vous ne pouvez pas lancer un type de pointeur sur un int non plus. Je l'ai finalement fait fonctionner en le changeant en (char*)&((T*)0)[1] - (char*)((T*)0) puisque vous pouvez lancer un pointeur vers un autre type de pointeur.

gcc_jit_rvalue* jit_sizeof(gcc_jit_context* ctx, gcc_jit_type* t) 
{ 
    const void* NULL_PTR = 0; 

    gcc_jit_type* t_ptr_type = gcc_jit_type_get_pointer(t); 
    gcc_jit_type* size_type = gcc_jit_context_get_type(ctx, GCC_JIT_TYPE_SIZE_T); 
    gcc_jit_type* byte_type_ptr = gcc_jit_type_get_pointer(gcc_jit_context_get_int_type(ctx, 1, 0)); 

    gcc_jit_rvalue* one = gcc_jit_context_new_rvalue_from_int(ctx, size_type, 1); 

    gcc_jit_rvalue* ptr_0 = gcc_jit_context_new_rvalue_from_ptr(ctx, t_ptr_type, &NULL_PTR); 
    gcc_jit_rvalue* ptr_1 = gcc_jit_lvalue_get_address(gcc_jit_context_new_array_access(ctx, NULL, ptr_0, one), NULL); 

    ptr_0 = gcc_jit_context_new_cast(ctx, NULL, ptr_0, byte_type_ptr); 
    ptr_1 = gcc_jit_context_new_cast(ctx, NULL, ptr_1, byte_type_ptr); 

    return gcc_jit_context_new_binary_op(ctx, NULL, GCC_JIT_BINARY_OP_MINUS, size_type, ptr_1, ptr_0); 
} 

EDIT: Je viens compris comment jeter un pointeur sur un type entier ainsi. Vous pouvez bitwise et avec lui-même et définir le type de résultat à un size_t.

ptr_0 = gcc_jit_context_new_binary_op(ctx, NULL, GCC_JIT_BINARY_OP_BITWISE_AND, size_type, ptr_0, ptr_0); 
ptr_1 = gcc_jit_context_new_binary_op(ctx, NULL, GCC_JIT_BINARY_OP_BITWISE_AND, size_type, ptr_1, ptr_1); 

return gcc_jit_context_new_binary_op(ctx, NULL, GCC_JIT_BINARY_OP_MINUS, size_type, ptr_1, ptr_0);