Skip to content
← Todas las publicaciones
· Delta1 Labs DecompilationGlass

Cómo lee Glass las regiones de excepción de un método

Un bloque try/catch/finally casi no deja rastro en el flujo de instrucciones IL: las llaves se compilan en rangos de desplazamiento guardados en una tabla de cláusulas de controladores de excepción aparte, al final del cuerpo del método. Este artículo lee esa tabla cláusula a cláusula, muestra los cuatro tipos de cláusula del CLR (incluido el controlador fault, que no tiene palabra clave en C#), explica por qué el orden de las cláusulas decide qué controlador gana y muestra cómo Glass.NET convierte los rangos de desplazamiento crudos de vuelta en try/catch/finally anidados.

Abre cualquier método con un bloque try en la vista IL de un decompilador y busca el try. No lo encontrarás. No hay ningún opcode “begin try”, ninguna instrucción “catch”, nada en el flujo de instrucciones que diga dónde empieza o termina una región protegida. Las llaves que escribiste se compilaron en otra cosa por completo: una pequeña tabla de desplazamientos en bytes atornillada al final del cuerpo del método. Reconstruir try/catch/finally a partir de esa tabla es una de las cosas más silenciosas que hace un decompilador, y es una buena ventana a cómo modela realmente el CLR el manejo estructurado de excepciones.

La pregunta real

El flujo de instrucciones IL es lineal. El manejo de excepciones no lo es: es un conjunto de regiones, algunas anidadas, cada una con un controlador al que el runtime salta ante un fallo. Entonces, ¿dónde vive esa estructura y cómo llega un lector desde una lista plana de opcodes más una tabla de desplazamientos crudos de vuelta al try/catch/finally anidado que un desarrollador reconocería?

La respuesta es la tabla de cláusulas de controladores de excepción. Todo método que contiene alguna región protegida se emite con una cabecera de método fat (gorda), cuyos indicadores activan CorILMethod_MoreSects. Después del código IL —alineado a un límite de 4 bytes— viene una sección de datos extra, y esa sección contiene la tabla de cláusulas. Cada cláusula es una fila de campos fija, y esas filas son el único registro del try que escribiste.

Una cláusula son cinco números y un tipo

Toma un método corriente con un catch y 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;
}

Las instrucciones se compilan en una secuencia plana. Los límites de las regiones se expresan solo a través de leave (la forma normal de salir de una región protegida o de un controlador) y endfinally, más la tabla de cláusulas. Renderizado como lo muestra Glass en la vista 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
}

Ese anidamiento es la salida de Glass. La entrada es la tabla de cláusulas, que no lleva ninguna llave: solo dos filas:

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

Cada cláusula tiene la misma forma: un tipo (kind), la región protegida como un desplazamiento más una longitud (Try), la región del controlador como un desplazamiento más una longitud (Handler) y un campo extra cuyo significado depende del tipo: un token de clase para un catch con tipo, un desplazamiento de filtro para un catch filtrado y nada (cero) para finally y fault. Ese es todo el registro. Todo lo que un decompilador imprime sobre el manejo de excepciones se deriva de estos números.

Los cuatro tipos

El campo kind es un pequeño indicador con exactamente cuatro valores con significado, y son toda la taxonomía del manejo de excepciones del CLR:

  • EXCEPTION (0x0000) — un catch con tipo. El campo extra es un token de clase; el controlador se ejecuta si el objeto lanzado es asignable a ese tipo. Esto es catch (FormatException).
  • FILTER (0x0001) — un catch con una cláusula when. El campo extra es un desplazamiento de filtro: un bloque de IL que se ejecuta con la excepción en la pila y devuelve 1 (ejecutar el controlador) o 0 (seguir buscando). Esto es catch (E e) when (cond).
  • FINALLY (0x0002) — un controlador que se ejecuta en cada salida de la región protegida, normal o excepcional. El controlador termina en endfinally. Esto es finally.
  • FAULT (0x0004) — un controlador que se ejecuta solo en la salida excepcional. Como un finally que se omite en la vía normal. También termina en endfinally (no hay un endfault separado). C# no tiene palabra clave para esto.

La cláusula fault es la interesante, porque no la puedes escribir. El compilador la emite. Cuando escribes un iterador o un método async, el MoveNext generado de la máquina de estado necesita una limpieza que se ejecute si el cuerpo lanza una excepción pero no si se completa normalmente y se suspende, y eso es exactamente un controlador fault. Glass lo muestra con honestidad en la vista IL como fault { }, y cuando reconstruye el C# de más alto nivel pliega el fault de vuelta en la semántica try/finally que representa la máquina de estado. Ver una cláusula fault en un método en el que no esperabas que la hubiera suele ser señal de que estás mirando código reducido generado por el compilador.

Disposición del cuerpo del métodocabecera fatindicador MoreSectsflujo de instrucciones ILIL_0000 .. IL_001ftabla de cláusulas EHsección de datos extraFilas de cláusulas (sin llaves, solo desplazamientos)EXCEPTION FormatExceptiontry 0x0002+0x000e handler 0x0010+0x0005FINALLYtry 0x0002+0x0013 handler 0x0015+0x0009try { } catch { } finally { }anidado por rango de desplazamiento,ordenado de dentro hacia fueraLas dos cláusulas comparten el mismo inicio de try (0x0002). El catch cubre 0x0002..0x0010;el finally cubre 0x0002..0x0015, que incluye al catch, así que Glass anida elcatch dentro de la región protegida del finally, tal como lo escribió el código fuente.Tipos de cláusula:EXCEPTION · FILTER · FINALLY · FAULT (sin palabra clave en C#)
El cuerpo de un método guarda su estructura de excepciones como una tabla de cláusulas de rangos de desplazamiento en bytes, no como instrucciones; Glass asigna cada rango sobre el IL decodificado y anida las cláusulas por contención para reconstruir try/catch/finally.

El orden y el anidamiento los decide la tabla, no las llaves

Mira de nuevo las dos filas de cláusulas. Ambas empiezan su región protegida en 0x0002, pero sus longitudes difieren: el catch protege 0x0002..0x0010, mientras que el finally protege 0x0002..0x0015, un rango que contiene al controlador del catch. Esa contención es como sabe Glass que la estructura es un try/catch interno envuelto por un try/finally externo, en lugar de dos controladores hermanos sobre el mismo try. Las llaves nunca se guardaron; la geometría de los rangos de desplazamiento sí.

El orden importa igual de mucho. El runtime recorre la tabla de cláusulas de arriba abajo y toma la primera cláusula cuya región protegida cubre la instrucción que falla y cuyo tipo o filtro coincide. Así que el compilador debe —y lo hace— emitir las cláusulas de más específica a menos específica: un catch (ArgumentNullException) antes que un catch (ArgumentException), y las cláusulas de un try interno antes que las del try que lo envuelve. Si un decompilador las reordenara, cambiaría qué controlador gana. Glass preserva el orden de la tabla y reconstruye el anidamiento a partir de los rangos, de modo que la cadena de catch que lees de vuelta se dispara en la misma secuencia que usaría el runtime.

Leerlo desde la CLI

No necesitas la interfaz gráfica para inspeccionar la tabla de cláusulas. Pídele a glass export el método en IL y las regiones se renderizan con sus límites intactos:

$ glass export ./App.dll --member "M:App.Program.ReadCount(System.String)" --il

La salida muestra los ámbitos .try / catch / finally que Glass derivó de las filas de cláusulas, con cada destino de leave y el endfinally en su lugar. Quita --il y obtienes el C# reconstruido, donde esas dos mismas cláusulas se imprimen de vuelta como el try/catch/finally anidado. Para un método que sospechas que fue generado por el compilador —un MoveNext de un iterador, por ejemplo— la vista IL es donde aparecerá una cláusula fault { } que la superficie de C# nunca nombra.

Advertencias y dónde se complica

Unos límites honestos. La tabla de cláusulas solo registra las regiones físicas que emitió el compilador, y el compilador es libre de compartirlas y fusionarlas. Un solo finally puede proteger varios bloques lógicamente distintos; un catch que solo relanza puede haber sido optimizado y eliminado por completo. Así que las llaves reconstruidas reflejan lo que produjo el compilador, lo cual es fiel al IL pero no siempre una coincidencia carácter por carácter con el código fuente original.

Las cláusulas de filtro (when) llevan su condición como una región de IL aparte en lugar de un token, así que recuperar catch (E e) when (cond) significa leer ese bloque de filtro y su endfilter, un tema más profundo por derecho propio. Y las cláusulas fault, por diseño, no tienen grafía en C#: Glass o bien las pliega en el significado try/finally de una máquina de estado o, en IL escrito a mano que no tiene equivalente en C# en absoluto, muestra el fault { } literalmente en lugar de inventar una palabra clave que no existe. Esa es la decisión correcta: la vista IL debe decirte la verdad sobre el tipo de cláusula incluso cuando C# no puede expresarlo.

Conclusión

Un bloque try/catch/finally casi desaparece cuando se compila. El flujo de instrucciones conserva solo leave y endfinally; la estructura real se mueve a una tabla de cláusulas de controladores de excepción al final del cuerpo del método, donde cada cláusula es un tipo más dos rangos de desplazamiento y un campo de tipo-o-filtro. Glass.NET lee esa tabla, asigna cada rango de vuelta sobre las instrucciones que ya decodificó y anida las cláusulas por contención y por orden de tabla para reconstruir el try/catch/finally exacto, incluido el controlador fault que el CLR define pero que C# no puede escribir. Es un rincón pequeño y preciso de los metadatos, y es por lo que decompilar bien las excepciones significa leer la tabla, no los opcodes. Consigue la versión gratuita en la página de descarga de Glass.NET y abre la vista IL en el próximo método cuyo bloque try necesites entender.

Prueba Nebula.NET

Endurece tu código .NET en minutos — empieza con la edición gratuita.