Avertissement inline suppression

Question

Je reçois inling avertissement tels que:

  warning: inlining failed in call to ‘symbol_Arity’: call is unlikely and code size would grow

Pour se débarrasser de ce que j'ai changé le makefile enlever le -Winline pour se débarrasser de cela. Je ne reçois pas d'avertissement inline. Mais, je ne sais pas comment est-il sage de faire en ce qui concerne la performance. Quelqu'un peut-il s'il vous plaît me suggérer à ce sujet?

Ajout d'informations:

ici est e avertissement:

search.c: In function ‘prfs_InsertInSortTheories’:
list.h:254: warning: inlining failed in call to ‘list_Delete’: call is unlikely and code size would grow
search.c:187: warning: called from here
list.h:254: warning: inlining failed in call to ‘list_Delete’: call is unlikely and code size would grow
search.c:189: warning: called from here

et le code correspondant est le suivant:

de list.h

254 static __inline__ void list_Delete(LIST L)
255 {
256   LIST Current;
257 
258   Current = L;
259   while (!list_Empty(Current)) {
260     L = list_Cdr(L);
261     list_Free(Current);
262     Current = L;
263   }

et de search.c

 176     LIST    approx;
 177     l = clause_Length(Clause);
 178     for (i = clause_FirstSuccedentLitIndex(Clause); i < l; i++) {
 179       lit = clause_GetLiteral(Clause,i);
 180       if (clause_LiteralIsMaximal(lit) &&
 181           symbol_IsBaseSort(term_TopSymbol(clause_LiteralSignedAtom(lit)))) {
 182         if (prfs_DynamicSortTheory(Search) != (SORTTHEORY)NULL
 183             && clause_NumOfSuccLits(Clause) == 1 &&
 184             clause_NumOfAnteLits(Clause) == 0)
 185           {
 186           copy = clause_Copy(Clause);
 187           list_Delete(clause_ParentClauses(copy));
 188           clause_SetParentClauses(copy,list_Nil());
 189           list_Delete(clause_ParentLiterals(copy));
 190           clause_SetParentLiterals(copy,list_Nil());
 191           clause_SetNumber(copy,clause_Number(Clause));
 192           sort_TheoryInsertClause(prfs_DynamicSortTheory(Search),Clause,
 193                                   copy,clause_GetLiteral(copy,i));
 194         }

Answer 1

Le seul « problème » est que vous essayez de forcer le compilateur à faire quelque chose inefficace.

Utilisez ìnline plutôt que __inline__ et respecter les décisions des compilateurs sur ce qui devrait ou ne devrait pas être inline. Ne pas essayer de forcer, à moins que vous avez déjà PROFILES le code, trouvé qu'il était un goulot d'étranglement, et vérifié que inline accélérerait réellement, plutôt que vers le bas lent, le code.

C'est essentiellement ce que l'avertissement dit: «Vous me demandez de faire quelque chose de stupide qui avait ralentir le code que je vais l'ignorer ».

Et bien sûr, vous pouvez ignorer (ou silence) l'avertissement, mais la meilleure solution est juste de ne pas forcer à quoi que ce soit stupide, en premier lieu. Ne pas utiliser le __inline__ spécifique-compilateur, et l'utilisation inline si vous en avez besoin, et faire confiance au compilateur de décider quoi en ligne.

Answer 2

Supprimer static __inline__ de la fonction dans le fichier d'en-tête et le remplacer par inline - le mot-clé standard C ++. Vous ne devriez pas recevoir un avertissement avec cela.

Answer 3

Je suis tombé ici après avoir compilé un vieux code avec -Werror -Winline - un avertissement que je veux par défaut parce qu'il trouve des erreurs importantes, où vous avez oublié les opérateurs d'affectation etc

.

Cependant, pour une fonction particulière je ne suis absolument besoin d'être toujours inline, et donc je besoin d'un moyen de supprimer un avertissement pour tout ce bloc de code.

#pragma GCC diagnostic ignored "-Winline"

était le choix évident, mais il ne fait pas disparaître cet avertissement. La solution est d'utiliser l'attribut always_inline:

inline bool function() __attribute__((always_inline));
inline bool function() { /*something*/ };

Cela se débarrasser de l'avertissement et en fait la force toujours inline

Answer 4

Je ne vois pas de problème avec ça!

Il ne devrait pas être un retard de performance, que je comprends, coz, le compilateur traite l'inline en fonction régulière!

Voyez ce que GCC a à dire!

-Winline
Avertir si une fonction ne peut pas être inline et il a été déclaré en ligne. Même avec cette option, le compilateur ne sera pas mettre en garde contre les défaillances de fonctions en ligne déclarés dans les en-têtes du système. Le compilateur utilise une variété de heuristiques pour déterminer si oui ou non une fonction inline. Par exemple, le compilateur prend en compte la taille de la fonction étant inline et la quantité de inline qui a déjà été fait dans la fonction actuelle. Par conséquent, des changements apparemment insignifiants dans le programme source peut provoquer des avertissements produits par -Winline apparaître ou disparaître.