QBE generator

[YerinAlexey]

Description

This adds a generator for QBE. This time it should go a bit better.

Notes

• Extended types are only allowed in data definitions (aka aggregate types)
• Casting to a larger type doesn't work, needs to be explicitly extended with ext* instructions

Demo time

struct Person {
    beans: int
}

fn main() {
    let me = new Person {
        beans: 0
    }

    printf("before: %d beans\n", me.beans)

    me.beans += 100

    printf("after: %d beans\n", me.beans)
}

Produces:

$ ./target/debug/sb -t qbe build -o - test.sb | qbe | cc -x assembler -o test -
$ ./test
before: 0 beans
after: 100 beans

Known issues

• Function calls don't have correct return types. If you call a C function that returns a long and pass it into something else, it will break. Blocked on better types and function prototype syntax.

ToDo

• [x] Functions
• Control structures
  • [x] Return
  • [x] If statement
  • [ ] For loop (requires arrays)
  • [x] While loop
  • [x] Break/continue from loops
  • [ ] Match
• Expressions
  • [x] Integer literals
  • [x] Boolean literals
  • [x] String literals (requires string aggregate type)
  • [x] Function calls (a bit fragile right now)
  • [x] Variable access
  • [x] Binary operations (+, - and friends)
  • [x] Assignment operations (+=, *= etc)
  • [ ] Self in methods (if methods will live to this point)
• Aggregate types
  • Arrays
  • [x] [..., ....] initialization syntax
  • [ ] Array access
  • [ ] Assignment to array
  • [ ] Nested arrays?
  • Structs
  • [x] Struct initialization (new Database { ... })
  • [x] Resolve structs in variable types
  • [x] Field access
  • [x] Assignment to fields
  • [ ] Nested structs
  • [x] Strings. Like C, with NUL terminator
• [ ] Make sb build assemble and link the binary
• [ ] Add tests
• [x] Document the new backend
• [x] Add to "Unreleased" section in the changelog

[garritfra]

Do we want to build 100% static binaries without any dependencies?

I think for now we can rely on the c stdlib as a dependency. Once the language is a bit more sophisticated, we can add our own wrappers.

[garritfra]

Regarding assignment operators (+=): to keep it simple, we could maybe transform that during build-time to x = x + 1. Or how easy would that be to implement?

[YerinAlexey]

Regarding assignment operators (+=): to keep it simple, we could maybe transform that during build-time to x = x + 1. Or how easy would that be to implement?

This should be quite easy to implement. I had the idea to have a resolve(Expression) -> QbeValue function that retrieves the value from variable, field access or array access and then use it in *Assign binops.

It should be basically this (pseudocode):

let (ty, tmp) = resolve(lhs);
generate_assign(
    lhs,
    ty,
    QbeInstr::Add(tmp, rhs),
);

Feel free to work on this in the meantime.

[YerinAlexey]

I rebased this on master, should still work

[YerinAlexey]

Any comments so far?

[garritfra]

Also, would you mind opening some tickets for the missing parts? That way we have them documented to be worked on later

[YerinAlexey]

Also, would you mind opening some tickets for the missing parts? That way we have them documented to be worked on later

Ok, sure. I'll add arrays and += now, and leave match as a ticket. This PR is already massive