Pourquoi l'optimiseur amélioré GCC 6 rompt-il le code C ++ pratique?

GCC 6 a une nouvelle fonctionnalité d'optimisation : il suppose que ce thisn'est toujours pas nul et optimise en fonction de cela.

La propagation de la plage de valeurs suppose désormais que le pointeur this des fonctions membres C ++ est non nul. Cela élimine les vérifications de pointeurs nulles courantes mais casse également certaines bases de code non conformes (telles que Qt-5, Chromium, KDevelop) . Pour contourner le problème, vous pouvez utiliser -fno-delete-null-pointer-checks. Un code incorrect peut être identifié en utilisant -fsanitize = undefined.

Le document de modification appelle clairement cela comme dangereux car il rompt une quantité surprenante de code fréquemment utilisé.

Pourquoi cette nouvelle hypothèse casserait-elle le code C ++ pratique?Existe-t-il des schémas particuliers où des programmeurs imprudents ou non informés s'appuient sur ce comportement particulier non défini? Je ne peux pas imaginer que quiconque écrive if (this == NULL)parce que ce n'est pas naturel.

Je suppose que la question à laquelle il faut répondre pourquoi des gens bien intentionnés écriraient les chèques en premier lieu.

Le cas le plus courant est probablement si vous avez une classe qui fait partie d'un appel récursif naturel.

Si tu avais:

struct Node
{
    Node* left;
    Node* right;
};

en C, vous pourriez écrire:

void traverse_in_order(Node* n) {
    if(!n) return;
    traverse_in_order(n->left);
    process(n);
    traverse_in_order(n->right);
}

En C ++, c'est bien d'en faire une fonction membre:

void Node::traverse_in_order() {
    // <--- What check should be put here?
    left->traverse_in_order();
    process();
    right->traverse_in_order();
}

Au début du C ++ (avant la standardisation), il était souligné que les fonctions membres étaient du sucre syntaxique pour une fonction où le thisparamètre est implicite. Le code a été écrit en C ++, converti en C équivalent et compilé. Il y avait même des exemples explicites que la comparaison thisà null était significative et le compilateur Cfront d'origine en a également profité. Donc, venant d'un fond C, le choix évident pour le contrôle est:

if(this == nullptr) return;      

Remarque: Bjarne Stroustrup mentionne même que les règles pour thisont changé au fil des ans ici

Et cela a fonctionné sur de nombreux compilateurs pendant de nombreuses années. Lorsque la normalisation a eu lieu, cela a changé. Et plus récemment, les compilateurs ont commencé à tirer parti de l'appel d'une fonction membre où thisêtre nullptrest un comportement indéfini, ce qui signifie que cette condition est toujours falseet que le compilateur est libre de l'omettre.

Cela signifie que pour effectuer une traversée de cet arbre, vous devez soit:

• Faites toutes les vérifications avant d'appeler traverse_in_order

  void Node::traverse_in_order() {
      if(left) left->traverse_in_order();
      process();
      if(right) right->traverse_in_order();
  }

  Cela signifie également vérifier sur CHAQUE site d'appel si vous pouvez avoir une racine nulle.

• N'utilisez pas de fonction membre

  Cela signifie que vous écrivez l'ancien code de style C (peut-être en tant que méthode statique) et que vous l'appelez avec l'objet explicitement en tant que paramètre. par exemple. vous êtes de retour à l'écriture Node::traverse_in_order(node);plutôt que node->traverse_in_order();sur le site d'appel.

• Je pense que le moyen le plus simple / le plus soigné de corriger cet exemple particulier d'une manière conforme aux normes est d'utiliser en fait un nœud sentinelle plutôt qu'un nullptr.

  // static class, or global variable
  Node sentinel;
  
  void Node::traverse_in_order() {
      if(this == &sentinel) return;
      ...
  }

Aucune des deux premières options ne semble aussi attrayante, et bien que le code puisse s'en tirer, ils ont écrit du mauvais code avec this == nullptr au lieu d'utiliser un correctif approprié.

Je suppose que c'est ainsi que certaines de ces bases de code ont évolué pour avoir des this == nullptrvérifications.

Il le fait parce que le code "pratique" était cassé et impliquait un comportement indéfini au départ. Il n'y a aucune raison d'utiliser une valeur nulle this, autre que comme une micro-optimisation, généralement très prématurée.

C'est une pratique dangereuse, car l' ajustement des pointeurs en raison de la traversée de la hiérarchie des classes peut transformer un null thisen un non nul. Donc, à tout le moins, la classe dont les méthodes sont censées fonctionner avec un null thisdoit être une classe finale sans classe de base: elle ne peut dériver de rien, et elle ne peut pas être dérivée. Nous passons rapidement de la pratique au laide-hack-land .

Concrètement, le code n'a pas à être moche:

struct Node
{
  Node* left;
  Node* right;
  void process();
  void traverse_in_order() {
    traverse_in_order_impl(this);
  }
private:
  static void traverse_in_order_impl(Node * n)
    if (!n) return;
    traverse_in_order_impl(n->left);
    n->process();
    traverse_in_order_impl(n->right);
  }
};

Si vous aviez un arbre vide (par exemple root est nullptr), cette solution repose toujours sur un comportement indéfini en appelant traverse_in_order avec un nullptr.

Si l'arborescence est vide, c'est-à-dire null Node* root, vous n'êtes pas censé appeler de méthodes non statiques dessus. Période. C'est parfaitement bien d'avoir un code arborescent de type C qui prend un pointeur d'instance par un paramètre explicite.

L'argument ici semble se résumer à la nécessité d'écrire des méthodes non statiques sur des objets qui pourraient être appelés à partir d'un pointeur d'instance nul. Il n'y a pas un tel besoin. La manière d'écrire un tel code en C-avec-objets est toujours plus agréable dans le monde C ++, car elle peut au moins être de type sécurisé. Fondamentalement, le nul thisest une telle micro-optimisation, avec un champ d'utilisation si étroit, que l'interdire est parfaitement bien à mon humble avis. Aucune API publique ne doit dépendre d'une valeur nulle this.

Le document de modification appelle clairement cela comme dangereux car il rompt une quantité surprenante de code fréquemment utilisé.

Le document ne l'appelle pas dangereux. Il ne prétend pas non plus qu'il casse une quantité surprenante de code . Il souligne simplement quelques bases de code populaires dont il prétend être connu pour s'appuyer sur ce comportement non défini et qui se briseraient en raison du changement à moins que l'option de contournement ne soit utilisée.

Pourquoi cette nouvelle hypothèse casserait-elle le code C ++ pratique?

Si le code C ++ pratique repose sur un comportement non défini, les modifications apportées à ce comportement non défini peuvent le casser. C'est pourquoi UB doit être évité, même lorsqu'un programme qui en dépend semble fonctionner comme prévu.

Existe-t-il des schémas particuliers où des programmeurs imprudents ou non informés s'appuient sur ce comportement non défini particulier?

Je ne sais pas si c'est un anti- modèle largement répandu , mais un programmeur non informé pourrait penser qu'il peut réparer son programme de planter en faisant:

if (this)
    member_variable = 42;

Lorsque le bogue réel déréférence un pointeur nul ailleurs.

Je suis sûr que si le programmeur n'est pas suffisamment informé, il pourra proposer des (anti) modèles plus avancés qui reposent sur cet UB.

Je ne peux pas imaginer que quelqu'un écrive if (this == NULL)parce que ce n'est pas naturel.

Je peux.

Une partie du code "pratique" (façon amusante d'épeler "buggy") qui a été cassé ressemblait à ceci:

void foo(X* p) {
  p->bar()->baz();
}

et il a oublié de tenir compte du fait que p->bar()parfois renvoie un pointeur nul, ce qui signifie que le déréférencer pour appeler baz()n'est pas défini.

Pas tout le code qui a été brisé contenu explicite if (this == nullptr)ou les if (!p) return;chèques. Certains cas étaient simplement des fonctions qui n'accédaient à aucune variable membre, et qui semblaient donc fonctionner correctement. Par exemple:

struct DummyImpl {
  bool valid() const { return false; }
  int m_data;
};
struct RealImpl {
  bool valid() const { return m_valid; }
  bool m_valid;
  int m_data;
};

template<typename T>
void do_something_else(T* p) {
  if (p) {
    use(p->m_data);
  }
}

template<typename T>
void func(T* p) {
  if (p->valid())
    do_something(p);
  else 
    do_something_else(p);
}

Dans ce code, lorsque vous appelez func<DummyImpl*>(DummyImpl*)avec un pointeur nul, il y a un déréférencement "conceptuel" du pointeur à appeler p->DummyImpl::valid(), mais en fait, cette fonction membre retourne simplement falsesans accéder *this. Cela return falsepeut être intégré et donc, dans la pratique, le pointeur n'a pas du tout besoin d'être accédé. Donc, avec certains compilateurs, cela semble fonctionner correctement: il n'y a pas de segfault pour déréférencer null, p->valid()est faux, donc le code appelle do_something_else(p), qui vérifie les pointeurs nuls, et ne fait donc rien. Aucun crash ou comportement inattendu n'est observé.

Avec GCC 6, vous obtenez toujours l'appel à p->valid(), mais le compilateur déduit maintenant de cette expression qui pdoit être non-null (sinon ce p->valid()serait un comportement non défini) et prend note de cette information. Ces informations déduites sont utilisées par l'optimiseur de sorte que si l'appel à do_something_else(p)est incorporé, la if (p)vérification est maintenant considérée comme redondante, car le compilateur se souvient qu'elle n'est pas nulle, et donc intègre le code à:

template<typename T>
void func(T* p) {
  if (p->valid())
    do_something(p);
  else {
    // inlined body of do_something_else(p) with value propagation
    // optimization performed to remove null check.
    use(p->m_data);
  }
}

Cela fait maintenant vraiment déréférencer un pointeur nul, et donc le code qui semblait auparavant fonctionner cesse de fonctionner.

Dans cet exemple, le bogue est présent func, qui aurait dû d'abord vérifier null (ou les appelants n'auraient jamais dû l'appeler avec null):

template<typename T>
void func(T* p) {
  if (p && p->valid())
    do_something(p);
  else 
    do_something_else(p);
}

Un point important à retenir est que la plupart des optimisations comme celle-ci ne sont pas un cas où le compilateur dit "ah, le programmeur a testé ce pointeur contre null, je vais le supprimer juste pour être ennuyeux". Ce qui se passe, c'est que diverses optimisations courantes telles que l'inlining et la propagation de la plage de valeurs se combinent pour rendre ces vérifications redondantes, car elles surviennent après une vérification antérieure ou une déréférence. Si le compilateur sait qu'un pointeur est non nul au point A dans une fonction et que le pointeur n'est pas modifié avant un point B ultérieur dans la même fonction, alors il sait qu'il est également non nul en B.Lorsque l'inlining se produit les points A et B peuvent en fait être des morceaux de code qui étaient à l'origine dans des fonctions séparées, mais qui sont maintenant combinés en un seul morceau de code, et le compilateur est capable d'appliquer sa connaissance que le pointeur est non nul à plusieurs endroits.

La norme C ++ est rompue de manière importante. Malheureusement, plutôt que de protéger les utilisateurs de ces problèmes, les développeurs de GCC ont choisi d'utiliser un comportement indéfini comme excuse pour implémenter des optimisations marginales, même lorsqu'il leur a été clairement expliqué à quel point il est dangereux.

Ici, une personne beaucoup plus intelligente que je ne l'explique en détail. (Il parle de C mais la situation est la même ici).

• https://groups.google.com/forum/m/#!msg/boring-crypto/48qa1kWignU/o8GGp2K1DAAJ

Pourquoi est-ce nocif?

Recompiler simplement du code sécurisé précédemment fonctionnel avec une version plus récente du compilateur peut introduire des vulnérabilités de sécurité . Bien que le nouveau comportement puisse être désactivé avec un indicateur, les fichiers makefiles existants n'ont pas cet indicateur défini, évidemment. Et comme aucun avertissement n'est produit, il n'est pas évident pour le développeur que le comportement précédemment raisonnable a changé.

Dans cet exemple, le développeur a inclus une vérification du dépassement d'entier, en utilisant assert, qui mettra fin au programme si une longueur non valide est fournie. L'équipe GCC a supprimé la vérification sur la base que le débordement d'entier n'est pas défini, donc la vérification peut être supprimée. Cela a abouti à la redéfinition de la vulnérabilité des instances réelles de cette base de code après la résolution du problème.

• https://gcc.gnu.org/bugzilla/show_bug.cgi?id=30475

Lisez le tout. C'est assez pour te faire pleurer.

OK, mais qu'en est-il de celui-ci?

Il y a longtemps, il y avait un idiome assez courant qui ressemblait à ceci:

 OPAQUEHANDLE ObjectType::GetHandle(){
    if(this==NULL)return DEFAULTHANDLE;
    return mHandle;

 }

 void DoThing(ObjectType* pObj){
     osfunction(pObj->GetHandle(), "BLAH");
 }

Donc, l'idiome est: Si pObjn'est pas nul, vous utilisez le handle qu'il contient, sinon vous utilisez un handle par défaut. Ceci est encapsulé dans la GetHandlefonction.

L'astuce est que l'appel d'une fonction non virtuelle n'utilise en fait aucun this pointeur, donc il n'y a pas de violation d'accès.

Je ne comprends toujours pas

Il existe beaucoup de code écrit comme ça. Si quelqu'un le recompile simplement, sans changer de ligne, chaque appel à DoThing(NULL)est un bug qui plante - si vous êtes chanceux.

Si vous n'êtes pas chanceux, les appels aux bogues qui se bloquent deviennent des vulnérabilités d'exécution à distance.

Cela peut se produire même automatiquement. Vous avez un système de construction automatisé, non? Le mettre à niveau vers le dernier compilateur est inoffensif, non? Mais maintenant ce n'est pas le cas - pas si votre compilateur est GCC.

OK alors dis-leur!

On leur a dit. Ils le font en pleine connaissance des conséquences.

mais pourquoi?

Qui peut dire? Peut-être:

• Ils valorisent la pureté idéale du langage C ++ par rapport au code réel
• Ils croient que les gens devraient être punis pour ne pas suivre la norme
• Ils n'ont aucune compréhension de la réalité du monde
• Ils ... introduisent des bogues exprès. Peut-être pour un gouvernement étranger. Où habitez-vous? Tous les gouvernements sont étrangers à la plupart des pays du monde et la plupart sont hostiles à une partie du monde.

Ou peut-être autre chose. Qui peut dire?