Wie Glass die Ausnahmeregionen einer Methode liest
Ein try/catch/finally-Block hinterlässt im IL-Instruktionsstrom fast keine Spur – die geschweiften Klammern werden zu Offset-Bereichen kompiliert, die in einer separaten Klauseltabelle für Ausnahmehandler am Ende des Methodenrumpfs gespeichert sind. Dieser Artikel liest diese Tabelle Klausel für Klausel, zeigt die vier Klauselarten der CLR (einschließlich des fault-Handlers, der in C# kein Schlüsselwort hat), erklärt, warum die Reihenfolge der Klauseln entscheidet, welcher Handler gewinnt, und zeigt, wie Glass.NET rohe Offset-Bereiche wieder in verschachteltes try/catch/finally umwandelt.
Öffne irgendeine Methode mit einem try-Block in der IL-Ansicht eines Decompilers und suche nach dem try. Du wirst es nicht finden. Es gibt keinen „begin try“-Opcode, keine „catch“-Instruktion, nichts im Instruktionsstrom, das sagt, wo eine geschützte Region beginnt oder aufhört. Die geschweiften Klammern, die du geschrieben hast, wurden zu etwas ganz anderem kompiliert: einer kleinen Tabelle aus Byte-Offsets, die ans Ende des Methodenrumpfs geschraubt ist. try/catch/finally aus dieser Tabelle zu rekonstruieren ist eine der leiseren Aufgaben eines Decompilers, und es ist ein gutes Fenster dazu, wie die CLR die strukturierte Ausnahmebehandlung tatsächlich modelliert.
Die eigentliche Frage
Der IL-Instruktionsstrom ist linear. Die Ausnahmebehandlung ist es nicht – sie ist eine Menge von Regionen, manche verschachtelt, jede mit einem Handler, zu dem die Laufzeit bei einem Fehler springt. Wo lebt also diese Struktur, und wie kommt ein Leser von einer flachen Liste von Opcodes plus einer Tabelle roher Offsets zurück zum verschachtelten try/catch/finally, das ein Entwickler wiedererkennen würde?
Die Antwort ist die Klauseltabelle für Ausnahmehandler. Jede Methode, die irgendeine geschützte Region enthält, wird mit einem fat-Methodenkopf ausgegeben, dessen Flags CorILMethod_MoreSects setzen. Nach dem IL-Code – an einer 4-Byte-Grenze ausgerichtet – folgt ein Abschnitt mit Zusatzdaten, und dieser Abschnitt enthält die Klauseltabelle. Jede Klausel ist eine feste Zeile aus Feldern, und diese Zeilen sind die einzige Aufzeichnung des try, das du geschrieben hast.
Eine Klausel sind fünf Zahlen und eine Art
Nimm eine gewöhnliche Methode mit einem catch und einem 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;
}
Die Instruktionen kompilieren zu einer flachen Sequenz. Die Regionsgrenzen werden nur durch leave (der normale Weg aus einer geschützten Region oder einem Handler) und endfinally ausgedrückt, plus die Klauseltabelle. So gerendert, wie Glass es in der IL-Ansicht zeigt:
.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
}
Diese Verschachtelung ist die Ausgabe von Glass. Die Eingabe ist die Klauseltabelle, die überhaupt keine geschweiften Klammern trägt – nur zwei Zeilen:
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
Jede Klausel hat dieselbe Form: eine Art (kind), die geschützte Region als Offset plus Länge (Try), die Handler-Region als Offset plus Länge (Handler) und ein zusätzliches Feld, dessen Bedeutung von der Art abhängt – ein Klassen-Token für einen typisierten catch, ein Filter-Offset für einen gefilterten catch und nichts (null) für finally und fault. Das ist die gesamte Aufzeichnung. Alles, was ein Decompiler über die Ausnahmebehandlung ausgibt, wird aus diesen Zahlen abgeleitet.
Die vier Arten
Das Feld kind ist ein kleines Flag mit genau vier bedeutungsvollen Werten, und sie sind die gesamte Taxonomie der Ausnahmebehandlung der CLR:
EXCEPTION(0x0000) – ein typisierter catch. Das Zusatzfeld ist ein Klassen-Token; der Handler läuft, wenn das geworfene Objekt diesem Typ zuweisbar ist. Das istcatch (FormatException).FILTER(0x0001) – ein catch mit einerwhen-Klausel. Das Zusatzfeld ist ein Filter-Offset: ein Block aus IL, der mit der Ausnahme auf dem Stack läuft und 1 (Handler ausführen) oder 0 (weitersuchen) zurückgibt. Das istcatch (E e) when (cond).FINALLY(0x0002) – ein Handler, der bei jedem Verlassen der geschützten Region läuft, normal oder außergewöhnlich. Der Handler endet mitendfinally. Das istfinally.FAULT(0x0004) – ein Handler, der nur beim außergewöhnlichen Verlassen läuft. Wie ein finally, das auf dem normalen Pfad übersprungen wird. Es endet ebenfalls mitendfinally(es gibt kein separatesendfault). C# hat kein Schlüsselwort dafür.
Die fault-Klausel ist die interessante, weil du sie nicht schreiben kannst. Der Compiler gibt sie aus. Wenn du einen Iterator oder eine async-Methode schreibst, braucht das generierte MoveNext der Zustandsmaschine ein Aufräumen, das läuft, wenn der Rumpf eine Ausnahme wirft, aber nicht, wenn er sich normal beendet und aussetzt – und das ist genau ein fault-Handler. Glass zeigt es in der IL-Ansicht ehrlich als fault { }, und wenn es das höhere C# rekonstruiert, faltet es das fault zurück in die try/finally-Semantik, für die die Zustandsmaschine steht. Eine fault-Klausel in einer Methode zu sehen, in der du keine erwartet hast, ist meist ein Zeichen dafür, dass du abgesenkten, vom Compiler generierten Code betrachtest.
Reihenfolge und Verschachtelung entscheidet die Tabelle, nicht die Klammern
Sieh dir die beiden Klauselzeilen noch einmal an. Beide beginnen ihre geschützte Region bei 0x0002, aber ihre Längen unterscheiden sich: Das catch schützt 0x0002..0x0010, während das finally 0x0002..0x0015 schützt – ein Bereich, der den Handler des catch enthält. Dieses Enthaltensein ist der Weg, auf dem Glass weiß, dass die Struktur ein inneres try/catch ist, umhüllt von einem äußeren try/finally, statt zweier Geschwister-Handler am selben try. Die geschweiften Klammern wurden nie gespeichert; die Geometrie der Offset-Bereiche schon.
Die Reihenfolge zählt genauso. Die Laufzeit durchläuft die Klauseltabelle von oben nach unten und nimmt die erste Klausel, deren geschützte Region die fehlerhafte Instruktion abdeckt und deren Typ oder Filter passt. Der Compiler muss also – und tut es – die Klauseln von spezifisch nach allgemein ausgeben: ein catch (ArgumentNullException) vor einem catch (ArgumentException) und die Klauseln eines inneren try vor denen des umhüllenden try. Würde ein Decompiler sie umordnen, änderte er, welcher Handler gewinnt. Glass bewahrt die Tabellenreihenfolge und rekonstruiert die Verschachtelung aus den Bereichen, sodass die catch-Kette, die du zurückliest, in derselben Reihenfolge auslöst, die die Laufzeit verwenden würde.
Es von der CLI aus lesen
Du brauchst die grafische Oberfläche nicht, um die Klauseltabelle zu inspizieren. Lass dir von glass export die Methode in IL geben, und die Regionen werden mit intakten Grenzen gerendert:
$ glass export ./App.dll --member "M:App.Program.ReadCount(System.String)" --il
Die Ausgabe zeigt die .try / catch / finally-Gültigkeitsbereiche, die Glass aus den Klauselzeilen abgeleitet hat, mit jedem leave-Ziel und dem endfinally an seinem Platz. Lass --il weg, und du erhältst das rekonstruierte C#, in dem dieselben zwei Klauseln wieder als verschachteltes try/catch/finally ausgegeben werden. Bei einer Methode, von der du vermutest, dass sie vom Compiler generiert wurde – etwa ein MoveNext eines Iterators – ist die IL-Ansicht der Ort, an dem eine fault { }-Klausel auftaucht, die die C#-Oberfläche nie benennt.
Vorbehalte und wo es schwierig wird
Ein paar ehrliche Grenzen. Die Klauseltabelle zeichnet nur die physischen Regionen auf, die der Compiler ausgegeben hat, und der Compiler darf sie teilen und zusammenführen. Ein einzelnes finally kann mehrere logisch unterschiedliche Blöcke schützen; ein catch, das nur weiterwirft, kann vollständig wegoptimiert worden sein. Die rekonstruierten Klammern spiegeln also wider, was der Compiler produziert hat, was dem IL treu ist, aber nicht immer eine zeichengenaue Übereinstimmung mit dem ursprünglichen Quellcode.
Filterklauseln (when) tragen ihre Bedingung als separate IL-Region statt als Token, also bedeutet die Wiederherstellung von catch (E e) when (cond), diesen Filterblock und sein endfilter zu lesen – ein tieferes Thema für sich. Und fault-Klauseln haben per Entwurf keine Schreibweise in C#: Glass faltet sie entweder in die try/finally-Bedeutung einer Zustandsmaschine oder zeigt bei handgeschriebenem IL, das überhaupt kein C#-Äquivalent hat, das fault { } wörtlich, statt ein Schlüsselwort zu erfinden, das es nicht gibt. Das ist die richtige Entscheidung: Die IL-Ansicht soll dir die Wahrheit über die Klauselart sagen, selbst wenn C# sie nicht ausdrücken kann.
Fazit
Ein try/catch/finally-Block verschwindet beim Kompilieren fast. Der Instruktionsstrom behält nur leave und endfinally; die eigentliche Struktur wandert in eine Klauseltabelle für Ausnahmehandler am Ende des Methodenrumpfs, wo jede Klausel eine Art plus zwei Offset-Bereiche und ein Typ-oder-Filter-Feld ist. Glass.NET liest diese Tabelle, ordnet jeden Bereich wieder den bereits dekodierten Instruktionen zu und verschachtelt die Klauseln nach Enthaltensein und Tabellenreihenfolge, um das exakte try/catch/finally zu rekonstruieren – einschließlich des fault-Handlers, den die CLR definiert, den C# aber nicht schreiben kann. Es ist eine kleine, präzise Ecke der Metadaten, und es ist der Grund, warum Ausnahmen gut zu dekompilieren bedeutet, die Tabelle zu lesen, nicht die Opcodes. Hol dir die kostenlose Version von der Glass.NET-Downloadseite und öffne die IL-Ansicht bei der nächsten Methode, deren try-Block du verstehen musst.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.