Wie Glass eine vararg-Methode liest
Eine mit __arglist deklarierte C#-vararg-Methode speichert keinerlei Typinformation über ihre variadischen Argumente – diese Typen leben nur an jeder Aufrufstelle, hinter einem Sentinel-Byte in der Aufrufsignatur. So liest Glass.NET die vararg-Aufrufkonvention, die Opcodes arglist / refanyval und die aufrufstellenspezifische Signatur, um __arglist(...) und die ArgIterator-Schleife zu rekonstruieren, die sie durchläuft.
Die meisten C#-Entwickler tippen nie __arglist, und genau deshalb irritiert es, wenn ein Dekompilierer es Ihnen zeigt. Sie öffnen einen Interop-Shim auf niedriger Ebene in Glass.NET und sehen statt eines sauberen params-Arrays eine Methode, deren Signatur in ... ausläuft, und einen Rumpf voller ArgIterator. Das ist die echte variadische Aufrufkonvention der CLR – dieselbe vararg-Konvention, die C für printf verwendet – an die Oberfläche von C# gehoben. Sie zu rekonstruieren ist ein guter Test für einen Dekompilierer, denn die Information, die eine params-Methode an einer Stelle hält, verstreut eine vararg-Methode absichtlich.
Die eigentliche Frage
Eine params int[]-Methode ist gewöhnlich. Sie nimmt ein einziges Array-Argument; der Compiler reserviert das Array an der Aufrufstelle, und die Methode liest es wie jedes andere Array. Alles, was Sie zum Dekompilieren brauchen, steht in der Methodendefinition.
Eine vararg-Methode ist nicht gewöhnlich. Ihre Definition erfasst die festen Parameter und dann einen Sentinel, der sagt: „und eine gewisse Zahl zusätzlicher Argumente, deren Typen ich nicht kenne“. Die Typen dieser zusätzlichen Argumente bestimmt der Aufrufer, und sie werden nur in der Signatur dieser Aufrufstelle erfasst. Die Frage, die ein Dekompilierer beantworten muss, lautet also: Wo lebt bei einer Methode, deren Definition über ihren variadischen Schwanz absichtlich schweigt, die Typinformation wirklich – und wie kommt man von rohem IL zurück zu __arglist(2, 3, 4)?
Die Methodendefinition hütet ein Geheimnis
Beginnen wir mit der Methode. Hier ist eine vararg-Summe in 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;
}
Das __arglist in der Parameterliste ist kein Parameter, den Sie benennen können – es ist die Markierung, die daraus eine vararg-Methode macht. Wenn Glass die Methodendefinition liest, beginnt der Signatur-Blob mit dem Aufrufkonventions-Byte 0x05 (VARARG) statt dem üblichen 0x00 (DEFAULT). ILDASM stellt das als ... nach den festen Parametern dar:
.method private hidebysig static int32
SumAll(int32 first,
...) cil managed
Beachten Sie, was nicht hier steht: keine Erwähnung von int, von drei Argumenten oder einer Anzahl. Die Definition legt sich auf genau ein festes int32 fest und erklärt sich dann für offen. Das ist das Geheimnis – und der Grund, warum ein Dekompilierer den Aufruf nicht rekonstruieren kann, indem er nur die Methode liest.
Die Argumente lesen: arglist und refanyval
Der Rumpf ist die andere Hälfte. Es gibt kein Array zum Indizieren, also durchläuft die Methode die eingehenden Argumente mit drei Spezialkonstrukten, die eins zu eins auf IL-Opcodes abbilden:
__arglist(der Ausdruck) emittiertarglist(0xFE 0x00), das einenRuntimeArgumentHandleauf den Stack legt, der die vom Aufrufer übergebenen zusätzlichen Argumente beschreibt.__refvalue(tr, int)emittiertrefanyval(0xC2), um aus einerTypedReferenceeinen verwalteten Zeiger eines gegebenen Typs zu extrahieren, gefolgt von einemldind, um durch ihn hindurch zu laden.- Seine Geschwister
__makerefund__reftypeemittierenmkrefanyundrefanytype.
Der dekompilierte Rumpf ergibt sich direkt aus diesen 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)
// Schleife:
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 erkennt das Paar arglist → ArgIterator::.ctor und gibt es als new ArgIterator(__arglist) wieder, und das Paar refanyval T + ldind als __refvalue(..., T). Das ist mechanisch. Der schwierige Teil liegt weiterhin stromaufwärts, beim Aufrufer.
Wo die Typen wirklich leben: die Aufrufstelle
Kompilieren Sie SumAll(1, __arglist(2, 3, 4)), und der Aufruf sieht so aus:
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)
Lesen Sie diese Aufrufsignatur genau. Nach dem festen int32 kommt ein Sentinel – ILDASM druckt ihn als ..., der rohe Blob kodiert ihn als ELEMENT_TYPE_SENTINEL (0x41) – und dann die drei int32-Typen der Argumente, die dieser konkrete Aufruf übergeben hat. Diese drei Typen stehen nicht in der Methodendefinition; sie stehen im Signatur-Blob, der an diese call-Anweisung angehängt ist und über ihr MemberRef- (oder StandAloneSig-)Token erreicht wird. Eine zweite Aufrufstelle anderswo – SumAll(9, __arglist(1.5, "x")) – würde einen völlig anderen Schwanz (float64, string) hinter ihrem eigenen Sentinel tragen, gegen genau dieselbe Methode.
Glass rekonstruiert einen vararg-Aufruf also in zwei Durchgängen: Es löst das call-Token auf, um den Methodennamen und ihre festen Parameter zu finden, und parst dann die Aufrufstellensignatur selbst, teilt sie am Sentinel und behandelt alles nach dem Sentinel als die Argumente von __arglist(...), wobei es jeden Schwanztyp dem für ihn auf den Stack gelegten Wert zuordnet.
Von der CLI aus
Sie brauchen die Oberfläche nicht, um das zu sehen. Richten Sie glass export auf das Assembly und fordern Sie das Mitglied in IL und dann in C# an:
$ glass export ./Interop.dll --member "M:Program.SumAll(System.Int32)" --il
$ glass export ./Interop.dll --member "M:Program.Main"
Der erste Befehl gibt den Methodenrumpf mit intakten arglist- und refanyval-Opcodes aus; der zweite zeigt den rekonstruierten Aufrufer, bei dem Glass die Aufrufstellensignatur bereits aufgelöst und SumAll(1, __arglist(2, 3, 4)) gedruckt hat. Da vararg-Methoden fast immer in Interop-Code leben, ist dies der schnelle Weg, zu bestätigen, was ein Shim tatsächlich an einen nativen Einstiegspunkt weiterreicht – alles statisch, nichts ausgeführt.
Vorbehalte und wo es schwierig wird
Es lohnt sich, die ehrlichen Grenzen zu benennen. Die Dokumentationskommentar-ID einer vararg-Methode listet nur ihre festen Parameter, denn das ist alles, was die Definition hat: M:Program.SumAll(System.Int32) benennt die Methode, obwohl jeder Aufruf mehr übergibt. Wenn Sie wissen wollen, was ein bestimmter Aufruf übergeben hat, müssen Sie die Aufrufstelle ansehen, nicht die Signatur der Methode, auf die Sie geklickt haben.
TypedReference, ArgIterator und RuntimeArgumentHandle sind eingeschränkte Typen: Sie können nicht geboxt, nicht in Feldern gespeichert und nicht als generische Argumente verwendet werden, sodass das umgebende C#, das ein Dekompilierer um sie herum erzeugen kann, begrenzt ist, und eine stark optimierte Schleife über sie führt vielleicht nicht exakt in die oben gezeigte while-Form zurück; Glass weicht dann darauf aus, die ArgIterator-Aufrufe wörtlicher anzuzeigen, statt ein foreach zu erfinden, das das Typsystem verbietet. Und vararg ist speziell die native variadische Konvention; sie ist nicht dasselbe wie ein params-Array, ein params Span<T> oder eine params-Collection, die allesamt gewöhnliche Methoden mit DEFAULT-Konvention sind, die Glass ohne diese Maschinerie rekonstruiert.
Fazit
Eine vararg-Methode verbirgt ihre interessanteste Information genau dort, wo man zuerst nachsehen würde. Die Definition deklariert nur die festen Parameter und einen Sentinel; die Typen der variadischen Argumente leben in der Signatur jeder einzelnen Aufrufstelle, hinter einem ELEMENT_TYPE_SENTINEL-Byte, und der Rumpf liest sie über arglist und refanyval. Glass.NET rekonstruiert die Methode aus ihren Opcodes und den Aufruf aus seiner Aufrufstellensignatur – es löst das Token für den Namen auf und teilt die Signatur am Sentinel für die Argumente –, sodass Sie new ArgIterator(__arglist) und __arglist(2, 3, 4) aus Bytes zurückerhalten, die keines von beidem je an einer einzigen Stelle ausbuchstabiert haben. Es ist eine kleine Ecke der Metadaten, aber eine saubere Veranschaulichung dafür, warum gutes Dekompilieren bedeutet, mehr zu lesen als nur die Methode, die Sie vor sich haben. Holen Sie sich die kostenlose Version von der Glass.NET-Downloadseite und richten Sie sie auf den nächsten Interop-Shim, den Sie verstehen müssen.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.