est-il possible d'apporter GCC dans une boucle infinie en saisissant un code source étrange? Et si oui, comment? Peut-être que on pourrait faire quelque chose avec des métaprogramming de modèle?
7 Réponses :
Je pense que vous pourriez le faire avec #include
juste #include "File1.c" dans File2.c et #include "File2.c" dans File1
suggestion provoque une boucle de compilateur beaucoup alors échouez, pas de boucler infiniment
Ce serait facile à tester, n'est-ce pas?
Non, il détecte la dépendance circulaire.
GCC finira par échouer avec un #include trop profondément erreur, donc pas une boucle infinie. Un test rapide montre que c'est le cas. GCC ne détecte pas la dépendance circulaire (GCC sur OS X Snow Leopard), mais ce n'est pas infini
Bon point - pas infini. Je ne suis pas habitué à laisser ce test courir assez longtemps pour vider
Je pensais que cela pourrait aussi, alors je l'ai déjà testé quand j'ai vu votre message. :)
Quelques mégaoctets de circulaire #includes pourraient être suffisants pour le faire pivoter pour un temps looong, pourrait apporter la machine si ulimit n'est pas défini ni l'obtenir pour accrocher pour le temps cosmique.
Cela peut être possible. Mais la plupart des compilateurs (et la plupart des langues normalisées) ont des limites sur des éléments tels que les profondeurs de récursivité dans les modèles ou incluent des fichiers, à quel point le compilateur devrait sous caution avec un diagnostic. Compilateurs qui ne le font pas ne sont pas normalement populaires avec les utilisateurs.
Je ne sais pas à propos de GCC, mais le vieux PCC avait l'habitude d'entrer dans une boucle infinie compilant certaines sortes de boucles infinies (celles qui compilaient jusqu'à _x: JMP _x).
oui.
Presque tous les programmes informatiques ont des problèmes de résiliation de boucle. Je pense que GCC, cependant, manquerait de RAM avant qu'une boucle infinie ne devienne jamais évidente. Il n'y a pas beaucoup d'opérations "gratuites" dans sa conception.
L'analyseur et le préprocesseur ne créeraient pas de problèmes. Je suis prêt à parier que vous pourriez cibler l'optimiseur, ce qui aurait probablement plus de défauts de mise en œuvre. Ce serait moins sur la langue et plus d'exploiter une faille que vous pourriez découvrir du code source. C'est-à-dire que l'exploitation serait non évidente.
dans Ce cas particulier , ma théorie semble correcte. Le compilateur continue de répartir la RAM et que l'optimiseur semble être vulnérable. La réponse est oui. Oui vous pouvez.
Commentaire de / * théoriquement possible, mais * hautement * improbable. * / dans ce rapport de bogue vaut mille images.
Bentley écrit dans son livre "Perles de programmation" que le code suivant a abouti à une boucle infinie lors de la compilation optimisée: il dit "L'optimiseur a essayé de convertir la récursivité de la queue en une boucle , et est mort quand il pourrait trouver un test pour terminer la boucle. " (p.139) Il ne signale pas la version exacte du compilateur où cela s'est passé. Je suppose que de nouveaux compilateurs détectent le cas.
Pas de boucle infinie pendant la compilation sur mon compilateur (GCC 4.x) :(
Les bugs sont particulièrement transitoires, par exemple, la réponse de Pestilence a été trouvée dans GCC 4.4.0 et fixée en 4.4.1. Pour une liste des manières actuelles d'apporter GCC à une boucle infinie, cochez Leur bugzilla .
EDIT: Je viens de trouver une nouvelle façon, qui bloque également Comeau. C'est une réponse plus satisfaisante, pour l'instant. Bien sûr, c'est doit également être corrigé bientôt .
J'aime cette réponse. J'attendrai s'il y en aura un peu plus, mais je vais probablement l'accepterai.
Étant donné que la métaprogrammation de modèle C ++ est en fait complète, vous pouvez faire une compilation sans fin.
Par exemple: P>
template<typename T>
struct Loop {
typedef typename Loop<Loop<T> >::Temp Temp;
};
int main(int, char**) {
Loop<int> n;
return 0;
}
Hmm. La dernière fois que je vérifie man gcc il a eu une option spécifiant la taille maximale de "pile". Donc, il est impossible car ce n'est aucun moyen de travailler autour de la finité des itérations.
"La profondeur d'instanciation de modèle dépasse le maximum de 500"
Je recommande à la communauté wiki pour cela. J'ai des capacités d'édition, je vais donc mettre cela moi-même si personne n'obne.
@Joshua: Pourquoi Wiki communautaire? Cela ne me semble pas subjectif. C'est soit possible, soit ce n'est pas le cas.
S'il y a, il doit être envoyé à gcc.gnu.org/bugs où il peut être corrigé .
Les gros programmes ne sont pas sans bug. GCC est un grand programme.
"Pas une vraie question?" Comment ne pourrait-il pas être une vraie question, lorsqu'il est lisible, a un point d'interrogation à la fin, une inversion correcte du verbe et du pronom, et réponses valides ?
Je pense que vous devriez essayer d'écrire un programme pour déterminer si GCC sera ou n'entrera pas dans une boucle infinie pour une entrée donnée. Vous savez, pour voir si cela s'arrêterait ou non.
Je ne pense pas que cela devrait être fermé. Quand je l'ai lu, j'étais comme une "bonne question" et j'étais assez excitée de voir les réponses et de voir quel type de code compliqué torturerait mon compilateur de cette façon. C'est une vraie question