// set up malloc
typedef long unsigned int size_t;
void* malloc (size_t size);

// make a typedef to a _forward declaration_ of s, not the struct itself
typedef struct s *S;

// define s
struct s {
        int i;
};

S returns_struct() {
        // this still thinks s hasn't been defined
        S my_struct = malloc(sizeof(struct s));
        my_struct->i = 1;
        return my_struct;
}
<stdin>:8:14: error: no member named 'i' in 'struct s'

When we see the definition for s, we need to update the entry for S.

Found https://github.com/c-testsuite/c-testsuite just now, it already found a bug. It would be great (once the tests are passing) to add it to the test suite.

$ cargo run
int a[]; int main() { return a * 1; }
thread 'main' panicked at 'Type::sign can only be called on integral types', src/parse/expr.rs:1149:18

The fix is to do type checking in Expr::multiplicative_expr before calling binary_promote, that solved this for additive_expr

int a[] = {1,2,3};
int main() {
    return a[2];
}

Expected behavior: returns 3
Actual behavior: returns 0
Root cause: adding 2 to a, not 2 * sizeof(int)

parse_num just keeps coming back to haunt me, I might split it up into integer and float parsing.

0E0u
thread 'main' panicked at 'internal error: entered unreachable code: parse_num should never return something besides Token::Int when called with allow_float: false', src/lex.rs:433:18

The proper thing to do is to not allow unsigned exponents.

See https://en.cppreference.com/w/c/language/restrict. We don't need to support optimizations, but the lexer and parser definitely shouldn't crash and it might be nice to add it to Qualifiers.

Expected behavior:

$ cargo run
int main(int argc, char **argv) {
    return 0 || argc;
}
$ ./a.out three args; echo $?
3

Actual behavior: returns 1
Fix: need to implement arguments to EBBs

• struct
• union
• enum

Whenever Parser::panic is called there's an infinite loop. Not sure why, it has clear termination conditions.

(osh) ~/.../rust/compiler ▶️ timeout 5s cargo run <<< 'int i, main() {} '
    Finished dev [unoptimized + debuginfo] target(s) in 0.06s
     Running `target/debug/compiler`
(osh) ~/.../rust/compiler ▶️ echo $?
124

According to the C11 standard, !x is exactly the same as x == 0 for all scalar x. It makes more sense to treat this as syntactic sugar than to try to compile it seperately in ir.rs.

• arrays of functions: int f[]()
• functions returning arrays: int f()[]
• function returning function: int f()()
• ... more?

int i;
int *p = &i;

should be legal

struct s my_s;
struct s { int i; };
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `Some(1)`,
 right: `Some(0)`', /home/joshua/.cargo/registry/src/github.com-1ecc6299db9ec823/faerie-0.11.0/src/artifact/decl.rs:453:5

Need to update all types in scope, not just typedefs :( this won't be hard but it'll be really slow

Pointers should be between declaration specifiers and declarators but instead are printed before both, i.e. the current *int () should be int *(). This is hard because it requires introspecting the types, it might be easier to print an english-like description the way cdecl does it

char *s = "hi";
<stdin>:1:11: error: cannot implicitly convert 'char[3]' to '*char'. help: use an explicit cast: (*char)

The following degrade to pointers when used in an expression context:

• Arrays
• Functions

Additionally, ids are automatically derefence (this is implemented).

Waiting on #19 since this is only an issue for degrading to pointers.

int main() {
        int i, j;
        j = 1;
}
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/libcore/option.rs:347:21

Immediate cause: src/ir.rs doesn't think j is in scope.
Root cause: Parser::compound_statement does not look at self.pending for declarations.
Proposed fix: Get rid of self.pending altogether, it's hacky and I never liked it. Replace it by making Stmt::Decl a Vec<Declaration> instead of a Box. That also allows getting rid of Option for Parser::declaration.

int main() { int i = 5, j = 0; while (i >= 0) { j += 1; i -= 1; } }
thread 'main' panicked at 'not yet implemented: almost every statement', src/ir.rs:296:18
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

• while loops in 41d7876
• continue/break in 41d7876
• do while loops in 6cb4e50
• for loops in 883e126
• switch/case/default in 4a71ada
• goto/label

Steps to reproduce:

float f = 2;
int main() {
    return f;
}

Expected behavior: exits with return code 2
Actual behavior: exits with return code 0

The issue is that the casts in the constant folding don't have a way to change the type of the token. Cast(Token::Double(2.0), Float) gets turned into Token::Double(2.0). Then when Expr::into_bytes calls Token::ctype() it gets back Double instead of Float, so Token::into_bytes stores the full precision instead of single-precision. When it's loaded from memory at runtime, it only loads the first 4 bytes, which are garbage when interpreted as a float.

The fix is to finally implement types for literals, which we need for #4 anyway.

Need to go through and look at https://github.com/CraneStation/cranelift/issues/212 more closely. It looks like cranelift decided this needs to be done by the frontend.

This is important because no one can call printf without it.

Resources:

• Rustc implementation (don't understand what it's doing): https://github.com/rust-lang/rust/blob/master/src/librustc_codegen_llvm/va_arg.rs
• rustc_codegen_cranelift implementation (pass all the arguments and hope the callee figures it out): bjorn3/rustc_codegen_cranelift@53e51ac
• Rust vararg RFC: https://github.com/rust-lang/rfcs/blob/master/text/2137-variadic.md

Not sure how to do this.

Steps to replicate:

$ cargo run -- --debug-asm
int main() {
    int i = 1;
    return i;
}

Current behavior:

function u0:0() -> i32 system_v {
    ss0 = explicit_slot 4

ebb0:
    v0 = iconst.i32 1
    stack_store v0, ss0
    v1 = stack_addr.i64 ss0
    v2 = load.i32 v1
    return v2
}

Expected behavior:

function u0:0() -> i32 system_v {
    ss0 = explicit_slot 4

ebb0:
    v0 = iconst.i32 1   ; int i = 1
    stack_store v0, ss0
    v1 = stack_addr.i64 ss0  ; return i
    v2 = load.i32 v1
    return v2
}

Section 6.10:

• 6.10.1: #if / #ifdef / #ifndef / #elif / #else / defined conditional compilation (added in #184)
• 6.10.2: #include headers
• 6.10.3: #define macros and substitutions
  • object-like macros
  • 6.10.3.1 function-like macros
    • including __VA_ARGS__
  • 6.10.3.2 and # and ## operators
  • 6.10.3.5 and undef
• 6.10.4: #line control (can be ignored for now, waiting on #152, brendanzab/codespan#157)
• 6.10.5: #error directives
• 6.10.6, 6.10.9: pragma directives (can be ignored altogether)
  • #pragma
  • _Pragma ()
• 6.10.7: # on its own (ignored)
• 6.10.8: predefined macros
  • conditional features (6.10.8.3):
    • __STDC_NO_ATOMICS__
    • __STDC_NO_COMPLEX__
    • __STDC_NO_THREADS__
    • __STDC_NO_VLA__

typedef int i;
thread 'main' panicked at 'not yet implemented: typedefs', src/parse/decl.rs:85:13

Fun fact: 'typedef' doesn't have to come first in the declaration:

$ clang -x c -
int unsigned typedef i;
$

Right now, almost every token requires a copy of the filename and it's really expensive in terms of performance.

Short term plan

Make filename a global

Mid term plan

Use Rc basically everywhere. Alternatively, store a single offset from the start of the file and calculate lines and columns lazily.

Pie in the sky architecture astronaut plan

Use multiple threads for lexer, parser, and codegen. Store a single offset from the start of the file, so Location is now copy. Handle errors in a fourth thread, which is now the only one that needs to know the filename -> no longer a global. Use a channel to send semantic errors so they no longer disrupt parsing (see #32).

It's a long shot, but it would solve a lot of different problems really elegantly without having to rewrite the internals that much, only the wrappers.

struct s my_s;
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `Some(1)`,
 right: `Some(0)`', /home/joshua/.cargo/registry/src/github.com-1ecc6299db9ec823/faerie-0.11.0/src/artifact/decl.rs:453:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

Note: this is because I'm passing an align of 0 to faerie, which it doesn't like.

https://en.cppreference.com/w/c/language/integer_constant

int main(void) {
    return 3-3;
}

expected behavior: returns 0
actual behavior: <stdin>:2:14: error: expected ';', got '-3'

int main() { int a[3] = {1, 2, 3}; }
thread 'main' panicked at 'not yet implemented: aggregate dynamic initialization', src/ir.rs:211:48

Note: the way LLVM implements this is by storing the array in static memory and then loading it into the stack when the function is called. It also loads 8 bytes at a time regardless of the type of the array (at least on x86_64).

Proposed architecture:

main loop:

• '.' => parse_float()
• digit => parse_num()

parse_num:

1. Parse radix
2. parse_int(radix)
3. check for integer suffixes (if so, return)
4. parse_float(radix)

parse_float(radix):

1. Parse fraction
2. Optionally, parse exponent
3. check for float suffixes

and then parse_int is super simple

Current behavior:

int f(int) {
    return;
}
<stdin>:1:18: error: missing parameter name in function definition (parameter 0 of type 'int')
1 error generated

Expected behavior:

int f(int) {
    return;
}
<stdin>:1:5: error: missing parameter name in function definition (parameter 0 of type 'int')
<stdin>:2:3: error: function 'f' does not return a value
2 errors generated

I have a version locally that changes main and lib to report all errors, but because the architecture wasn't designed around this, it gets thrown off by semantic errors and cuts off parsing in the middle of a grammar expression. The example above ends up going into an infinite loop because it doesn't consume the '}'.

To fix this requires distinguishing between syntactic and semantic errors, which is not going to be fun. Ideally it would be separated into a new pass, but that would be a massive headache to do at this point.

int a[] = {1, 2, 3};
thread 'main' panicked at 'not yet implemented: inferring size of unbounded array from initializer', src/ir.rs:904:21

This should be pretty easy to add.

int main() {
    return 2.5f * 2;
}

Expected: returns 5
Actual: <stdin>:2:16: error: expected ';', got 'f'

int main() {
        if (1) { 
                return 1;
        }
}
thread 'main' panicked at 'should not have a compile error: VerifierErrors([VerifierError { location: inst1, message: "invalid ebb reference ebb2" }])', src/libcore/result.rs:999:5

Compare an explicit return, which works fine:

int main() {
        if (1) { 
                return 1;
        }
        return 0;
}

function u0:0() -> i32 system_v {
ebb0:
    v0 = iconst.i32 1
    brz v0, ebb2
    jump ebb1

ebb1:
    v1 = iconst.i32 1
    return v1
}

thread 'main' panicked at 'should not have a compile error: VerifierErrors([VerifierError { location: inst1, message: "invalid ebb reference ebb2" }])', src/libcore/result.rs:999:5
stack backtrace:
   0: backtrace::backtrace::libunwind::trace
             at /cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.29/src/backtrace/libunwind.rs:88
   1: backtrace::backtrace::trace_unsynchronized
             at /cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.29/src/backtrace/mod.rs:66
   2: std::sys_common::backtrace::_print
             at src/libstd/sys_common/backtrace.rs:47
   3: std::sys_common::backtrace::print
             at src/libstd/sys_common/backtrace.rs:36
   4: std::panicking::default_hook::{{closure}}
             at src/libstd/panicking.rs:200
   5: std::panicking::default_hook
             at src/libstd/panicking.rs:214
   6: std::panicking::rust_panic_with_hook
             at src/libstd/panicking.rs:477
   7: std::panicking::continue_panic_fmt
             at src/libstd/panicking.rs:384
   8: rust_begin_unwind
             at src/libstd/panicking.rs:311
   9: core::panicking::panic_fmt
             at src/libcore/panicking.rs:85
  10: core::result::unwrap_failed
             at /rustc/eae3437dfe991621e8afdc82734f4a172d7ddf9b/src/libcore/macros.rs:18
  11: core::result::Result<T,E>::expect
             at /rustc/eae3437dfe991621e8afdc82734f4a172d7ddf9b/src/libcore/result.rs:827
  12: compiler::ir::LLVMCompiler::compile_func
             at src/ir.rs:248
  13: compiler::ir::compile
             at src/ir.rs:77
  14: compiler::compile
             at src/lib.rs:72
  15: compiler::real_main
             at src/main.rs:63
  16: compiler::main
             at src/main.rs:109
  17: std::rt::lang_start::{{closure}}
             at /rustc/eae3437dfe991621e8afdc82734f4a172d7ddf9b/src/libstd/rt.rs:64
  18: std::rt::lang_start_internal::{{closure}}
             at src/libstd/rt.rs:49
  19: std::panicking::try::do_call
             at src/libstd/panicking.rs:296
  20: __rust_maybe_catch_panic
             at src/libpanic_unwind/lib.rs:82
  21: std::panicking::try
             at src/libstd/panicking.rs:275
  22: std::panic::catch_unwind
             at src/libstd/panic.rs:394
  23: std::rt::lang_start_internal
             at src/libstd/rt.rs:48
  24: std::rt::lang_start
             at /rustc/eae3437dfe991621e8afdc82734f4a172d7ddf9b/src/libstd/rt.rs:64
  25: main
  26: __libc_start_main
  27: _start

FunctionBody(
                        [
                            Locatable {
                                data: If(
                                    Expr {
                                        expr: Literal(
                                            Int(
                                                1,
                                            ),
                                        ),
                                        ctype: Int(
                                            true,
                                        ),
                                        constexpr: true,
                                        lval: false,
                                        location: Location {
                                            line: 2,
                                            column: 14,
                                            file: "<stdin>",
                                        },
                                    },
                                    Locatable {
                                        data: Compound(
                                            [
                                                Locatable {
                                                    data: Return(
... snip ...

int main() {
    int x;
}

should be legal

• addition (0x7fffffffffffffffL + 1, -0x7fffffffffffffffL + -2)
• subtraction (-0x7fffffffffffffffL - 2, 0x7fffffffffffffffL - -1)
• multiplication (0x7fffffffffffffffL * 2, (-0x7fffffffffffffffL - 1) * -1)
• division (1/0, (-0x7fffffffffffffffL - 1) / -1)
• modulus (1%0, (-0x7fffffffffffffffL - 1) % -1)
• shift left (1 << 33)
• negation(-(-0x7fffffffffffffffL - 1L))

struct s {
    int i, j, k;
} s;
int main() {
        int i = s.i = s.j = s.k = 1;
        struct s *sp = &s;
}
<stdin>:6:25: error: cannot implicitly convert 'struct s *' to 'struct s *'. help: use an explicit cast: (struct s *)

The right way to fix this is to implement Type::partial_eq by hand.

• Struct/union members (a.b) (part of #21)
• Pre/post increment/decrement (++a, i--)
• sizeof (should be easy, just call Type::sizeof internally)
• references (part of #19)
• logical expressions (||, &&) - 558122e
• ternaries (c ? a : b) - only implemented for constants