La machine virtuelle de .NET:CLR(Common Language Runtime)

Présentation au sujet: "La machine virtuelle de .NET:CLR(Common Language Runtime)"— Transcription de la présentation:

1 La machine virtuelle de .NET:CLR(Common Language Runtime)
Pr ZEGOUR DJAMEL EDDINE Ecole Supérieure d’Informatique (ESI)

2 La machine virtuelle de .NET:CLR(Common Language Runtime)
Architecture Organisation de la mémoire Code IL et méta données générés Ensemble des instructions de la CLR

3 Architecture de la CLR C’est quoi une machine virtuelle (VM)?
Un CPU implémenté sous forme d’un programme (software) Commandes seront interprétées / JIT-compiled Autres exemples: Java-VM, Smalltalk-VM, Pascal P-Code Le CLR est une machine à pile pas de registres à la place,il y a une pile d’expressions (dans laquelle les valeurs sont chargées) esp estack Taille maximale rangée dans les méta-données de chaque méthode esp ... pointeur de la pile d’expressions La CLR exécute du bytecode JIT compilé Chaque méthode est compilée avant la première exécution (= just-in-time) Les opérandes sont adressées symboliquement en IL (information rangée dans les méta-données)

4 Architecture de la CLR: machine à pile
Exemple instruction i = i + j * 5; Suppose les valeurs suivantes de i et j locals 3 i 1 4 j Simulation instructions pile ldloc.0 Charger la variable se trouvant à l’adresse 0 (c.a.d. i) 3 lldloc.1 Charger la variable se trouvant à l’adresse 1 (c.a.d. j) 3 4 ldc.i4.5 Charger la constante 5 3 4 5 mul Multiplier les 2 éléments en sommet de pile 3 20 add Ajouter les 2 éléments en sommet de pile 23 stloc.0 Ranger l’élément en sommet de pile à l’adresse 0 A la fin de chaque instruction la pile d’expression est vide!

5 La machine virtuelle de .NET:CLR(Common Language Runtime)
Architecture Organisation de la mémoire Code IL et méta données générés Ensemble des instructions de la CLR

6 Organisation de la mémoire
Variables globales statics Représentent les champs statiques de la classe ‘program’ dans la CLR Les variables globales sont accessibles dans tout le programme Les variables globales sont adressées par des unités ‘medadata’ Ex. ldsfld Tfld charge la valeur du champ référencé par Tfld sur la pile estack Les unités ‘Metadata’ sont des valeurs à 4 octets qui référencent des lignes dans les tables ‘metadata’. Type de l’unité (1 Octet) index dans la table metadata (3 Octets)

7 Organisation de la mémoire
État d‘une méthode La CLR gère des zones séparées pour Les arguments (args) Les variables locales (locals) La pile d‘expressions (estack) Chaque appel de méthode a son propre état (MS) Les états de méthodes sont gérés dans une pile MSP P Q MSQ R MSR P appelle Q; Q appelle R Chaque paramètre et chaque variable locale occupent un espace qui dépend du type. Les adresses sont des numéros consécutifs reflétant l’ordre de déclarations Ex. ldarg.0 charge la valeur du premier argument de la méthode sur la pile estack ldloc.2 charge la valeur de la troisième variable locale sur la pile estack args locals estack État de la méthode

8 Organisation de la mémoire
Le tas (Heap) Contient les objets ‘classe’ et ‘tableau’ heap free k Les nouveaux objets sont alloués à la position free (et free est incrémenté); Ceci est fait par les instructions CIL newobj et newarr Les objets sont libérés par le ‘garbage collector’

9 Organisation de la mémoire
Les objets ‘class’ heap class X { int a, b; char c; } X obj = new X; obj adressé par le champ relatif à obj a b c Les objets ‘array’ heap int[] a = new int[4]; a adressé par la valeur d’indice relative à a a[0] a[1] a[2] a[3] Seuls les vecteurs peuvent être maniés par les directives CIL spéciales newarr, ldlen, ldelem, stelem

10 Organisation de la mémoire
Les différentes zones de données à un moment donné : Méthode P appelle Q; Q appelle R; R appelle S. MSP MSQ MSR args locals free estack k MSS Pile d’exécution Le tas Heap Méthode S en cours d’exécution Variable globales Statics

11 La machine virtuelle de .NET:CLR(Common Language Runtime)
Architecture Organisation de la mémoire Code IL et méta données générés Ensemble des instructions de la CLR

12 Code IL à générer Structure du programme à obtenir Comment l’obtenir ?
Un programme .NET compilé est un assemblage (Assembly) Un assemblage est composé de modules. En général, un seul module (=programme) Le programme est un ensemble de types (classes) Chaque type est un ensemble de méthodes Une méthode contient du code machine pour la CLR (= Common Intermediate Language (CIL)) et des méta-données sous forme de tables. Comment l’obtenir ? Nous utiliserons les classes du domaine ‘System.Reflection.Emit’ de la BCL ( .NET Base Class Library) afin de générer le IL produire les méta-données dans le format adéquat.

13 Code IL à générer public class Code {
const FieldAttributes GLOBALATTR = FieldAttributes.Assembly | FieldAttributes.Static; const FieldAttributes FIELDATTR = FieldAttributes.Assembly; const MethodAttributes METHATTR = MethodAttributes.Assembly | MethodAttributes.Static; const TypeAttributes INNERATTR = TypeAttributes.Class | TypeAttributes.NotPublic; const TypeAttributes PROGATTR = TypeAttributes.Class | TypeAttributes.Public; //----- System.Reflection.Emit objects for metadata management static AssemblyBuilder assembly; // metadata builder for the program assembly static ModuleBuilder module; // metadata builder for the program module static TypeBuilder program; // metadata builder for the main class static TypeBuilder inner; // metadata builder for the currently compiled inner class internal static ILGenerator il; // IL stream of currently compiled method //----- metadata generation internal static void CreateMetadata (Symbol sym) {... } // instruction generation /* Load the operand x onto the expression stack. */ internal static void Load (Item x) { ... } /* Generate an assignment x = y. */ internal static void Assign (Item x, Item y) {... } … }

14 Code IL à générer Chaque méthode est composée d’un flot d’instructions CIL et de méta-données comme .entrypoint, .locals, .maxstack, attributs d’accès, ... La classe System.Reflection.Emit.ILGenerator gère le flot CIL. On peut accéder au flot IL de la méthode en cours de compilation via le champ statique internal static ILGenerator il; de la classe code class ILGenerator { /* overloaded (see next slide) */ virtual void Emit (OpCode op, ...); /* for method calls */ void EmitCall ( OpCode op, MethodInfo meth, Type[] varArgs); ... } Les instructions sont définies dans la class OpCodes. static readonly OpCode LDARG0 = OpCodes.Ldarg_0, ... LDARG = OpCodes.Ldarg_S, ... LDC0 = OpCodes.Ldc_I4_0, ... ADD = OpCodes.Add, ... BEQ = OpCodes.Beq, ... ... ; Ex.: pour générer ldloc.2 Code.il.Emit(LDLOC2);

15 Code IL à générer : méthodes Emit
class ILGenerator { // use for the following IL instructions: void Emit (OpCode); // ldarg.n, ldloc.n, stloc.n, ldnull, ldc.i4.n, ld.i4.m1 // add, sub, mul, div, rem, neg, // ldlen, ldelem... , stelem... , dup, pop, ret, throw void Emit (OpCode, byte); // ldarg.s, starg.s, ldloc.s, stloc.s void Emit (OpCode, int); // ldc.i4 void Emit (OpCode, FieldInfo); // ldsfld, stsfld, ldfld, stfld void Emit (OpCode, LocalBuilder); // ldloc.s, stloc.s void Emit (OpCode, ConstructorInfo); // newobj void Emit (OpCode, Type); // newarr void Emit (OpCode, Label); // br, beq, bge, bgt, ble, blt, bne.un /* for method calls */ void EmitCall (OpCode, MethodInfo, Type[]); ... }

16 Meta-données à générer
Décrivent les propriétés des composants d’un assemblage (types, champs, méthodes, ...). La classe Code possède des champs pour gérer d’importants éléments de méta-données: static AssemblyBuilder assembly; // the program assembly static ModuleBuilder module; // the program module static TypeBuilder program; // the main class static TypeBuilder inner; // the currently compiled inner class La méthode CreateMetadata de la classe Code crée des objets méta-données à partir des nœuds de type Symbol (invoquée pour chaque symbole rajouté à la table des symboles)

17 Meta-données à générer
internal static void CreateMetadata (Symbol sym) { switch (sym.kind) { case Symbol.Kinds.Prog: AssemblyName aName = new AssemblyName(); aName.Name = sym.name; assembly = AppDomain.CurrentDomain.DefineDynamicAssembly( aName, AssemblyBuilderAccess.Save); module = assembly.DefineDynamicModule(sym.name + "Module", sym.name + ".exe"); program = module.DefineType(sym.name, TypeAttributes.Class | TypeAttributes.Public); inner = null; break; ... } Exemple1 : pour un programme

18 Meta-données à générer
Exemple2 : pour les variables globales et champs d’une structure La CLR gère les deux comme des champs (champ statique de la class ‘program’; champ de la classe courante). La méthode DefineField de TypeBuilder génère les méta-données pour les champs. internal static void CreateMetadata (Symbol sym) { switch (sym.kind) { case Symbol.Kinds.Global: if (sym.type != Tab.noType) sym.fld = program.DefineField(sym.name, sym.type.sysType, FieldAttributes.Assembly | FieldAttributes.Static); break; case Symbol.Kinds.Field: sym.fld = inner.DefineField(sym.name, sym.type.sysType, FieldAttributes.Assembly); ... } Champs additionnels pour les nœuds de type Symbol internal FieldBuilder fld; pour générer les accès aux champs (ldsfld, stsfld, ldfld, stfld).

19 La machine virtuelle de .NET:CLR(Common Language Runtime)
Architecture Organisation de la mémoire Code IL et méta données générés Ensemble des instructions de la CLR

20 Ensemble des instructions de la CLR
Langage Intermédiaire (CIL) (un sous ensemble) Très compacte: instructions sur un octet (la plupart) La plupart non typée; indications de type fait référence au type du résultat Non typée Typée ldloc.0 starg.1 add ldc.i4.3 ldelem.i2 stelem.ref Format des instructions Très simple comparé a Intel, PowerPC ou SPARC Code = { Instruction }. Instruction = opcode [ operand ]. opcode or 2 octets operand ... de type primitif ou unité metadata Exemples 0 opérande add a 2 opérandes implicites sur la pile 1 opérande ldc.i4.s 9

21 Ensemble des instructions de la CLR
Modes d’adressage Comment les opérandes sont accédés? mode d’adressage exemple Immédiat ldc.i4 123 pour les constantes Argument ldarg.s 5 pour les arguments de méthode Local ldlocs.s 12 pour les variable locales Statique ldsfld fld pour les champs statiques (fld = unité metadata ) Pile add pour les valeurs chargées dans la pile estack Relatif ldfld fld pour les objet champs (référence objet est dans estack) Indexé ldelem.i4 pour les éléments de tableau (référence tableau et indice sont dans estack) Relatif base address esp estack Indexé index

22 Ensemble des instructions de la CLR
Chargement et rangement d’arguments de méthodes Types d’opérandes b ... Octet non signé i ... Entier signé T ... Unité metadata ldarg.s b ... ..., val charger push(args[b]); ldarg.n ... ..., val charger (n = 0..3) push(args[n]); starg.s b ..., val ... Ranger args[b] = pop(); ldloc.s b ... ..., val charger push(locals[b]); ldloc.n charger (n = 0..3) push(locals[n]); Chargement et rangement de variables locales stloc.n ..., val ... Ranger (n = 0..3) locals[n] = pop(); stloc.s b Ranger locals[b] = pop();

23 Ensemble des instructions de la CLR
Chargement et rangement de variables globales ldsfld Tfld ... ..., val Charger une variable statique push(statics[Tfld]); stsfld Tfld ..., val ... Ranger une variable statique statics[Tfld] = pop(); Chargement et rangement d’objets champ stfld Tfld ..., obj, val ... Ranger un objet champ val = pop(); obj = pop(); heap[obj+Tfld] = val; ldfld Tfld ..., obj ..., val Charger un objet champ obj = pop(); push(heap[obj+Tfld]); Tfld estack adr Heap

24 Ensemble des instructions de la CLR
Chargement de constantes ldc.i4 i ... ..., i Charge une constante push(i); ldc.i4.n ... ..., n Charge une constante (n = 0..8) push(n); ldc.i4.m1 ... ..., -1 Charge la constante -1 push(-1); ldnull ... ..., null Charge la constante null push(null);

25 Exemples: chargement et rangement
args locals statics ax x gx 1 ay 1 y gy 2 p x y Code Octets estack ax = ay; ldarg.1 1 ay starg.s 0 2 - x = y; ldloc.1 1 y stloc.0 1 - gx = gy; ldsfld Tfld_gy 5 gy stsfld Tfld_gx 5 - p.x = p.y; ldloc.2 1 p ldloc.2 1 p p ldfld Tfld_y 5 p p.y stfld Tfld_x 5 -

26 Ensemble des instructions de la CLR
Arithmétiques add ..., val1, val2 ..., val1+val2 Ajouter push(pop() + pop()); sub ..., val1, val2 ..., val1-val2 Soustraire push(-pop() + pop()); mul ..., val1, val2 ..., val1*val2 Multiplier push(pop() * pop()); div ..., val1, val2 ..., val1/val2 Diviser x = pop(); push(pop() / x); rem ..., val1, val2 ..., val1%val2 Reste x = pop(); push(pop() % x); neg ..., val ..., -val Négatif push(-pop());

27 Exemples: arithmétiques
locals Code Octets Pile x x + y * 3 ldloc.0 1 x ldloc.1 1 x y ldc.i4.3 1 x y 3 mul 1 x y*3 add 1 x+y*3 1 y 2 p x 3 a int[] y 4 t1 5 t2 x++; ldloc.0 1 x ldc.i4.1 1 x 1 add 1 x+1 stloc.0 1 - x--; ldloc.0 1 x ldc.i4.m1 1 x -1 add 1 x-1 stloc.0 1 - p.x++ ldloc.2 1 p dup 1 p p ldfld Tpx 5 p p.x ldc.i4.1 1 p p.x 1 add 1 p p.x+1 stfld Tpx 5 -

28 Ensemble des instructions de la CLR
Création d‘objets newobj Tctor ... [ arg0, ..., argN ] ..., obj Nouvel objet crée un nouveau objet de type spécifié par l’unité ’constructeur’ puis exécute le constructeur (les arguments sont dans la pile) newarr TeType ..., n ..., arr Nouveau tableau crée un tableau avec l’espace pour n éléments de type spécifié par l’unité type

29 Exemples: création d’objets
locals p 1 a Code Octets Pile Person p = new Person; newobj TP() 5 p stloc.0 1 - int[] a = new int[5]; ldc.i newarr Tint 5 a stloc.1 1 -

30 Ensemble des instructions de la CLR
Accès aux tableaux estack estack ldelem.u2 ldelem.i4 ldelem.ref ..., adr, i ..., val Charger un élément de tableau i = pop(); adr = pop(); push(heap[adr+i]); type du résultat sur la pile estack: char, int, référence objet adr a i i stelem.i2 stelem.i4 stelem.ref ...,adr, i, val ... Ranger un élément de tableau val=pop(); i=pop(); adr=pop()/4+1; heap[adr+i] = val; type de l’élément à ranger: char, int, référence objet ldlen ..., adr ..., len Obtenir la longueur du tableau

31 Exemple1: accès aux tableaux
locals a int[] 1 t1 Code Octets Pile 2 t2 a[2]++ ldloc.0 1 a ldc.i4.2 1 a 2 stloc.s 2 2 a stloc.s 1 2 - ldloc.s 1 2 a ldloc.s 2 2 a 2 ldloc.s 1 2 a a ldloc.s 2 2 a a 2 ldelem.i4 1 a a[2] ldc.i4.1 1 a a[2] 1 add 1 a a[2]+1 stelem.i4 1 -

32 Exemple2: accès aux tableaux
locals a 1 b int[] int[] 2 i Code Octets Pile a[i] = b[i+1]; ldloc.0 1 a ldloc.2 1 a i ldloc.1 1 a i b ldloc.2 1 a i b i ldc.i4.1 1 a i b i 1 add 1 a i b i+1 ldelem.i4 1 a i b[i+1] stelem.i4 1 -

33 Ensemble des instructions de la CLR
Manipulation de la pile pop ..., val ... Enlever l’élément au sommet de pile dummy = pop(); dup ..., val ..., val, val Duplique l’élément au sommet de pile x = pop(); push(x); push(x); Branchement br i ... Branchement inconditionnel pc = pc + i pc désigne l’instruction courante; i (distance du saut) relative par rapport à la prochaine instruction b<cond> i ..., x, y Branchement conditionnel (<cond> = eq | ge | gt | le | lt | ne.un) y = pop(); x = pop(); if (x cond y) pc = pc + i;

34 Exemple: branchements
locals x 1 y Code Octets Pile if (x > y) { ... } ldloc.0 1 x ldloc.1 1 x y ble

35 Ensemble des instructions de la CLR
Appel de méthode call Tmeth ... [ arg0, ... argN ] ... [ retVal ] Appel de méthode dépiler les arguments de la pile de l’appelant estack et les mettre dans args de l’appelée; Avant de faire le retour, dépiler la valeur retournée de la pile estack de l’appelé et l’ empiler dans la pile estack de l’appelant ret ... Retour de la méthode Divers throw ..., exc ... Throw exception

36 Exemple adresses a ... 0 b ... 1 max ... 2 sum ... 3 void Main ()
int a, b, max, sum; { if (a > b) max = a; else max = b; while (a > 0) { sum = sum + a * b; a--; } static void Main () 0: ldloc.0 1: ldloc.1 2: ble 7 (=14) 7: ldloc.0 8: stloc.2 9: br 2 (=16) 14: ldloc.1 15: stloc.2 16: ldloc.0 17: ldc.i4.0 18: ble 15 (=38) 23: ldloc.3 24: ldloc.0 25: ldloc.1 26: mul 27: add 28: stloc.3 29: ldloc.0 30: ldc.i4.1 31: sub 32: stloc.0 33: br -22 (=16) 38: return adresses a ... 0 b ... 1 max ... 2 sum ... 3