C compiler for the CLI platform

Last update: Dec 30, 2022

Related tags

Overview

Cesium

Cesium is a fully managed C compiler for CLI platform (.NET).

What? Cesium compiles standard C source code to a .NET assembly. No unmanaged/mixed mode (a-lá C++/CLI) code is generated; everything is fully managed (but may be unsafe).

Why? C programs are very useful in the modern world, and solve practical tasks. At the same time, deploying C code alongside .NET code may be tricky (especially if your application supports multiple platforms). Cesium is designed to resolve the problems of C code deployment, and lift it to the managed state (so it is cross-platform in the same way the underlying CIL code it is compiled to).

Implementation Status

TL;DR: is it ready for use?

Unfortunately, not yet. You won't be able to use Cesium for anything useful today. Probably, you'll be able to start after the next milestone is implemented. Stay tuned!

Dashboard

C17 standard compatibility: poor
- Preprocessor: only #include is supported
- Lexer: mostly works, but needs more tests and validation on its compliance
- Parser: supports about 20% of the language syntax
Compiler
- CIL code generator: basics are ready, new features get added
- PDB support: none
Standard library: a very few functions are supported
.NET SDK: none

Have a question? Welcome to the discussions section!

Looking to contribute? Check open issues with the "help wanted" label. Cesium is a big project which lives thanks to its contributors.

If you're interested in certain project area, check the per-area issue labels:

area:cil-interop: issues related to CLI interop
area:compiler: issues related to the Cesium compiler, type checker, and code analyzer
area:parser: issues related to C parsing
area:standard-support: issues related to C17 standard support
area:sdk: issues related to the Cesium .NET SDK

Sneak peek

Currently, Cesium is able to compile a "Hello, world" C17 example to a .NET assembly:

#include <stdio.h>

int main(int argc, char *argv[])
{
    puts("Hello, world!");
    return 42;
}

The next milestone is #61: sha1collisiondetection, which is 0% complete.

Documentation

Usage

$ dotnet run --project Cesium.Compiler -- <path to the input .c file> <path to the output assembly>

For example, this will generate an assembly executable by .NET 6, .NET Framework, or Mono:

$ dotnet run --project Cesium.Compiler -- Cesium.Samples/minimal.c out.exe
$ dotnet ./out.exe # run with .NET 6
$ ./out.exe # only on Windows, run with .NET Framework
$ mono ./out.exe # run with Mono

Testing

In order to test changes please run following for fast-cycle testing

$ dotnet test

And if you want to run integration tests

$ pwsh -c ./Cesium.IntegrationTests/Run-Tests.ps1 -NoBuild

(don't pass -NoBuild if you want to automatically rebuild the compiler before running the integration tests)

If you debug integration tests and want to run just single test

pwsh -c ./Cesium.IntegrationTests/Run-Tests.ps1 -TestCaseName quoted_include_fallback.c

where quoted_include_fallback.c is path within Cesium.IntegrationTests folder.

Comments

(#354) CodeGen: implement the wide architecture set
Closes #354.

TODO

[ ] present pointers as ~~long~~ CPtr<T> in codegen on Wide architecture

[ ] standard library enhancement

[x] create a CPtr<T> type

[x] add implicit conversions

[x] add codegen support

[ ] support CPtr interop

[ ] integration test
opened by ForNeVeR 0
Struct layout calculation

To statically determine struct layout (for 32b, 64b and wide architecture sets), we'll need to calculate struct layout.

I am planning to make structures have Pack = 4 / 8 and LayoutKind.Explicit for these architectures.

See the documentation on pack.

Look for number 355 in the code when implementing this.
kind:feature status:help-wanted area:compiler good-first-issue

opened by ForNeVeR 2
Wide architecture support

In scope of #132, we want to add the wide architecture support, which will use wide pointers (64-bit) everywhere.

This will require some work in the standard library to properly support those (right now, I am thinking of implementing some generic type over pointers with separate casts from normal and from wide pointers, to not recompile the stdlib for every arch separately).

When implementing, make sure to eliminate every instance of substring #354 in compiler's code and documentation.
kind:feature area:cil-interop area:compiler area:stdlib

opened by ForNeVeR 1
Assembly target architecture support
In scope of #132, we want to introduce proper support of assembly target architectures:

32b architecture set should target x86 and ARM32,

64b architecture set should target x86_64 and ARM64,

all the others should still support any CPU (same as before).

If it's impossible to emit same assembly for x64 and ARM32, or for x86_64 and ARM64, we should divide them further, thus removing the concept of an architecture set and introducing more standard concept of an architecture.

When implementing, make sure to eliminate every instance of substring #353 in compiler's code and documentation.
kind:feature status:help-wanted area:cil-interop good-first-issue
opened by ForNeVeR 0
Verification tests: check that all the gold files are used

Currently, it's easy to create some gold files (*.verified.txt) and leave them be, even if the methods they were created by were renamed or removed.

We should add some kind of verification step that will check that there are no leftover gold files.
status:help-wanted good-first-issue area:infrastructure

opened by ForNeVeR 0

Improve IL verifiability

Currently, ILVerify reports several errors in our programs. Namely, considering array/multidimensional.c integration test:

$ dotnet tool install --global dotnet-ilverify
$ pwsh Cesium.IntegrationTests/Run-Tests.ps1 -TestCaseName array/multidimensional.c
$ cd Cesium.IntegrationTests/bin
$ ilverify out_cs.exe -r "C:\Program Files\dotnet\shared\Microsoft.NETCore.App\7.0.0\*.dll" -r .\Cesium.Runtime.dll
[IL]: Error [StackUnexpected]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::.cctor()][offset 0x00000006][found Native Int][expected Int32] Unexpected type on the stack.
[IL]: Error [Unverifiable]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::main(int32, uint8**)][offset 0x00000006] Instruction cannot be verified.
[IL]: Error [InitLocals]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::main(int32, uint8**)][offset 0x00000009] initlocals must be set for verifiable methods with one or more local variables.
[IL]: Error [UnmanagedPointer]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::main(int32, uint8**)][offset 0x00000009] Unmanaged pointers are not a verifiable type.
[IL]: Error [StackByRef]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::main(int32, uint8**)][offset 0x00000020][found Native Int] Expected ByRef on the stack.
[IL]: Error [StackUnexpected]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::<SyntheticEntrypoint>(string[])][offset 0x00000002][found Native Int][expected Int32] Unexpected type on the stack.
[IL]: Error [InitLocals]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::<SyntheticEntrypoint>(string[])][offset 0x0000000A] initlocals must be set for verifiable methods with one or more local variables.
[IL]: Error [InitLocals]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::<SyntheticEntrypoint>(string[])][offset 0x00000012] initlocals must be set for verifiable methods with one or more local variables.
[IL]: Error [InitLocals]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::<SyntheticEntrypoint>(string[])][offset 0x00000013] initlocals must be set for verifiable methods with one or more local variables.
[IL]: Error [InitLocals]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::<SyntheticEntrypoint>(string[])][offset 0x0000001A] initlocals must be set for verifiable methods with one or more local variables.
[IL]: Error [InitLocals]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::<SyntheticEntrypoint>(string[])][offset 0x0000001B] initlocals must be set for verifiable methods with one or more local variables.
[IL]: Error [InitLocals]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::<SyntheticEntrypoint>(string[])][offset 0x0000001D] initlocals must be set for verifiable methods with one or more local variables.
[IL]: Error [StackUnexpected]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::<SyntheticEntrypoint>(string[])][offset 0x00000024][found address of 'uint8*'][expected Native Int] Unexpected type on the stack.
[IL]: Error [InitLocals]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::<SyntheticEntrypoint>(string[])][offset 0x00000035] initlocals must be set for verifiable methods with one or more local variables.
[IL]: Error [InitLocals]: [W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe : .<Module>::<SyntheticEntrypoint>(string[])][offset 0x0000003C] initlocals must be set for verifiable methods with one or more local variables.
15 Error(s) Verifying W:\Projects\Cesium\Cesium.IntegrationTests\bin\out_cs.exe

We should investigate whether these issues are acceptable or not.

They may be reason for the multidimensional.c test failing one time.

kind:feature status:help-wanted area:compiler

opened by ForNeVeR 0

Owner

Friedrich von Never

Engineer, programmer, gentleman.

GitHub

A Small C Compiler

8cc C Compiler Note: 8cc is no longer an active project. The successor is chibicc. 8cc is a compiler for the C programming language. It's intended to

5.8k Jan 8, 2023

A C compiler for LLVM. Supports C++11/14/1z C11

The LLVM Project is a collection of modular and reusable compiler and toolchain technologies

17.5k Jan 8, 2023

GNU Prolog is a native Prolog compiler

GNU Prolog is a native Prolog compiler with constraint solving over finite domains (FD)

64 Dec 13, 2022

Take your first step in writing a compiler.

first-step Take your first step in writing a compiler. Building from Source Before building first-step, please make sure you have installed the follow

28 Aug 20, 2022

NCC is an ANSI/ISO-compliant optimizing C compiler.

The compiler is retargetable by design, but, at present, it only produces binaries for Linux/x86_64. As the compiler ABI differs somewhat from the System V ABI used by Linux, its code cannot be linked against Linux system libraries. It does, however, provide its own (incomplete) standard ANSI/Posix C library.

0 Apr 1, 2022

nanoc is a tiny subset of C and a tiny compiler that targets 32-bit x86 machines.

nanoc is a tiny subset of C and a tiny compiler that targets 32-bit x86 machines. Tiny? The only types are: int (32-bit signed integer) char (8-

19 Nov 28, 2022

Smaller C is a simple and small single-pass C compiler

Smaller C is a simple and small single-pass C compiler, currently supporting most of the C language common between C89/ANSI C and C99 (minus some C89 and plus some C99 features).

1.2k Jan 7, 2023

Microvm is a virtual machine and compiler

The aim of this project is to create a stack based language and virtual machine for microcontrollers. A mix of approaches is used. Separate memory is used for program and variable space (Harvard architecture). An interpreter, virtual machine and compiler are available. A demostration of the interpreter in action is presented below.