Skip to content
← Tous les articles
· Delta1 Labs InteropGlass

Comment Glass lit une méthode vararg

Une méthode vararg C# déclarée avec __arglist ne stocke aucune information de type sur ses arguments variadiques : ces types ne vivent que sur chaque site d'appel, après un octet sentinelle dans la signature de l'appel. Voici comment Glass.NET lit la convention d'appel vararg, les opcodes arglist / refanyval et la signature propre à chaque site d'appel pour reconstruire __arglist(...) et la boucle ArgIterator qui la parcourt.

La plupart des développeurs C# ne tapent jamais __arglist, et c’est précisément pourquoi c’est déroutant quand un décompilateur vous le montre. Vous ouvrez un adaptateur d’interop de bas niveau dans Glass.NET et, au lieu d’un tableau params bien net, vous voyez une méthode dont la signature se perd dans ... et un corps plein d’ArgIterator. C’est la véritable convention d’appel variadique du CLR — la même convention vararg que C utilise pour printf — remontée à la surface de C#. La reconstruire est un bon test pour un décompilateur, car l’information qu’une méthode params garde au même endroit, une méthode vararg la disperse délibérément.

La vraie question

Une méthode params int[] est ordinaire. Elle prend un unique argument tableau ; le compilateur alloue le tableau au site d’appel et la méthode le lit comme n’importe quel autre tableau. Tout ce qu’il faut pour la décompiler se trouve dans la définition de la méthode.

Une méthode vararg n’est pas ordinaire. Sa définition enregistre les paramètres fixes puis une sentinelle qui dit « et un certain nombre d’arguments supplémentaires dont j’ignore les types ». Les types de ces arguments supplémentaires sont décidés par l’appelant et enregistrés uniquement dans la signature de ce site d’appel. La question à laquelle un décompilateur doit répondre est donc : étant donné une méthode dont la définition reste délibérément muette sur sa queue variadique, où vit réellement l’information de type — et comment passe-t-on de l’IL brut à __arglist(2, 3, 4) ?

La définition de la méthode garde un secret

Commençons par la méthode. Voici une somme 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;
}

Le __arglist dans la liste des paramètres n’est pas un paramètre que vous pouvez nommer : c’est le marqueur qui fait de ceci une méthode vararg. Quand Glass lit la définition de la méthode, le blob de signature commence par l’octet de convention d’appel 0x05 (VARARG) au lieu du 0x00 habituel (DEFAULT). ILDASM le rend sous la forme d’un ... après les paramètres fixes :

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

Remarquez ce qui n’est pas là : aucune mention de int, ni de trois arguments, ni d’un compte. La définition s’engage sur exactement un int32 fixe puis se déclare ouverte. C’est là le secret — et c’est pourquoi un décompilateur ne peut pas reconstruire l’appel en lisant seulement la méthode.

Lire les arguments : arglist et refanyval

Le corps est l’autre moitié. Il n’y a aucun tableau à indexer, alors la méthode parcourt les arguments entrants avec trois constructions spéciales qui correspondent une à une à des opcodes IL :

  • __arglist (l’expression) émet arglist (0xFE 0x00), qui empile un RuntimeArgumentHandle décrivant les arguments supplémentaires passés par l’appelant.
  • __refvalue(tr, int) émet refanyval (0xC2) pour extraire d’un TypedReference un pointeur managé d’un type donné, suivi d’un ldind pour charger à travers lui.
  • Ses frères __makeref et __reftype émettent mkrefany et refanytype.

Le corps décompilé découle directement de ces 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)
  // boucle :
  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 reconnaît la paire arglist → ArgIterator::.ctor et la rend par new ArgIterator(__arglist), et la paire refanyval T + ldind par __refvalue(..., T). Cela est mécanique. La partie difficile reste en amont, chez l’appelant.

Où vivent vraiment les types : le site d’appel

Compilez SumAll(1, __arglist(2, 3, 4)) et l’appel ressemble à ceci :

  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)

Lisez attentivement cette signature d’appel. Après le int32 fixe vient une sentinelle — ILDASM l’imprime sous la forme ..., le blob brut l’encode comme ELEMENT_TYPE_SENTINEL (0x41) — et ensuite les trois types int32 des arguments que cet appel précis a passés. Ces trois types ne sont pas dans la définition de la méthode ; ils sont dans le blob de signature attaché à cette instruction call, atteint via son jeton MemberRef (ou StandAloneSig). Un second site d’appel ailleurs — SumAll(9, __arglist(1.5, "x")) — porterait une queue totalement différente (float64, string) après sa propre sentinelle, contre la même méthode exactement.

Glass reconstruit donc un appel vararg en deux passes : il résout le jeton call pour trouver le nom de la méthode et ses paramètres fixes, puis il analyse la signature du site d’appel elle-même, la scinde à la sentinelle, et traite tout ce qui suit la sentinelle comme les arguments de __arglist(...), en appariant chaque type de la queue à la valeur empilée pour lui.

Signature de la définition de méthode (VARARG 0x05)int32 firstparam. fixeSENTINELLE0x41 (...)pas de types variadiques icila définition tait la queueSignature du site d'appel : call vararg ... SumAllint32 firstSENTINELLEint32int32int32types des args variadiques,par site d'appelGlass scinde à la sentinelleparam. fixes | queue variadiqueSumAll(1, __arglist(2, 3, 4))C# reconstruit
Les types des arguments variadiques sont absents de la définition de la méthode et présents uniquement dans la signature de chaque site d'appel, après un octet sentinelle ; Glass scinde là la signature de l'appel pour reconstruire les arguments de __arglist.

Le faire depuis la CLI

Vous n’avez pas besoin de l’interface pour voir cela. Pointez glass export vers l’assembly et demandez le membre en IL, puis en C# :

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

La première commande vide le corps de la méthode avec les opcodes arglist et refanyval intacts ; la seconde montre l’appelant reconstruit, où Glass a déjà résolu la signature du site d’appel et imprimé SumAll(1, __arglist(2, 3, 4)). Comme les méthodes vararg vivent presque toujours dans du code d’interop, c’est la voie rapide pour confirmer ce qu’un adaptateur transmet réellement à un point d’entrée natif — tout en statique, rien d’exécuté.

Mises en garde et là où ça se corse

Il vaut la peine d’énoncer les limites honnêtes. L’identifiant de commentaire de documentation d’une méthode vararg ne liste que ses paramètres fixes, car c’est tout ce que la définition possède : M:Program.SumAll(System.Int32) nomme la méthode même si chaque appel en passe davantage. Si vous voulez savoir ce qu’un appel donné a passé, vous devez regarder le site d’appel, et non la signature de la méthode sur laquelle vous avez cliqué.

TypedReference, ArgIterator et RuntimeArgumentHandle sont des types restreints : ils ne peuvent être ni boxés, ni stockés dans des champs, ni utilisés comme arguments génériques, si bien que le C# environnant qu’un décompilateur peut produire autour d’eux est contraint, et une boucle sur eux fortement optimisée peut ne pas retrouver exactement la forme while montrée plus haut ; Glass se rabat alors sur un affichage plus littéral des appels à ArgIterator plutôt que d’inventer un foreach que le système de types interdit. Et vararg est précisément la convention variadique native ; ce n’est pas la même chose qu’un tableau params, un params Span<T> ou une collection params, qui sont toutes des méthodes ordinaires de convention DEFAULT que Glass reconstruit sans aucune de ces mécaniques.

À retenir

Une méthode vararg cache son information la plus intéressante à l’endroit où l’on regarderait en premier. La définition ne déclare que les paramètres fixes et une sentinelle ; les types des arguments variadiques vivent dans la signature de chaque site d’appel individuel, après un octet ELEMENT_TYPE_SENTINEL, et le corps les lit via arglist et refanyval. Glass.NET reconstruit la méthode à partir de ses opcodes et l’appel à partir de la signature de son site d’appel — en résolvant le jeton pour le nom et en scindant la signature à la sentinelle pour les arguments — de sorte que vous récupérez new ArgIterator(__arglist) et __arglist(2, 3, 4) à partir d’octets qui n’ont jamais épelé l’un ou l’autre au même endroit. C’est un petit coin des métadonnées, mais c’est une illustration nette de pourquoi bien décompiler signifie lire plus que la seule méthode que vous avez sous les yeux. Récupérez la version gratuite depuis la page de téléchargement de Glass.NET et pointez-la vers le prochain adaptateur d’interop que vous devez comprendre.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.