romainthd/jlc

Compiler for a C / Java-like language

jlc's Issues

Multiple constructor definition with inheritance

Constant propagation in loops optimization

JLC/src/fr/rthd/jlc/optimizer/Optimizer.java

Line 444 in 0996df0

// FIXME: Constant propagation in while body must be fixed

No return statement for functions that have unreachable states and infinite loops

int main() {
    while (true) {
        printString("Infinite loop");
    }

    printString("Unreachable");
}

throws

- Type error: Function `main` has no return statement, or not all paths return a value

However,

int main() {
    if (sideEffect() == 0) {
        return 0;
    } else {
        return 1;
    }

    printString("Unreachable");
}

works correctly

How to deal with `self`

The testsuite never use it

Passing an unknown flag will throw an exception

Check LValue override for `self`, `.length` and methods

Reduce execution time by reusing visitors?

Call to inherited method

class Animal {
    void move() {}
}

class Dog extends Animal {
}

int main() {
    Dog dog = new Dog;
    dog.move();
    return 0;
}

This currently doesn't work since the function @Dog$move technically doesn't exist.

Should the definition of move be duplicated between both classes (spoiler: probably not), or should a cast to the parent happen?

Method calls should use a pointer, not a loaded reference

Currently, the generated code looks like

%a = alloca %A
%.temp = load %A, %A* %a
call void @A$__constructor(%A* %.temp) ; Note that `%A*` is a hack, since `%.temp` is typed as `%A`

It should however be

%a = alloca %A
call void @A$__constructor(%A* %a)

Variable-to-variable assignments with objects

The following code

Animal a = new Animal;
Animal b = a;

will output this LLVM assembly:

store %Animal %a, %Animal* %b

with the error '%a' defined with type '%Animal*'

Add new line after all statement in LLVM assembly

Recursive functions are wrongly marked as pure

int main() {
    f();
    return 0;
}

void f() {
    f();
}

will currently be optimized into

int main () {
    return 0;
}

Grammar shift / reduce conflict near `Constructor`

Creating an unitialized array will segfault due to length field set on null

Chicken & egg problem with constant propagation in while loops

JLC/src/fr/rthd/jlc/optimizer/Optimizer.java

Lines 421 to 429 in 0996df0

	// We need to disable constant propagation for the condition,
	// otherwise something like `while (x != 0) x--;` will never be
	// executed. On the other hand, we cannot evaluate the body before
	// the condition, because the condition might evaluate to false
	// and the body will prevent some possible optimizations about
	// purity, unused functions etc. This solution is a good compromise
	// even though we might be able to optimize the condition more,
	// especially if the body never updates the variable used in the
	// condition.

`getAllMethods()` and `getAllAttributes()` should keep a cache

Method calls without using `self` throw an exception

class Animal {
    void eat() {
        printString("Animal is eating");
        eatAgain(); // Error here: NullPointerException
    }

    void eatAgain() {
        printString("Animal is eating again");
    }
}

Strings literals are affected by the parsing hack

int main() {
    printString("A [ ] B");
    return 0;
}

prints A [] B instead of A [ ] B

Constant propagation doesn't work very well with blocks

int main() {
    int n = 24;
    if (n % 2 == 0) {
        n++;
    }

    if (n % 5 == 0) {
        return 0;
    }

    return 1;
}

Expected:

int main() {
    int n = 24;

    {
        n++;
    }

    {
        return 0;
    }
}

Actual:

int main () {
    int n = 24;
  
    {
        n ++;
    }

    if (n % 5 == 0) {
        return 0;
    }

    return 1;
}