Skip to content

Conversation

gitoleg
Copy link
Collaborator

@gitoleg gitoleg commented Nov 28, 2023

This PR adds array size into AllocaOp that will be useful in future - currently I work on variable length array support. So I start to make tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as possible, so no existing AllocaOp usages need to be changed.

Copy link
Collaborator

@sitio-couto sitio-couto left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@gitoleg thanks for tackling VLAs!

Could you add a few tests in clang/test/CIR/?

  • In IR/alloca.cir, ensure the new AllocaOp is properly parsed/printed.
  • In IR/invalid.cir, ensure that invalid renditions of the AllocaOp will throw an error (e.g. array size as a float).
  • In Lowering/alloca.cir, ensure the lowering to LLVM IR of the AllocaOp is as expected.

@gitoleg
Copy link
Collaborator Author

gitoleg commented Nov 29, 2023

@sitio-couto done!

Copy link
Collaborator

@sitio-couto sitio-couto left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@gitoleg just a few minor improvements to the tests.

Other than that, LGTM!

@bcardosolopes
Copy link
Member

Thanks for adding VLA support, yay!

This PR adds array size into AllocaOp that will be useful in future - currently I work on variable length array support. So I start to make tiny PRs in advance)

Perfect!

@gitoleg
Copy link
Collaborator Author

gitoleg commented Nov 30, 2023

@bcardosolopes @sitio-couto fixed

@gitoleg
Copy link
Collaborator Author

gitoleg commented Dec 1, 2023

@bcardosolopes @sitio-couto

so... I made tests mote concise and fixed the description of the new argument. Did I understand right your suggestions?

Copy link
Member

@bcardosolopes bcardosolopes left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

LGTM

@bcardosolopes bcardosolopes merged commit feddbe7 into llvm:main Dec 8, 2023
lanza pushed a commit that referenced this pull request Dec 20, 2023
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
lanza pushed a commit that referenced this pull request Jan 29, 2024
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
bcardosolopes pushed a commit that referenced this pull request Jan 31, 2024
This is a first PR for variable length array support. There are one (or
more :) ) ahead.

Basically, we already did lot's of preliminary job in order to land VLA
in CIR in #367 #346 #340. So now we add initial VLA support itself.

Most of the changes are taken from the original codegen, so there is
nothing to be scary of)

I added just one test, and basically that's all we can test right now.
Later, I will add more, from the original codegen tests.
lanza pushed a commit that referenced this pull request Mar 23, 2024
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
lanza pushed a commit that referenced this pull request Mar 23, 2024
This is a first PR for variable length array support. There are one (or
more :) ) ahead.

Basically, we already did lot's of preliminary job in order to land VLA
in CIR in #367 #346 #340. So now we add initial VLA support itself.

Most of the changes are taken from the original codegen, so there is
nothing to be scary of)

I added just one test, and basically that's all we can test right now.
Later, I will add more, from the original codegen tests.
eZWALT pushed a commit to eZWALT/clangir that referenced this pull request Mar 24, 2024
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
eZWALT pushed a commit to eZWALT/clangir that referenced this pull request Mar 24, 2024
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
eZWALT pushed a commit to eZWALT/clangir that referenced this pull request Mar 24, 2024
This is a first PR for variable length array support. There are one (or
more :) ) ahead.

Basically, we already did lot's of preliminary job in order to land VLA
in CIR in llvm#367 llvm#346 llvm#340. So now we add initial VLA support itself.

Most of the changes are taken from the original codegen, so there is
nothing to be scary of)

I added just one test, and basically that's all we can test right now.
Later, I will add more, from the original codegen tests.
lanza pushed a commit that referenced this pull request Apr 29, 2024
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
lanza pushed a commit that referenced this pull request Apr 29, 2024
This is a first PR for variable length array support. There are one (or
more :) ) ahead.

Basically, we already did lot's of preliminary job in order to land VLA
in CIR in #367 #346 #340. So now we add initial VLA support itself.

Most of the changes are taken from the original codegen, so there is
nothing to be scary of)

I added just one test, and basically that's all we can test right now.
Later, I will add more, from the original codegen tests.
lanza pushed a commit that referenced this pull request Apr 29, 2024
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
lanza pushed a commit that referenced this pull request Apr 29, 2024
This is a first PR for variable length array support. There are one (or
more :) ) ahead.

Basically, we already did lot's of preliminary job in order to land VLA
in CIR in #367 #346 #340. So now we add initial VLA support itself.

Most of the changes are taken from the original codegen, so there is
nothing to be scary of)

I added just one test, and basically that's all we can test right now.
Later, I will add more, from the original codegen tests.
eZWALT pushed a commit to eZWALT/clangir that referenced this pull request Apr 29, 2024
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
eZWALT pushed a commit to eZWALT/clangir that referenced this pull request Apr 29, 2024
This is a first PR for variable length array support. There are one (or
more :) ) ahead.

Basically, we already did lot's of preliminary job in order to land VLA
in CIR in llvm#367 llvm#346 llvm#340. So now we add initial VLA support itself.

Most of the changes are taken from the original codegen, so there is
nothing to be scary of)

I added just one test, and basically that's all we can test right now.
Later, I will add more, from the original codegen tests.
lanza pushed a commit that referenced this pull request Apr 29, 2024
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
lanza pushed a commit that referenced this pull request Apr 29, 2024
This is a first PR for variable length array support. There are one (or
more :) ) ahead.

Basically, we already did lot's of preliminary job in order to land VLA
in CIR in #367 #346 #340. So now we add initial VLA support itself.

Most of the changes are taken from the original codegen, so there is
nothing to be scary of)

I added just one test, and basically that's all we can test right now.
Later, I will add more, from the original codegen tests.
bruteforceboy pushed a commit to bruteforceboy/clangir that referenced this pull request Oct 2, 2024
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
bruteforceboy pushed a commit to bruteforceboy/clangir that referenced this pull request Oct 2, 2024
This is a first PR for variable length array support. There are one (or
more :) ) ahead.

Basically, we already did lot's of preliminary job in order to land VLA
in CIR in llvm#367 llvm#346 llvm#340. So now we add initial VLA support itself.

Most of the changes are taken from the original codegen, so there is
nothing to be scary of)

I added just one test, and basically that's all we can test right now.
Later, I will add more, from the original codegen tests.
Hugobros3 pushed a commit to shady-gang/clangir that referenced this pull request Oct 2, 2024
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
Hugobros3 pushed a commit to shady-gang/clangir that referenced this pull request Oct 2, 2024
This is a first PR for variable length array support. There are one (or
more :) ) ahead.

Basically, we already did lot's of preliminary job in order to land VLA
in CIR in llvm#367 llvm#346 llvm#340. So now we add initial VLA support itself.

Most of the changes are taken from the original codegen, so there is
nothing to be scary of)

I added just one test, and basically that's all we can test right now.
Later, I will add more, from the original codegen tests.
keryell pushed a commit to keryell/clangir that referenced this pull request Oct 19, 2024
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
keryell pushed a commit to keryell/clangir that referenced this pull request Oct 19, 2024
This is a first PR for variable length array support. There are one (or
more :) ) ahead.

Basically, we already did lot's of preliminary job in order to land VLA
in CIR in llvm#367 llvm#346 llvm#340. So now we add initial VLA support itself.

Most of the changes are taken from the original codegen, so there is
nothing to be scary of)

I added just one test, and basically that's all we can test right now.
Later, I will add more, from the original codegen tests.
lanza pushed a commit that referenced this pull request Nov 5, 2024
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
lanza pushed a commit that referenced this pull request Nov 5, 2024
This is a first PR for variable length array support. There are one (or
more :) ) ahead.

Basically, we already did lot's of preliminary job in order to land VLA
in CIR in #367 #346 #340. So now we add initial VLA support itself.

Most of the changes are taken from the original codegen, so there is
nothing to be scary of)

I added just one test, and basically that's all we can test right now.
Later, I will add more, from the original codegen tests.
lanza pushed a commit that referenced this pull request Mar 18, 2025
This PR adds dynamic stack allocation into `AllocaOp` that will be useful in future -
currently I work on variable length array support. So I start to make
tiny PRs in advance)
No changes in tests needed, I tried to make the changes as smooth as
possible, so no existing `AllocaOp` usages need to be changed.
lanza pushed a commit that referenced this pull request Mar 18, 2025
This is a first PR for variable length array support. There are one (or
more :) ) ahead.

Basically, we already did lot's of preliminary job in order to land VLA
in CIR in #367 #346 #340. So now we add initial VLA support itself.

Most of the changes are taken from the original codegen, so there is
nothing to be scary of)

I added just one test, and basically that's all we can test right now.
Later, I will add more, from the original codegen tests.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

3 participants