b'\n_START_ARTICLE_\nCommon Intermediate Language\n_START_PARAGRAPH_\nCommon Intermediate Language (CIL), cunoscut\xc4\x83 anterior sub denumirea Microsoft Intermediate Language (MSIL), este limbajul de programare cel mai sc\xc4\x83zut la nivel de limbaj uman, definit de specifica\xc8\x9biile infrastructurii lingvistice comune (CLI), \xc8\x99i este utilizat de .NET Framework, .NET Core \xc8\x99i Mono. Limbile care vizeaz\xc4\x83 un mediu de rulare compatibil cu CLI se compilesaz\xc4\x83 la CIL, care este asamblat \xc3\xaentr-un cod obiect care are un format \xc3\xaen stil octet. CIL este un limbaj de asamblare orientat pe obiect \xc8\x99i este \xc3\xaen \xc3\xaentregime bazat pe stiva. Bytecode-ul s\xc4\x83u este tradus \xc3\xaen cod nativ sau cel mai frecvent executat de o ma\xc8\x99in\xc4\x83 virtual\xc4\x83._NEWLINE_CIL a fost ini\xc8\x9bial cunoscut sub numele de Microsoft Intermediate Language (MSIL) \xc3\xaen timpul lans\xc4\x83rilor beta ale limbajelor .NET. Datorit\xc4\x83 standardiz\xc4\x83rii C# \xc8\x99i a infrastructurii lingvistice comune, bytecode-ul este acum cunoscut oficial ca CIL.\n_START_SECTION_\nModelul computa\xc8\x9bional\n_START_PARAGRAPH_\nCommon Intermediate Language este orientat\xc4\x83 pe obiecte \xc8\x99i bazat\xc4\x83 pe stiva. Asta \xc3\xaenseamn\xc4\x83 c\xc4\x83 datele sunt \xc3\xaempinse pe un teanc \xc3\xaen loc s\xc4\x83 fie scoase din registre ca \xc3\xaen majoritatea arhitecturilor procesorului._NEWLINE_\xc3\x8en x86 ar putea ar\xc4\x83ta astfel:_NEWLINE_add eax, edx_NEWLINE_Codul corespunz\xc4\x83tor din IL poate fi redat ca acesta, unde 0 este eax \xc8\x99i 1 este edx:_NEWLINE_ldloc.0    // push local variable 0 onto stackldloc.1    // push local variable 1 onto stackadd        // pop and add the top two stack items then push the result onto the stackstloc.0    // pop and store the top stack item to local variable 0_NEWLINE_Iat\xc4\x83 doi loc care sunt \xc3\xaempin\xc8\x99i pe stiv\xc4\x83. Atunci c\xc3\xa2nd instruc\xc8\x9biunea de ad\xc4\x83ugare este denumit\xc4\x83 operanzii sunt afi\xc8\x99a\xc8\x9bi \xc8\x99i rezultatul este \xc3\xaempins. Valoarea r\xc4\x83mas\xc4\x83 este apoi afi\xc8\x99at\xc4\x83 \xc8\x99i stocat\xc4\x83 \xc3\xaen primul loc.\n_START_SECTION_\nObiective orientate\n_START_PARAGRAPH_\nAceasta se extinde \xc8\x99i la conceptele orientate pe obiect. Ave\xc8\x9bi posibilitatea s\xc4\x83 crea\xc8\x9bi obiecte, s\xc4\x83 apela\xc8\x9bi metode \xc8\x99i s\xc4\x83 utiliza\xc8\x9bi alte tipuri de membri, cum ar fi c\xc3\xa2mpurile. _NEWLINE_CIL este proiectat s\xc4\x83 fie orientat pe obiecte \xc8\x99i fiecare metod\xc4\x83 are nevoie (cu unele excep\xc8\x9bii) s\xc4\x83 locuiasc\xc4\x83 \xc3\xaentr-o clas\xc4\x83. De asemenea, aceast\xc4\x83 metod\xc4\x83 static\xc4\x83:_NEWLINE_.class public Foo{_NEWLINE_    .method public static int32 Add(int32, int32) cil managed_NEWLINE_    {_NEWLINE_        .maxstack 2_NEWLINE_        ldarg.0 // load the first argument;_NEWLINE_        ldarg.1 // load the second argument;_NEWLINE_        add     // add them;_NEWLINE_        ret     // return the result;_NEWLINE_    }}_NEWLINE_Aceast\xc4\x83 metod\xc4\x83 nu necesit\xc4\x83 declararea unei instan\xc8\x9be a Foo deoarece este static\xc4\x83. Aceasta \xc3\xaenseamn\xc4\x83 c\xc4\x83 apar\xc8\x9bine clasei \xc8\x99i poate fi folosit ca acesta \xc3\xaen C#:_NEWLINE_int r = Foo.Add(2, 3);    // 5_NEWLINE_\xc3\x8en CIL:_NEWLINE_ldc.i4.2ldc.i4.3call int32 Foo::Add(int32, int32)stloc.0\n_START_SECTION_\nClase de instan\xc8\x9b\xc4\x83\n_START_PARAGRAPH_\nO clas\xc4\x83 de instan\xc8\x9b\xc4\x83 con\xc8\x9bine cel pu\xc8\x9bin un constructor \xc8\x99i un membru al instan\xc8\x9bei. Aceast\xc4\x83 clas\xc4\x83 are un set de metode care reprezint\xc4\x83 ac\xc8\x9biunile unui obiect auto._NEWLINE_.class public Car{_NEWLINE_    .method public specialname rtspecialname instance void .ctor(int32, int32) cil managed_NEWLINE_    {_NEWLINE_        /* Constructor */_NEWLINE_    }_NEWLINE__NEWLINE_    .method public void Move(int32) cil managed_NEWLINE_    {_NEWLINE_        /* Omitting implementation */_NEWLINE_    }_NEWLINE__NEWLINE_    .method public void TurnRight() cil managed_NEWLINE_    {_NEWLINE_        /* Omitting implementation */_NEWLINE_    }_NEWLINE__NEWLINE_    .method public void TurnLeft() cil managed_NEWLINE_    {_NEWLINE_        /* Omitting implementation */_NEWLINE_    }_NEWLINE__NEWLINE_    .method public void Brake() cil managed_NEWLINE_    {_NEWLINE_        /* Omitting implementation */_NEWLINE_    }}\n_START_SECTION_\nCrearea obiectelor\n_START_PARAGRAPH_\n\xc3\x8en instan\xc8\x9bele de clas\xc4\x83 C# sunt create astfel:_NEWLINE_Car myCar = new Car(1, 4); _NEWLINE_Car yourCar = new Car(1, 3);_NEWLINE_Aceste afirma\xc8\x9bii sunt aproximativ acelea\xc8\x99i cu aceste instruc\xc8\x9biuni:_NEWLINE_ldc.i4.1ldc.i4.4newobj instance void Car::.ctor(int, int)stloc.0    // myCar = new Car(1, 4);ldc.i4.1ldc.i4.3newobj instance void Car::.ctor(int, int)stloc.1    // yourCar = new Car(1, 3);\n_START_SECTION_\nInvoc\xc3\xa2nd metodele instan\xc8\x9bei\n_START_PARAGRAPH_\nMetode de instan\xc8\x9b\xc4\x83 sunt invocate ca cea care urmeaz\xc4\x83:_NEWLINE_myCar.Move(3);_NEWLINE_\xc3\x8en CIL:_NEWLINE_ldloc.0    // Load the object "myCar" on the stackldc.i4.3call instance void Car::Move(int32)\n_START_SECTION_\nExemplu\n_START_PARAGRAPH_\nMai jos este un program de baz\xc4\x83 Program Hello, world! scris \xc3\xaen CIL. Acesta va afi\xc8\x99a \xc8\x99irul "Hello, world!"._NEWLINE_.assembly Hello {}.assembly extern mscorlib {}.method static void Main(){_NEWLINE_    .entrypoint_NEWLINE_    .maxstack 1_NEWLINE_    ldstr "Hello, world!"_NEWLINE_    call void [mscorlib]System.Console::WriteLine(string)_NEWLINE_    ret}_NEWLINE_Urm\xc4\x83torul cod este mai complex \xc3\xaen num\xc4\x83rul de opcode._NEWLINE_static void Main(string[] args){_NEWLINE_    for (int i = 2; i < 1000; i++)_NEWLINE_    {_NEWLINE_        for (int j = 2; j < i; j++)_NEWLINE_        {_NEWLINE_             if (i % j == 0)_NEWLINE_                 goto outer;_NEWLINE_        }_NEWLINE_        Console.WriteLine(i);_NEWLINE_        outer:;_NEWLINE_    }}_NEWLINE_\xc3\x8en sintaxa CIL se arat\xc4\x83 astfel:_NEWLINE_.method private hidebysig static void Main(string[] args) cil managed{_NEWLINE_    .entrypoint_NEWLINE_    .maxstack  2_NEWLINE_    .locals init (int32 V_0,_NEWLINE_                  int32 V_1)_NEWLINE__NEWLINE_              ldc.i4.2_NEWLINE_              stloc.0_NEWLINE_              br.s       IL_001f_NEWLINE_    IL_0004:  ldc.i4.2_NEWLINE_              stloc.1_NEWLINE_              br.s       IL_0011_NEWLINE_    IL_0008:  ldloc.0_NEWLINE_              ldloc.1_NEWLINE_              rem_NEWLINE_              brfalse.s  IL_001b_NEWLINE_              ldloc.1_NEWLINE_              ldc.i4.1_NEWLINE_              add_NEWLINE_              stloc.1_NEWLINE_    IL_0011:  ldloc.1_NEWLINE_              ldloc.0_NEWLINE_              blt.s      IL_0008_NEWLINE_              ldloc.0_NEWLINE_              call       void [mscorlib]System.Console::WriteLine(int32)_NEWLINE_    IL_001b:  ldloc.0_NEWLINE_              ldc.i4.1_NEWLINE_              add_NEWLINE_              stloc.0_NEWLINE_    IL_001f:  ldloc.0_NEWLINE_              ldc.i4     0x3e8_NEWLINE_              blt.s      IL_0004_NEWLINE_              ret}_NEWLINE_Aceasta este doar o reprezentare a modului \xc3\xaen care arat\xc4\x83 CIL aproape de nivelul VM. C\xc3\xa2nd sunt compilate, metodele sunt stocate \xc3\xaen tabele \xc8\x99i instruc\xc8\x9biunile sunt stocate ca octe\xc8\x9bi \xc3\xaen interiorul ansamblului, care este un executabil portabil (PE).\n_START_SECTION_\nGenera\xc8\x9bie\n_START_PARAGRAPH_\nUn ansamblu CIL \xc8\x99i instruc\xc8\x9biuni sunt generate fie de un compilator, fie de un utilitar numit IL Assembler (ILAsm) care este livrat \xc3\xaempreun\xc4\x83 cu mediul de execu\xc8\x9bie._NEWLINE_CIL-ul asamblat poate fi deasemenea dezasamblat \xc3\xaen cod din nou folosind IL Disasembler (ILDASM). Exist\xc4\x83 \xc8\x99i alte instrumente, cum ar fi .NET Reflector, care pot decompila CIL \xc3\xaentr-un limbaj de nivel \xc3\xaenalt (de ex., C # sau Visual Basic). Acest lucru face CIL o \xc8\x9bint\xc4\x83 foarte u\xc8\x99oar\xc4\x83 pentru inginerie invers\xc4\x83. Aceast\xc4\x83 tr\xc4\x83s\xc4\x83tur\xc4\x83 este partajat\xc4\x83 cu Java bytecode. Cu toate acestea, exist\xc4\x83 instrumente care pot ucide codul \xc8\x99i \xc3\xael pot face astfel \xc3\xaenc\xc3\xa2t codul s\xc4\x83 nu poat\xc4\x83 fi u\xc8\x99or de citit, dar \xc3\xaenc\xc4\x83 s\xc4\x83 poat\xc4\x83 fi rulat.\n_START_SECTION_\nCompila\xc8\x9bie exact\xc4\x83 \xc3\xaen timp\n_START_PARAGRAPH_\nCompila\xc8\x9bia Just-in-Time (JIT) implic\xc4\x83 transformarea codului de byte \xc3\xaen cod imediat executabil de c\xc4\x83tre procesor. Conversia se realizeaz\xc4\x83 treptat \xc3\xaen timpul execu\xc8\x9biei programului. Compila\xc8\x9bia JIT ofer\xc4\x83 optimizarea specific\xc4\x83 mediului, siguran\xc8\x9ba tipului de execu\xc8\x9bie \xc8\x99i verificarea asambl\xc4\x83rii. Pentru a realiza acest lucru, compilatorul JIT examineaz\xc4\x83 metadatele de asamblare pentru orice acces ilegal \xc8\x99i trateaz\xc4\x83 \xc3\xaenc\xc4\x83lc\xc4\x83rile adecvate.\n_START_SECTION_\nCompila\xc8\x9bie \xc3\xaen timp real\n_START_PARAGRAPH_\nIntervalele de execu\xc8\x9bie compatibile cu CLI au, de asemenea, op\xc8\x9biunea de a efectua o compilare Ahot-of-time (AOT) a unui ansamblu pentru a face executarea mai rapid\xc4\x83 prin eliminarea procesului JIT \xc3\xaen timpul rul\xc4\x83rii._NEWLINE_\xc3\x8en .NET Framework exist\xc4\x83 un instrument special numit Generatorul de imagini nativ (NGEN) care efectueaz\xc4\x83 AOT. \xc3\x8en Mono exist\xc4\x83, de asemenea, o op\xc8\x9biune de a face un AOT.\n_START_SECTION_\nInstruc\xc8\x9biuni pentru pointer - C++/CLI\n_START_PARAGRAPH_\nO diferen\xc8\x9b\xc4\x83 notabil\xc4\x83 fa\xc8\x9b\xc4\x83 de octetul Java este c\xc4\x83 CIL vine cu ldind, stind, ldloca \xc8\x99i numeroase instruc\xc8\x9biuni de apel care sunt suficiente pentru manipularea indicilor de date/func\xc8\x9bii necesare pentru a compila codul C/C++ \xc3\xaen CIL._NEWLINE_class A {_NEWLINE_   public: virtual void __stdcall meth() {}};void test_pointer_operations(int param) {_NEWLINE_int k = 0;_NEWLINE_int * ptr = &k;_NEWLINE_*ptr = 1;_NEWLINE_ptr = &param;_NEWLINE_*ptr = 2;_NEWLINE_A a;_NEWLINE_A * ptra = &a;_NEWLINE_ptra->meth();}_NEWLINE_Codul corespunz\xc4\x83tor din CIL poate fi redat astfel:_NEWLINE_.method assembly static void modopt([mscorlib]System.Runtime.CompilerServices.CallConvCdecl) _NEWLINE_        test_pointer_operations(int32 param) cil managed{_NEWLINE_  .vtentry 1 : 1_NEWLINE_  // Code size       44 (0x2c)_NEWLINE_  .maxstack  2_NEWLINE_  .locals ([0] int32* ptr,_NEWLINE_           [1] valuetype A* V_1,_NEWLINE_           [2] valuetype A* a,_NEWLINE_           [3] int32 k)// k = 0;_NEWLINE_  IL_0000:  ldc.i4.0 _NEWLINE_  IL_0001:  stloc.3// ptr = &k;_NEWLINE_  IL_0002:  ldloca.s   k // load local\'s address instruction_NEWLINE_  IL_0004:  stloc.0// *ptr = 1;_NEWLINE_  IL_0005:  ldloc.0_NEWLINE_  IL_0006:  ldc.i4.1_NEWLINE_  IL_0007:  stind.i4 // indirection instruction// ptr = &param_NEWLINE_  IL_0008:  ldarga.s   param // load parameter\'s address instruction_NEWLINE_  IL_000a:  stloc.0// *ptr = 2_NEWLINE_  IL_000b:  ldloc.0_NEWLINE_  IL_000c:  ldc.i4.2_NEWLINE_  IL_000d:  stind.i4// a = new A;_NEWLINE_  IL_000e:  ldloca.s   a_NEWLINE_  IL_0010:  call       valuetype A* modopt([mscorlib]System.Runtime.CompilerServices.CallConvThiscall) \'A.{ctor}\'(valuetype A* modopt([mscorlib]System.Runtime.CompilerServices.IsConst) modopt([mscorlib]System.Runtime.CompilerServices.IsConst))_NEWLINE_  IL_0015:  pop// ptra = &a;_NEWLINE_  IL_0016:  ldloca.s   a_NEWLINE_  IL_0018:  stloc.1// ptra->meth();_NEWLINE_  IL_0019:  ldloc.1_NEWLINE_  IL_001a:  dup_NEWLINE_  IL_001b:  ldind.i4 // reading the VMT for virtual call_NEWLINE_  IL_001c:  ldind.i4_NEWLINE_  IL_001d:  calli      unmanaged stdcall void modopt([mscorlib]System.Runtime.CompilerServices.CallConvStdcall)(native int)_NEWLINE_  IL_0022:  ret} // end of method \'Global Functions\'::test_pointer_operations'