Linux på emulerad x86 i javascript

[stekern]

GCC gör ju det om man vill men oftast är det väl något slags mellanspråk som väl iofs ofta ser ut som assembler fast mer generell.

Mig veterligen producerar GCC fortfarande alltid textuell assemblerkod som parsas av assemblern.
LLVM har dock en inbyggd assembler som kan producera elf-object direkt utan att gå via textuell parsning av assemblerkoden.

Det är korrekt att både GCC och LLVM använder sig av "mellanspråk" (IR = Intermediate Language), i GCC är det gimple och i LLVM kallas det rätt och slätt LLVM IR.
Om man vill se hur det ser ut kan man i Clang/LLVM göra såhär:

Kod: Markera allt

$ cat hello_world.c
#include <stdio.h>

int main(void)
{
        printf("hello world!\n");
}

$ clang -S -emit-llvm hello_world.c -o -
; ModuleID = 'hello_world.c'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

@.str = private unnamed_addr constant [14 x i8] c"hello world!\0A\00", align 1

define i32 @main() nounwind uwtable {
entry:
  %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([14 x i8]* @.str, i32 0, i32 0))
  ret i32 0
}

declare i32 @printf(i8*, ...)

[hanzibal]

Aha, trodde att GCC även kunde ge annan mellankod, fel av mig alltså.

Den där LLVM-koden ser ju ganska begripligt ut och inga problem att översätta till den egna assemblern/binärkoden.

Såhär kan det ser ut .NET IL:

Kod: Markera allt

//Add.il
.method static void main() cil managed
{
    .maxstack 2
    .entrypoint
    
    ldstr "The sum of 50 and 30 is = "
    call void [mscorlib]System.Console::Write (string)
    
    ldc.i4.s 50
    ldc.i4 30    
    add
    call void [mscorlib]System.Console::Write (int32)
    ret
}

Det är alltså heller ingen rocket science att översätta IL-kod till egen maskin men det blir snabbt mer komplext om man använder sig av objektorientering, externa libar (assemblies), generiska typer och sådant.

Ovan kod är iofs handknackad och man kan alltså koda direkt i IL (såklart) men även generera IL .NET IL kod runtime eftersom den JIT-kompileras (Just In Time). Det senare tycker jag är rätt coolt eftersom man då kan skriva program som skapar sin egen kod och t.ex. kan generera ny funktionalitet med allt vad det iofs innebär i säkerhetsrisk och annat men det är ju alltid en trade-off (triangeln ni vet).

Dock portar man oftast inte .NET IL utan istället dess VM i form av CLR (Common Language Runtime). Denna har portats till diverse arkitekturer, finns en hel del sådana. T.ex. TinyCLR för ARM-processorer i form av exempelvis Netduino, alla Fez-varianter, Cerb40 och en hel drös av diverse industriella SoC:ar.

Nyligen skaffade jag detta kort kallat "G120" när GHI sålde dem på intro-kampanj för 25 USD:

G120.jpg

[/url]
Det är en SoM med en hel del godis ombord, lägg särskilt märke till RAM och flash:

•Processor: NXP Cortex-M3 120MHz
•RAM: 16MBytes
•Flash: 4.5MBytes
•Embedded LCD Controller
•USB Host/device
•4-bit SD card interface
•81 GPIO
•SPI,UART and I2C
•CAN
•Analog ports
•PWM
•Full TCP/IP with Ethernet, WiFi or PPP (cellular) support
•Runs Microsoft's .NET Mico Framework with GHI's premium libraries

Ganska liten är den också 1050mil x 1500mil (26.67 mmx 38.1mm).