hpcguy / squint Goto Github PK

The function Squint.c :: rename_register1() does literal constant optimizations, and is currently unsafe. I suggest commenting out that optimization until this ticket is closed.

This bug might only occur for chained literal constant assignment:

a = b = c = 0.0;

In the case of chained literal assignment, a workaround is likely as easy as:

a = 0.0;
b = 0.0;
c = 0.0;

This bug gives me an excuse to refactor how I handle literal constants in general (which are tricky on ARM since they are embedded in inactive parts of the instruction stream). Sorry that I am not doing a more direct fix, but I do not yet have any heavy users of Squint.c .

Since I am currently in the midst of a serious medical issue, I may not have the energy to get to this for at least several more weeks.

Some gotos are being optimized away.

Create a stress test for branching and goto as a means to fix this and other jump related bugs.

The testing harness catches bugs, but it needs to hard fail more often.
Also, each test pass should create unique executable names rather than the current name sharing.

I just created a shocktube problem to start applying floating point optimizations.

There are some critical bugs I need to fix in the floating point immediately.

Even though this is a one pass compiler, it is possible to backpatch function call addresses
to create true forward declarations. The current "function prototype" ability in the compiler
is a poor man's forward declaration that backpatching can fix.

It would be nice to port Squint to a AArch 64 environment, but the ELF needs to be modified to work there.

Very simple to implement. A type is set up as an Id using the current type machinery, and the tk field of the Id is set to Typedef. After that, the use of the new typename just clones the Id type information from the old Id into a new Id, and possiblly allocates space.

You can only move an instruction 1K to 4K away from the constant is accesses in the instruction pool memory. Unfortunately, the optimizer is so good, that some constants cross the 4K distance when trying to compress out instructions that were optimized away!!

Labels should likely be handled as a special expression Id. This could allow multiple labels to point to the same statement.

This is best implented in four branches:
(1) Enable float constants, float memory movement, float-register <-> memory transfers, and calling functions that return floats.
(2) Enable float ABI for parameter passing in function calls (harder than working with simple register return value).
(3) Enable math operations on floats.
(4) Enable mixed type expressions with automatic type conversion.

int main() {
    int a = 0;
    if (1) {
        int b;
        printf("%d\n", a);
        int c;
        b = 1;
        a += b;
        printf("%d\n", a);
    }
}

Results in

0
0
1

Clearly it should not print 3 numbers!

Implement codegen() as shared libraries to support multiple architectures. codegen() is a self contained function that converts an an input IR array into a .text segment that can be executed.

There are a few spots in the compiler where a tiny block of assembly code is genertaed directly into an array, and those can be broken out as other functions in the shared library.

Printf requires that the stack and stack arguments be 8-byte aligned when you call printf. This is harder to achieve than it sounds because if you adjust the stack alignment before printf is called, there is not way to know if it had been forcibly aligned after the call, when you have to pop stack arguments.

Found a ptr problem:

int *je;
int n =2;
je += n;

Shared libraries are already supported by the compiler.

Needed features:
(1) Enable function prototype declarations.
(2) Enable -D command line option and #ifdef prepocessor functionality.

Bonus: Enable #define preprocessor functionalitry

This will be implemented by making a global variable that prepends the function name
onto the local variable name.

Right now, you can't use gdb on an mc-compiled executable. Needs to be fixed!

This code should return a 0 value to the shell. It returns '4'.

int g;

int effect()
{
g = 1;
return 1;
}

int main()
{
int x;
g = 0;
x = 0;
if(x && effect())
return 1;
if(g)
return 2;
x = 1;
if(x && effect()) {
if (g != 1)
return 3;
} else {
return 4;
}
g = 0;
x = 1;
if(x || effect()) {
if(g)
return 5;
} else {
return 6;
}
x = 0;
if(x || effect()) {
if (g != 1)
return 7;
} else {
return 8;
}
return 0;
}

The old c4 symbol manager is buggy. Switch to a stack for symbol management.

Stack segments: keywords, globals, parameters, nested scope.

Create a scope marker whenever a block scope is creaked, and delete all
symbols down to the scope marker when block scope is exited.
Keep a tos marker for last symbol created.
Scan downward through the stack when doing id lookups.

In the tokenizer, when tokenizing ids, do this:

notkeyword = 0;
while ((*p >= 'a' && *p <= 'z') || (++notkeyword, *p >= 'A' && *p <= 'Z') || *p == '_') { ... }

if (notkeyword) /* handle id /;
else / handle keyword */ ;

This will not only fix all the bugs with the c4 design, but will also increase performance.

I am forced to add the inline keyword to the public Squint compiler due to a botched 'git stash' and merge on my part.
This was work in progress for the HPC version of MC, and was not supposed to be here.

Now that the cat is out of the bag, I have to let it ride here on the public branch of the compiler.

Note that what I have committed so far only has partial functionality, since it was in mid development.
It only works for a limited subset of void functions at the moment.

Of note: the inline keyword in the MC compiler can be applied in two ways -- either to the function or the call site.
This allows for optimized specializations of functions. For example:

void dot(float *result, float *a, float *b, int len)
{
float sum = 0.0;
for (int i=0; i<len; ++i)
sum += a[i]*b[i];
*result = sum;
}

void ddot(float *out, float *x, int n)
{
inline dot(out, x, x, n); // note speicialization here -- MC optimizer cuts number of mem reads in half
}

Inlining can be nested up to 16 levels. Error messages follow the context through all inline levels.

This should either get it right, or spit out an error!

int a = 1 << 0, b = 1 << 1, c = 1 << 2;

int main() {
    printf("%d %d %d\n", a, b, c);
    return 0;
}

I get.

0 1 2

Should be 1 2 4

Also, unrelated, standard C does not require main to have a return value even though it's declared as int.

This is the most powerful optimization in Squint, but is
currently buggy due to some missing dependency checks.

Since this repository is a Work In Progress,
and since all repository tests are passing,
I am not going to disable apply_ptr_cleanup as I work to fix it.

To disable this optimization, go into squint.c and comment out
the only call to the apply_ptr_cleanup function near the end of the file.

Declarations such as "int foo[32];" should certainly work under any circumstance. Rework the type system to allow this to be naturally supported.