[CIR][CodeGen] VLA support next step #453
Conversation
|
✅ With the latest revision this PR passed the C/C++ code formatter. |
Verifiers doing some nice work here! This is right, this is not VLA specific. One thing I'm doing in this front is to make sure all cleanup things at least stay in the scope "cleanup" block so that whenever I fix this issue, it can apply to all relevant cases. That said, I don't think during past reviews for |
Can you also insert the example in the testcase and leave it commented out with a FIXME? |
|
@bcardosolopes
I'm not sure I understand you, my bad! Now the clean up for VLA is inserted here, and as far I understand this is the only place where we need to insert it. |
|
Hi Oleg.
No problem, seems like it might already be in the right place.
BTW, I ran into an issue with Anyways, if you have hints about this, just let me know - but I'm gonna take a look at the issue, no sweat for you. Thanks for offering help! |
Here is the next step in VLA support.
Basically, these changes handle different expressions, like `int
(*a[5])[n]` or `sizeof(a[n])`.
I took tests from the original `codegen` - they don't check anything,
just verify we don't fail.
There is still an issue with a proper cleanup - there are cases when
`stack_save` doesn't dominate a corresponded `stack_restore`. For
example in the next example:
```
void test(unsigned x) {
while (1) {
char a[x];
if (x > 5)
break;
++x;
}
}
```
Look like `break` here doesn't lead to `stack_restore`. But I would say
this is less related to VLA, though probably I need to fix this as well.
Here is the next step in VLA support.
Basically, these changes handle different expressions, like `int
(*a[5])[n]` or `sizeof(a[n])`.
I took tests from the original `codegen` - they don't check anything,
just verify we don't fail.
There is still an issue with a proper cleanup - there are cases when
`stack_save` doesn't dominate a corresponded `stack_restore`. For
example in the next example:
```
void test(unsigned x) {
while (1) {
char a[x];
if (x > 5)
break;
++x;
}
}
```
Look like `break` here doesn't lead to `stack_restore`. But I would say
this is less related to VLA, though probably I need to fix this as well.
Here is the next step in VLA support.
Basically, these changes handle different expressions, like `int
(*a[5])[n]` or `sizeof(a[n])`.
I took tests from the original `codegen` - they don't check anything,
just verify we don't fail.
There is still an issue with a proper cleanup - there are cases when
`stack_save` doesn't dominate a corresponded `stack_restore`. For
example in the next example:
```
void test(unsigned x) {
while (1) {
char a[x];
if (x > 5)
break;
++x;
}
}
```
Look like `break` here doesn't lead to `stack_restore`. But I would say
this is less related to VLA, though probably I need to fix this as well.
Here is the next step in VLA support.
Basically, these changes handle different expressions, like `int
(*a[5])[n]` or `sizeof(a[n])`.
I took tests from the original `codegen` - they don't check anything,
just verify we don't fail.
There is still an issue with a proper cleanup - there are cases when
`stack_save` doesn't dominate a corresponded `stack_restore`. For
example in the next example:
```
void test(unsigned x) {
while (1) {
char a[x];
if (x > 5)
break;
++x;
}
}
```
Look like `break` here doesn't lead to `stack_restore`. But I would say
this is less related to VLA, though probably I need to fix this as well.
Here is the next step in VLA support.
Basically, these changes handle different expressions, like `int
(*a[5])[n]` or `sizeof(a[n])`.
I took tests from the original `codegen` - they don't check anything,
just verify we don't fail.
There is still an issue with a proper cleanup - there are cases when
`stack_save` doesn't dominate a corresponded `stack_restore`. For
example in the next example:
```
void test(unsigned x) {
while (1) {
char a[x];
if (x > 5)
break;
++x;
}
}
```
Look like `break` here doesn't lead to `stack_restore`. But I would say
this is less related to VLA, though probably I need to fix this as well.
Here is the next step in VLA support.
Basically, these changes handle different expressions, like `int
(*a[5])[n]` or `sizeof(a[n])`.
I took tests from the original `codegen` - they don't check anything,
just verify we don't fail.
There is still an issue with a proper cleanup - there are cases when
`stack_save` doesn't dominate a corresponded `stack_restore`. For
example in the next example:
```
void test(unsigned x) {
while (1) {
char a[x];
if (x > 5)
break;
++x;
}
}
```
Look like `break` here doesn't lead to `stack_restore`. But I would say
this is less related to VLA, though probably I need to fix this as well.
Here is the next step in VLA support.
Basically, these changes handle different expressions, like
int (*a[5])[n]orsizeof(a[n]).I took tests from the original
codegen- they don't check anything, just verify we don't fail.There is still an issue with a proper cleanup - there are cases when
stack_savedoesn't dominate a correspondedstack_restore. For example in the next example:Look like
breakhere doesn't lead tostack_restore. But I would say this is less related to VLA, though probably I need to fix this as well.Btw, looks like somehow I didn't attach tests last time, my bad!