Skip to content
← Todas las publicaciones
· Delta1 Labs InteropGlass

Cómo Glass lee un método vararg

Un método vararg de C# declarado con __arglist no almacena ninguna información de tipo sobre sus argumentos variádicos: esos tipos viven solo en cada sitio de llamada, tras un byte centinela en la firma de la llamada. Así es como Glass.NET lee la convención de llamada vararg, los opcodes arglist / refanyval y la firma de cada sitio de llamada para reconstruir __arglist(...) y el bucle ArgIterator que la recorre.

La mayoría de los desarrolladores de C# nunca escriben __arglist, y precisamente por eso resulta desconcertante cuando un descompilador se lo muestra. Abre un adaptador de interop de bajo nivel en Glass.NET y, en lugar de un prolijo array params, ve un método cuya firma se desvanece en ... y un cuerpo lleno de ArgIterator. Esta es la verdadera convención de llamada variádica del CLR —la misma convención vararg que usa C para printf— llevada a la superficie de C#. Reconstruirla es una buena prueba para un descompilador, porque la información que un método params guarda en un solo lugar, un método vararg la dispersa deliberadamente.

La verdadera pregunta

Un método params int[] es corriente. Recibe un único argumento de array; el compilador asigna el array en el sitio de llamada y el método lo lee como cualquier otro array. Todo lo que necesita para descompilarlo está en la definición del método.

Un método vararg no es corriente. Su definición registra los parámetros fijos y luego un centinela que dice «y cierto número de argumentos extra cuyos tipos desconozco». Los tipos de esos argumentos extra los decide quien llama y se registran solo en la firma de ese sitio de llamada. Así que la pregunta que un descompilador debe responder es: dado un método cuya definición calla deliberadamente sobre su cola variádica, ¿dónde vive de verdad la información de tipo, y cómo se pasa del IL en crudo a __arglist(2, 3, 4)?

La definición del método guarda un secreto

Empecemos por el método. Aquí hay una suma vararg en C#:

using System;

static int SumAll(int first, __arglist)
{
    int total = first;
    var it = new ArgIterator(__arglist);
    while (it.GetRemainingCount() > 0)
        total += __refvalue(it.GetNextArg(), int);
    return total;
}

El __arglist de la lista de parámetros no es un parámetro al que pueda poner nombre: es el marcador que convierte esto en un método vararg. Cuando Glass lee la definición del método, el blob de la firma empieza con el byte de convención de llamada 0x05 (VARARG) en lugar del habitual 0x00 (DEFAULT). ILDASM lo representa como un ... tras los parámetros fijos:

.method private hidebysig static int32
        SumAll(int32 first,
               ...) cil managed

Fíjese en lo que no está aquí: ninguna mención de int, ni de tres argumentos, ni de un recuento. La definición se compromete a exactamente un int32 fijo y luego se declara abierta. Ese es el secreto, y es la razón por la que un descompilador no puede reconstruir la llamada con solo leer el método.

Leer los argumentos: arglist y refanyval

El cuerpo es la otra mitad. No hay ningún array que indexar, así que el método recorre los argumentos entrantes con tres construcciones especiales que se corresponden una a una con opcodes de IL:

  • __arglist (la expresión) emite arglist (0xFE 0x00), que apila un RuntimeArgumentHandle que describe los argumentos extra que pasó quien llamó.
  • __refvalue(tr, int) emite refanyval (0xC2) para extraer de un TypedReference un puntero gestionado de un tipo dado, seguido de un ldind para cargar a través de él.
  • Sus hermanos __makeref y __reftype emiten mkrefany y refanytype.

El cuerpo descompilado sale directamente de estos opcodes:

.locals init (int32 total, valuetype System.ArgIterator it)
  IL_0000: ldarg.0
  IL_0001: stloc.0
  IL_0002: ldloca.s   it
  IL_0004: arglist
  IL_0005: call       instance void System.ArgIterator::.ctor(valuetype System.RuntimeArgumentHandle)
  // bucle:
  IL_000a: ldloca.s   it
  IL_000c: call       instance int32 System.ArgIterator::GetRemainingCount()
  IL_0011: brfalse.s  IL_0028
  IL_0013: ldloc.0
  IL_0014: ldloca.s   it
  IL_0016: call       instance valuetype System.TypedReference System.ArgIterator::GetNextArg()
  IL_001b: refanyval  [System.Runtime]System.Int32
  IL_0020: ldind.i4
  IL_0021: add
  IL_0022: stloc.0
  IL_0023: br.s       IL_000a

Glass reconoce la pareja arglist → ArgIterator::.ctor y la representa como new ArgIterator(__arglist), y la pareja refanyval T + ldind como __refvalue(..., T). Eso es mecánico. La parte difícil sigue estando aguas arriba, en quien llama.

Dónde viven de verdad los tipos: el sitio de llamada

Compile SumAll(1, __arglist(2, 3, 4)) y la llamada queda así:

  IL_0000: ldc.i4.1
  IL_0001: ldc.i4.2
  IL_0002: ldc.i4.3
  IL_0003: ldc.i4.4
  IL_0004: call vararg int32 Program::SumAll(int32, ..., int32, int32, int32)

Lea con atención esa firma de llamada. Tras el int32 fijo viene un centinela —ILDASM lo imprime como ..., el blob en crudo lo codifica como ELEMENT_TYPE_SENTINEL (0x41)— y luego los tres tipos int32 de los argumentos que esta llamada concreta pasó. Esos tres tipos no están en la definición del método; están en el blob de firma asociado a esta instrucción call, al que se llega por su token MemberRef (o StandAloneSig). Un segundo sitio de llamada en otro lugar —SumAll(9, __arglist(1.5, "x"))— llevaría una cola totalmente distinta (float64, string) tras su propio centinela, contra el mismísimo método.

Así que Glass reconstruye una llamada vararg en dos pasadas: resuelve el token call para encontrar el nombre del método y sus parámetros fijos, y luego analiza la firma del sitio de llamada en sí, la divide por el centinela y trata todo lo que hay tras el centinela como los argumentos de __arglist(...), emparejando cada tipo de la cola con el valor apilado para él.

Firma de la definición del método (VARARG 0x05)int32 firstparám. fijoCENTINELA0x41 (...)aquí no hay tipos variádicosla definición calla sobre la colaFirma del sitio de llamada: call vararg ... SumAllint32 firstCENTINELAint32int32int32tipos de args variádicos,por sitio de llamadaGlass divide por el centinelaparám. fijos | cola variádicaSumAll(1, __arglist(2, 3, 4))C# reconstruido
Los tipos de los argumentos variádicos están ausentes de la definición del método y solo presentes en la firma de cada sitio de llamada, tras un byte centinela; Glass divide ahí la firma de la llamada para reconstruir los argumentos de __arglist.

Hacerlo desde la CLI

No necesita la interfaz para ver esto. Apunte glass export al ensamblado y pida el miembro en IL, y luego en C#:

$ glass export ./Interop.dll --member "M:Program.SumAll(System.Int32)" --il
$ glass export ./Interop.dll --member "M:Program.Main"

El primero vuelca el cuerpo del método con los opcodes arglist y refanyval intactos; el segundo muestra el llamador reconstruido, donde Glass ya ha resuelto la firma del sitio de llamada y ha impreso SumAll(1, __arglist(2, 3, 4)). Como los métodos vararg casi siempre viven en código de interop, esta es la vía rápida para confirmar qué reenvía realmente un adaptador a un punto de entrada nativo: todo estático, nada ejecutado.

Advertencias y dónde se complica

Vale la pena enunciar los límites honestos. El ID de comentario de documentación de un método vararg solo lista sus parámetros fijos, porque eso es todo lo que tiene la definición: M:Program.SumAll(System.Int32) nombra el método aunque cada llamada pase más. Si quiere saber qué pasó una llamada concreta, debe mirar el sitio de llamada, no la firma del método en el que hizo clic.

TypedReference, ArgIterator y RuntimeArgumentHandle son tipos restringidos: no se pueden boxear, ni almacenar en campos, ni usar como argumentos genéricos, así que el C# circundante que un descompilador puede producir en torno a ellos es limitado, y un bucle sobre ellos muy optimizado puede no volver exactamente a la forma while mostrada arriba; Glass recurre a mostrar las llamadas a ArgIterator de manera más literal en vez de inventar un foreach que el sistema de tipos prohíbe. Y vararg es específicamente la convención variádica nativa; no es lo mismo que un array params, un params Span<T> o una colección params, que son todos métodos de convención DEFAULT corrientes que Glass reconstruye sin nada de esta maquinaria.

Conclusión

Un método vararg oculta su información más interesante en el sitio en el que uno miraría primero. La definición declara solo los parámetros fijos y un centinela; los tipos de los argumentos variádicos viven en la firma de cada sitio de llamada individual, tras un byte ELEMENT_TYPE_SENTINEL, y el cuerpo los lee mediante arglist y refanyval. Glass.NET reconstruye el método a partir de sus opcodes y la llamada a partir de la firma de su sitio de llamada —resolviendo el token para el nombre y dividiendo la firma por el centinela para los argumentos—, de modo que recupera new ArgIterator(__arglist) y __arglist(2, 3, 4) a partir de unos bytes que nunca deletrearon ninguna de las dos cosas en un solo lugar. Es un rincón pequeño de los metadatos, pero es una ilustración limpia de por qué descompilar bien significa leer más que el método que tiene delante. Descargue la versión gratuita desde la página de descarga de Glass.NET y apúntela al próximo adaptador de interop que necesite entender.

Prueba Nebula.NET

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