PhilippRados/wrecc — Gitpedia

wrecc is a small,lean x86-64 C99 compiler written from scratch. The name is a play on the word wreck which describes a rusting ship on the sea floor.
The compiler emits x86-64 assembly in AT&T syntax, it adheres to the System V ABI which I could only test for Ubuntu and Macos. There are no dependencies you only need your assembler and linker which the compiler then invokes to create the final binary.

Installation
- Pre-built binaries
- Cargo
Features
Testing
Troubleshooting
Contribution
Project goals
Resources

Installation

Pre-built binaries <a name="binaries"></a>

If you don't have the rust toolchain installed on your system you can install the latest binary (MacOs, Linux) from the releases directly:

curl --proto '=https' --tlsv1.2 -LsSf https://github.com/PhilippRados/wrecc/releases/download/v0.2.0/wrecc-installer.sh | sh

Cargo

Using cargo binstall

cargo binstall wrecc

or building from source

cargo install wrecc

Features

Since not all keywords are currently implemented wrecc uses custom standard-headers which are built directly into the binary

Preprocessor

The preprocessor implements all C99 preprocessor directives, except #line and #pragma. Most prominently it currently also misses function-like macros which are on the agenda though.

Compiler

Supported Keywords <a name="keywords"></a>

Other than that it even supports:

<details> <summary>Aggregate initialization with designated initializers</summary>

C
struct {
  union {
    int foo;
    long baz;
  } nested;
  int array[16];
} bar = { .nested.foo = 3, .array[6] = 1};

</details> <details> <summary>Function pointers</summary>

C
#include <stdio.h>

typedef int (*BinaryOperation)(int, int);
typedef struct {
  BinaryOperation add;
  BinaryOperation subtract;
} Calculator;

int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }

int main() {
  Calculator calc = {add, subtract};

  printf("Result of addition: %d\n", calc.add(10, 5));
  printf("Result of subtraction: %d\n", calc.subtract(10, 5));
}

</details> <details> <summary>Constant folding</summary>

C
char **string_offset = (char **)&"hello" + (int)(3 * 1);
int array[(long)3 * 2 - 1];

</details>

Unimplemented Features <a name="unimplemented"></a>

Aside from the missing keywords these are the main missing features:

[x] Arrays with unspecified size
Compiling multiple files at once
[ ] Raw structs/unions as function argument-/return-types
[ ] Floating point types<br>

Here is a list of all the stuff still missing: todo

Error messages <a name="errors"></a>

Wrecc also has nice looking messages. Error reporting doesn't stop after the first error. Using the --no-color option you can switch off color-highlighting in errors. Currently there are only errors and no warnings.

<table> <tr> <th>C code</th> <th>Errors</th> </tr> <tr> <td>

C
int foo(void);
int main() {
  int a = foo(1);
  long *p = a;

  return p * 2;
}

</td> <td> <img width="535" alt="error" src="https://github.com/PhilippRados/wrecc/assets/60818062/0b0e0c9f-3600-460c-9da5-1705ef0f83d9"> </td> </tr> </table>

Ast pretty-printer <a name="ast"></a>

When compiling using the --dump-ast option it prints the parse-tree

C
#define SIZE 16
void foo(char);
int main() {
  int arr[SIZE] = {1, 2};
  char p = (char)(*arr + 3);

  switch (p) {
  case 'c':
    foo(p);
  }
}

</td> <td>

Declaration:
-Decl: 'foo'
FuncDef: 'main'
-Declaration:
--Init: 'arr'
---Aggregate:
----Scalar:
-----Literal: 1
----Scalar:
-----Literal: 2
-Declaration:
--Init: 'p'
---Scalar:
----Cast: 'char'
-----Grouping:
------Binary: '+'
-------Unary: '*'
--------Ident: 'arr'
-------Literal: 3
-Switch:
--Ident: 'p'
--Block:
---Case:
----Literal: 99
----Expr:
-----FuncCall:
------Ident: 'foo'
------Ident: 'p'

</td> </tr> </table>

Inspect all options by running `wrecc --help`

Testing

Run different types of tests with make <target>. Available targets can be inspected using make help as shown below.

console
$ make help
Usage:
  make <target>
  help             Display this help
  unit-tests       Run rust unit-tests
  snapshot-tests   Run snapshot-tests located in tests/
  c-testsuite      Requires c-testsuite (https://github.com/c-testsuite/c-testsuite) and env-var C_TESTSUITE set to its path
  fuzzer           Launch afl.rs fuzzer

Troubleshooting

Reasons for wrecc not working properly on your machine:

Unsupported architecture/OS
Cannot find libc in standard library search paths (can be fixed by passing custom search path using -L <path> option)
If it's not mentioned in the unimplemented features section then please raise an issue

Contribution

If you want to help me with this compiler I would really welcome it. The easiest place to start is probably by implementing one of the missing keywords/types mentioned in the unimplemented features section. Make sure all tests still pass and implement your own if it's something new that is not already being tested.<br>
Have a look at the documentation to get a high level overview of the compiler pipeline.