Sysop: 1 revizi

2014-04-25T11:49:04Z

1 revizi

← Starší verze

Verze z 25. 4. 2014, 11:49

Sysop: 1 revizi

2010-10-21T17:20:18Z

1 revizi

Nová stránka

'''Common Intermediate Language''' ('''CIL''', vyslovováno jako „sil“, případně „kil“, dříve '''Microsoft Intermediate Language''', '''MSIL''') je v [[Informatika (počítačová věda)|informatice]] nejnižší člověkem čitelný programovací jazyk definovaný specifikací [[Common Language Infrastructure]] používaný projekty [[.NET Framework]] a [[Mono]]. Jazyky, které se zaměřují na CLI kompatibilní prostředí, jsou sestavovány do byte kódu ([[Bytecode]]). CIL patří mezi objektově orientované jazyky výhradně [[Zásobník (datová struktura)|zásobníkového typu]] ({{Vjazyce2|en|''stack-based''}}). Prováděn je prostřednictvím [[Virtuální stroj|virtuálního stroje]].

CIL byl původně během uvolňování beta .NET jazyků znám jako Microsoft Intermediate Language (MSIL). Vzhledem ke standardizaci [[C Sharp|C#]] a [[Common Language Infrastructure]] je byte-kód nově a oficiálně označován jako CIL.

== Základní informace ==
Při kompilování [[.NET]] programovacích jazyků je zdrojový kód přeložen do CIL kódu (nepoužívá se [[Počítačová platforma|platformně]] nebo do výpočetně specifický objektový kód). CIL je procesorově a zároveň platformě nezávislý soubor instrukcí, které mohou být realizovány v jakémkoli prostředí podporující [[Common Language Infrastructure]] (může se jednat buď o [[.NET]] runtime pro operační systém Microsoft Windows, nebo samostatně odvozené [[Mono]], které pracuje pod operačními systémy jako [[Linux]] či [[Unix]]). CIL kód je za běhu ověřován z hlediska bezpečnosti, a proto poskytuje lepší zabezpečení a spolehlivost, než nativně kompilované binární soubory.

Proces spuštění vypadá takto:

# Zdrojový kód je převeden do Common Intermediate Language, CLI ekvivalent k nižším programovacím jazykům pro CPU.
# CIL je pak převeden do byte-kódu a je vytvořeno .NET assembly.
# Po provedení .NET assembly, jeho byte kód projde skrz provozní JIT kompilátor, aby generoval nativní kód.
# Nativní kód je zpracováván pomocí procesoru.

== Instrukce ==

CIL bytecode má instrukce pro následující skupiny úloh:

* Načítání a ukládání
* Aritmetické
* Typ konverze
* Vytváření objektů a manipulaci s nimi
* Operand managementu zásobníku (push / pop)
* Kontrola převodu (větvení - Branching)
* Volání metod
* Vyhazování výjimky
* Synchronizace

== Výpočetní model ==

Common Intermediate Language je považován za objektově orientovaný jazyk zásobníkového typu ([[Zásobník (datová struktura)|stack-based]]). To znamená, že data jsou ukládána z registrů do zásobníku místo toho, aby byla odkládána do paměti jako ve většině [[Architektura procesoru|CPU architektur]].

V architektuře [[x86]] by to mohlo vypadat následovně:

<source lang=asm>
add eax, edx
mov ecx, eax
</source>

Odpovídající kód v CIL by mohl vypadat takto:

<source lang="cil">
ldloc.0
ldloc.1
add
stloc.0 // a = a + b or a += b;
</source>

V programu jsou použity dvě lokálně proměnné, které jsou přesunuty do fronty. Když je přidaná instrukce zavolána, operand je ze zásobníku vyzvednut a výsledek je na něj obratem uložen. Hodnota je pak vyzvednuta a uložena jako první lokální proměnná.

=== Objektově-orientované koncepty ===
V objektově-orientovaném konceptu můžete vytvářet objekty, volat metody a používat další typy členů, jako jsou například pole. CIL je navržen jako objektově orientovaný a všechny metody (až na výjimky) musí být obsažené v příslušné třídě.

Příklad statické metody:

<source lang="cil">
.class public Foo
{
.method public static int32 Add(int32, int32) cil managed
{
.maxstack 2
.locals init (
[0] int32 num1,
[1] int32 num2
)

ldloc.0
ldloc.1
add
stloc.0 // a = a + b or a += b;
ret // return a;
}
}
</source>

Použitá metoda nevyžaduje žádnou deklaraci instance třídy Foo, protože je statická. To znamená, že náleží do třídy a může být následně použita jako v tomto případě v C#.

<source lang="csharp">
int r = Foo.Add(2, 3); //5
</source>
V CIL
<source lang="cil">
ldc.i4.2
ldc.i4.3
call int32 Foo::Add(int32, int32)
stloc.0
</source>

==== Instance tříd ====

Instance třídy obsahuje nejméně jeden [[konstruktor]] a nějaké další členy. Tato třída má sadu metod reprezentujících akce objektu Car.

<source lang="cil">
.class public Car
{
.method public specialname rtspecialname
instance void .ctor(int32, int32) cil managed
{
/* Constructor */
}

.method public void Move(int32) cil managed
{
/* Omitting implementation */
}

.method public void TurnRight() cil managed
{
/* Omitting implementation */
}

.method public void TurnLeft() cil managed
{
/* Omitting implementation */
}

.method public void Break() cil managed
{
/* Omitting implementation */
}
}
</source>

==== Vytváření objektů ====

Instance tříd jsou v [[C sharp|C#]] vytvářeny následujícím způsobem:

<source lang="csharp">
Car myCar = new Car(1, 4);
Car yourCar = new Car(1, 3);
<source lang="csharp">

Příkazy jsou přibližně stejné jako tyto instrukce:

<source lang="cil">
ldc.i4.1
ldc.i4.4
newobj instance void Car::.ctor(int, int)
stloc.0 // myCar = new Car(1, 4);
ldc.i4.1
ldc.i4.3
newobj instance void Car::.ctor(int, int)
stloc.1 // yourCar = new Car(1, 3);
</source>

==== Vyvolání metody instance ====

Například metody jsou volány následovně:

<source lang="csharp">
myCar.Move(3);
</source>
V CIL
<source lang="cil">
ldloc.0 // Load the object "myCar" on the stack
ldc.i4.3
call instance void Car::Move(int32)
</source>

=== Metadata ===

.NET zaznamenává informace o kompilovaných třídách jako [[metadata]]. Proces čtení těchto metadat se nazývá zrcadlení ''(reflection)''. Metadata mohou být data v podobě atributů. Ty mohou být volně rozšířeny o atributy třídy, čímž se stávají velmi silným nástrojem.

== Příklad ==

Příklad je napsán v CIL a demonstruje kód „Hello, World“:

<source lang="cil">
.assembly Hello {}
.assembly extern mscorlib {}
.method static void Main()
{
.entrypoint
.maxstack 1
ldstr "Hello, world!"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
</source>

Tento kód může být porovnán s odpovídajícím kódem [[Java Bytecode]]:

<source lang="csharp">
static void Main(string[] args)
{
outer:
for (int i = 2; i < 1000; i++)
{
for (int j = 2; j < i; j++)
{
if (i % j == 0)
goto outer;
}
Console.WriteLine(i);
}
}
</source>

V CIL-syntaxi by zápis vypadal následovně:

<source lang="cil">
.method private hidebysig static void Main(string[] args) cil managed
{
.entrypoint
.maxstack 2
.locals init (int32 V_0,
int32 V_1)

IL_0000: ldc.i4.2
stloc.0
br.s IL_001f
IL_0004: ldc.i4.2
stloc.1
br.s IL_0011
IL_0008: ldloc.0
ldloc.1
rem
brfalse.s IL_0000
ldloc.1
ldc.i4.1
add
stloc.1
IL_0011: ldloc.1
ldloc.0
blt.s IL_0008
ldloc.0
call void [mscorlib]System.Console::WriteLine(int32)
ldloc.0
ldc.i4.1
add
stloc.0
IL_001f: ldloc.0
ldc.i4 0x3e8
blt.s IL_0004
ret
}
</source>

Výše je správná reprezentace toho, jak vypadá CIL blízko VM úrovně. Když jsou zkompilované metody uloženy v tabulkách a instrukce zase v bytech uvnitř assembly, který je přenosně spustitelným souborem (Portable Executable-file).

== Vývoj ==
CIL assembly a instrukce jsou generovány buď kompilátorem nebo nástrojem zvaným jako ''IL Assembler'' (ILASM). Složené IL může být také znovu rozloženo do kódu užitím IL Disassembler (ILDASM). Existují další nástroje jako [[.NET Reflektor]], které umožní dekompilaci IL do jazyků vyšší úrovně (např. C#, [[Visual Basic]]). Tato vlastnost je sdílená s Java bytecode. Ale existují nástroje, které mohou zmást kód, a to tak, že vlastní kód nemůže být rozložen, ale přesto je spustitelný.

== Kompilace just-in-time ==

Kompilace [[just-in-time]] kompilace zahrnuje vrácení byte-kódu do kódu, který je okamžitě vykonatelný pomocí [[CPU]]. Konverze je prováděna postupně v průběhu vykonávání programu. JIT kompilace nabízí specifické optimalizace daného prostředí a ověření assembly. K dosažení tohoto, JIT kompilátor zkoumá nashromážděná metadata pro nezákonné přístupy a ovládá přiměřeně rušení.

== Externí odkazy ==
* [http://www.ecma-international.org/publications/standards/Ecma-335.htm Common Language Infrastructure (Standard ECMA-335)]
* [http://msdn.microsoft.com/en-us/netframework/aa569283.aspx “ECMA C# and Common Language Infrastructure Standards” on MSDN]
* [[wikibooks:Transwiki:List_of_hello_world_programs#CIL|Hello world program in CIL]]
* [http://weblogs.asp.net/kennykerr/archive/2004/09/07/introduction-to-msil-part-1-hello-world.aspx Kenny Kerr's intro to CIL (called MSIL in the tutorial)]
* [http://msdn.microsoft.com/en-us/magazine/cc163808.aspx Speed: NGen Revs Up Your Performance With Powerful New Features -- MSDN Magazine, April 2005]
* http://en.csharp-online.net/CIL_Instruction_Set

{{Článek z Wikipedie}} [[Kategorie:Počítačové jazyky]]
[[Kategorie:.NET]]

Common Intermediate Language - Historie editací

Sysop: 1 revizi

Sysop: 1 revizi