Comment Glass lit les régions d'exception d'une méthode
Un bloc try/catch/finally ne laisse presque aucune trace dans le flux d'instructions IL : les accolades se compilent en plages de décalages stockées dans une table de clauses de gestionnaires d'exception distincte, à la fin du corps de la méthode. Cet article lit cette table clause par clause, montre les quatre types de clause du CLR (y compris le gestionnaire fault, qui n'a aucun mot-clé en C#), explique pourquoi l'ordre des clauses décide quel gestionnaire l'emporte, et montre comment Glass.NET reconvertit des plages de décalages brutes en try/catch/finally imbriqués.
Ouvrez n”importe quelle méthode contenant un bloc try dans la vue IL d”un décompilateur et cherchez le try. Vous ne le trouverez pas. Il n”y a aucun opcode « begin try », aucune instruction « catch », rien dans le flux d”instructions qui indique où une région protégée commence ou s”arrête. Les accolades que vous avez écrites se sont compilées en tout autre chose : une petite table de décalages en octets boulonnée à la fin du corps de la méthode. Reconstruire try/catch/finally à partir de cette table est l”une des choses les plus discrètes que fait un décompilateur, et c”est une bonne fenêtre sur la façon dont le CLR modélise réellement la gestion structurée des exceptions.
La vraie question
Le flux d”instructions IL est linéaire. La gestion des exceptions ne l”est pas : c”est un ensemble de régions, certaines imbriquées, chacune avec un gestionnaire vers lequel le runtime saute en cas de défaillance. Alors où vit cette structure, et comment un lecteur passe-t-il d”une liste plate d”opcodes plus une table de décalages bruts au try/catch/finally imbriqué qu”un développeur reconnaîtrait ?
La réponse est la table de clauses de gestionnaires d”exception. Toute méthode contenant une région protégée est émise avec un en-tête de méthode fat (gros), dont les indicateurs activent CorILMethod_MoreSects. Après le code IL — aligné sur une frontière de 4 octets — vient une section de données supplémentaires, et cette section contient la table de clauses. Chaque clause est une ligne de champs fixe, et ces lignes sont le seul enregistrement du try que vous avez écrit.
Une clause, ce sont cinq nombres et un type
Prenez une méthode ordinaire avec un catch et un finally :
static int ReadCount(string path)
{
int n = 0;
try
{
n = int.Parse(File.ReadAllText(path));
}
catch (FormatException)
{
n = -1;
}
finally
{
Console.WriteLine("done");
}
return n;
}
Les instructions se compilent en une séquence plate. Les limites des régions ne sont exprimées qu”à travers leave (la façon normale de sortir d”une région protégée ou d”un gestionnaire) et endfinally, plus la table de clauses. Rendu tel que Glass l”affiche dans la vue IL :
.method private hidebysig static int32 ReadCount(string path) cil managed
{
.locals init (int32 n)
IL_0000: ldc.i4.0
IL_0001: stloc.0
.try
{
.try
{
IL_0002: ldarg.0
IL_0003: call string System.IO.File::ReadAllText(string)
IL_0008: call int32 System.Int32::Parse(string)
IL_000d: stloc.0
IL_000e: leave.s IL_001e
}
catch System.FormatException
{
IL_0010: pop
IL_0011: ldc.i4.m1
IL_0012: stloc.0
IL_0013: leave.s IL_001e
}
}
finally
{
IL_0015: ldstr "done"
IL_001a: call void System.Console::WriteLine(string)
IL_001f: endfinally
}
IL_001e: ldloc.0
IL_001f: ret
}
Cette imbrication est la sortie de Glass. L”entrée est la table de clauses, qui ne porte aucune accolade — seulement deux lignes :
Clause 1 kind=EXCEPTION TryOffset=0x0002 TryLength=0x000e HandlerOffset=0x0010 HandlerLength=0x0005 ClassToken=FormatException
Clause 2 kind=FINALLY TryOffset=0x0002 TryLength=0x0013 HandlerOffset=0x0015 HandlerLength=0x0009 ClassToken=0
Chaque clause a la même forme : un type (kind), la région protégée sous la forme d”un décalage plus une longueur (Try), la région du gestionnaire sous la forme d”un décalage plus une longueur (Handler) et un champ supplémentaire dont le sens dépend du type — un jeton de classe pour un catch typé, un décalage de filtre pour un catch filtré, et rien (zéro) pour finally et fault. C”est tout l”enregistrement. Tout ce qu”un décompilateur affiche sur la gestion des exceptions est dérivé de ces nombres.
Les quatre types
Le champ kind est un petit indicateur avec exactement quatre valeurs significatives, et elles constituent toute la taxonomie de la gestion des exceptions du CLR :
EXCEPTION(0x0000) — un catch typé. Le champ supplémentaire est un jeton de classe ; le gestionnaire s”exécute si l”objet levé est assignable à ce type. C”estcatch (FormatException).FILTER(0x0001) — un catch avec une clausewhen. Le champ supplémentaire est un décalage de filtre : un bloc d”IL qui s”exécute avec l”exception sur la pile et renvoie 1 (exécuter le gestionnaire) ou 0 (continuer la recherche). C”estcatch (E e) when (cond).FINALLY(0x0002) — un gestionnaire qui s”exécute à chaque sortie de la région protégée, normale ou exceptionnelle. Le gestionnaire se termine parendfinally. C”estfinally.FAULT(0x0004) — un gestionnaire qui ne s”exécute qu”à la sortie exceptionnelle. Comme un finally qui est ignoré sur le chemin normal. Il se termine aussi parendfinally(il n”y a pas deendfaultdistinct). C# n”a aucun mot-clé pour cela.
La clause fault est la plus intéressante, parce que vous ne pouvez pas l”écrire. Le compilateur l”émet. Lorsque vous écrivez un itérateur ou une méthode async, le MoveNext généré de la machine à états a besoin d”un nettoyage qui s”exécute si le corps lève une exception mais pas s”il se termine normalement et se suspend — et c”est exactement un gestionnaire fault. Glass l”affiche honnêtement dans la vue IL sous la forme fault { }, et lorsqu”il reconstruit le C# de plus haut niveau, il replie le fault dans la sémantique try/finally que représente la machine à états. Voir une clause fault dans une méthode où vous ne vous attendiez pas à en trouver une est généralement un signe que vous regardez du code abaissé généré par le compilateur.
L”ordre et l”imbrication sont décidés par la table, pas par les accolades
Regardez de nouveau les deux lignes de clauses. Les deux commencent leur région protégée à 0x0002, mais leurs longueurs diffèrent : le catch protège 0x0002..0x0010, tandis que le finally protège 0x0002..0x0015 — une plage qui contient le gestionnaire du catch. Cette inclusion est la façon dont Glass sait que la structure est un try/catch interne enveloppé par un try/finally externe, plutôt que deux gestionnaires frères sur le même try. Les accolades n”ont jamais été stockées ; la géométrie des plages de décalages, elle, l”a été.
L”ordre compte tout autant. Le runtime parcourt la table de clauses de haut en bas et prend la première clause dont la région protégée couvre l”instruction fautive et dont le type ou le filtre correspond. Le compilateur doit donc — et c”est ce qu”il fait — émettre les clauses de la plus spécifique à la moins spécifique : un catch (ArgumentNullException) avant un catch (ArgumentException), et les clauses d”un try interne avant celles du try qui l”enveloppe. Si un décompilateur les réordonnait, il changerait quel gestionnaire l”emporte. Glass préserve l”ordre de la table et reconstruit l”imbrication à partir des plages, de sorte que la chaîne de catch que vous relisez se déclenche dans la même séquence que celle qu”utiliserait le runtime.
Le lire depuis la CLI
Vous n”avez pas besoin de l”interface graphique pour inspecter la table de clauses. Demandez à glass export la méthode en IL et les régions sont rendues avec leurs limites intactes :
$ glass export ./App.dll --member "M:App.Program.ReadCount(System.String)" --il
La sortie montre les portées .try / catch / finally que Glass a dérivées des lignes de clauses, avec chaque cible de leave et le endfinally à leur place. Enlevez --il et vous obtenez le C# reconstruit, où ces deux mêmes clauses sont réaffichées sous la forme du try/catch/finally imbriqué. Pour une méthode que vous soupçonnez d”avoir été générée par le compilateur — un MoveNext d”itérateur, par exemple — la vue IL est l”endroit où apparaîtra une clause fault { } que la surface C# ne nomme jamais.
Mises en garde et là où ça se complique
Quelques limites honnêtes. La table de clauses n”enregistre que les régions physiques que le compilateur a émises, et le compilateur est libre de les partager et de les fusionner. Un seul finally peut protéger plusieurs blocs logiquement distincts ; un catch qui ne fait que relancer peut avoir été entièrement optimisé et supprimé. Les accolades reconstruites reflètent donc ce que le compilateur a produit, ce qui est fidèle à l”IL mais pas toujours une correspondance caractère par caractère avec le code source d”origine.
Les clauses de filtre (when) portent leur condition sous la forme d”une région d”IL distincte plutôt que d”un jeton, donc récupérer catch (E e) when (cond) signifie lire ce bloc de filtre et son endfilter — un sujet plus profond à part entière. Et les clauses fault, par conception, n”ont aucune orthographe en C# : Glass les replie soit dans le sens try/finally d”une machine à états, soit, dans de l”IL écrit à la main qui n”a aucun équivalent en C#, affiche le fault { } littéralement plutôt que d”inventer un mot-clé qui n”existe pas. C”est le bon choix : la vue IL doit vous dire la vérité sur le type de clause même quand C# ne peut pas l”exprimer.
À retenir
Un bloc try/catch/finally disparaît presque lorsqu”il est compilé. Le flux d”instructions ne conserve que leave et endfinally ; la structure réelle se déplace vers une table de clauses de gestionnaires d”exception à la fin du corps de la méthode, où chaque clause est un type plus deux plages de décalages et un champ type-ou-filtre. Glass.NET lit cette table, réassocie chaque plage aux instructions qu”il a déjà décodées et imbrique les clauses par inclusion et par ordre de table pour reconstruire le try/catch/finally exact — y compris le gestionnaire fault que le CLR définit mais que C# ne peut pas écrire. C”est un coin petit et précis des métadonnées, et c”est pourquoi bien décompiler les exceptions signifie lire la table, pas les opcodes. Récupérez la version gratuite sur la page de téléchargement de Glass.NET et ouvrez la vue IL sur la prochaine méthode dont vous devez comprendre le bloc try.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.