[ir] Let real function return nested StructType #7059
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
[ghstack-poisoned]
lin-hitonami
added a commit
that referenced
this pull request
Jan 5, 2023
ghstack-source-id: 9e9de3d852a8adaf4dae5810a868a31afefeae1a Pull Request resolved: #7059
lin-hitonami
requested review from
ailzhang,
jim19930609,
strongoier and
bobcao3
jim19930609
reviewed
Jan 6, 2023
| @@ -2757,6 +2749,49 @@ llvm::Type *TaskCodeGenLLVM::get_real_func_ret_type(Function *real_func) { | |||
| return llvm::StructType::get(*llvm_context, tps); | |||
| } | |||
|
|
|||
| void TaskCodeGenLLVM::create_return(llvm::Value *buffer, | |||
| llvm::Type *buffer_type, | |||
There was a problem hiding this comment.
Can we obtain buffer_type from buffer->getType()?
There was a problem hiding this comment.
No... While it works fine on linux machines, it doesn't work on Windows because the pointers are opaque pointers, and buffer->getType() only returns ptr in LLVM 15. I don't know why it works on linux machines... maybe the LLVM binaries are different....
issue: #6983 Before this PR, if we want to return a struct type in a real function, we flatten the struct in LLVM. For example, `struct(a: Ta, s: struct(b: Tb, c: Tc))` is flattened to `struct(a: Ta, b: Tb, c: Tc)`. After this PR, we do not flatten anymore. We directly return `struct(a: Ta, s: struct(b: Tb, c: Tc))`. Note that we still need to pass the flattened return values from Python to CHI-IR because we can't pass a Python struct into C++. We compose the target struct type from the flattened values and the return type in the codegen. [ghstack-poisoned]
lin-hitonami
added a commit
that referenced
this pull request
Jan 6, 2023
ghstack-source-id: da419c9cae39d8a96490c01b5dbf0b50fd2137c3 Pull Request resolved: #7059
issue: #6983 Before this PR, if we want to return a struct type in a real function, we flatten the struct in LLVM. For example, `struct(a: Ta, s: struct(b: Tb, c: Tc))` is flattened to `struct(a: Ta, b: Tb, c: Tc)`. After this PR, we do not flatten anymore. We directly return `struct(a: Ta, s: struct(b: Tb, c: Tc))`. Note that we still need to pass the flattened return values from Python to CHI-IR because we can't pass a Python struct into C++. We compose the target struct type from the flattened values and the return type in the codegen. [ghstack-poisoned]
lin-hitonami
added a commit
that referenced
this pull request
Jan 6, 2023
ghstack-source-id: dc6954a0f04f99a8edb72a6b950315ccf60a7237 Pull Request resolved: #7059
jim19930609
approved these changes
Jan 6, 2023
issue: #6983 Before this PR, if we want to return a struct type in a real function, we flatten the struct in LLVM. For example, `struct(a: Ta, s: struct(b: Tb, c: Tc))` is flattened to `struct(a: Ta, b: Tb, c: Tc)`. After this PR, we do not flatten anymore. We directly return `struct(a: Ta, s: struct(b: Tb, c: Tc))`. Note that we still need to pass the flattened return values from Python to CHI-IR because we can't pass a Python struct into C++. We compose the target struct type from the flattened values and the return type in the codegen. [ghstack-poisoned]
lin-hitonami
added a commit
that referenced
this pull request
Jan 6, 2023
ghstack-source-id: 21a1ad6ce1912fd52267a176586bde2d56bd8148 Pull Request resolved: #7059
issue: #6983 Before this PR, if we want to return a struct type in a real function, we flatten the struct in LLVM. For example, `struct(a: Ta, s: struct(b: Tb, c: Tc))` is flattened to `struct(a: Ta, b: Tb, c: Tc)`. After this PR, we do not flatten anymore. We directly return `struct(a: Ta, s: struct(b: Tb, c: Tc))`. Note that we still need to pass the flattened return values from Python to CHI-IR because we can't pass a Python struct into C++. We compose the target struct type from the flattened values and the return type in the codegen. [ghstack-poisoned]
lin-hitonami
added a commit
that referenced
this pull request
Jan 6, 2023
ghstack-source-id: 2898ad5c64bbee12090e1546c3dbf24b85603a56 Pull Request resolved: #7059
issue: #6983 Before this PR, if we want to return a struct type in a real function, we flatten the struct in LLVM. For example, `struct(a: Ta, s: struct(b: Tb, c: Tc))` is flattened to `struct(a: Ta, b: Tb, c: Tc)`. After this PR, we do not flatten anymore. We directly return `struct(a: Ta, s: struct(b: Tb, c: Tc))`. Note that we still need to pass the flattened return values from Python to CHI-IR because we can't pass a Python struct into C++. We compose the target struct type from the flattened values and the return type in the codegen. [ghstack-poisoned]
lin-hitonami
added a commit
that referenced
this pull request
Jan 6, 2023
ghstack-source-id: 1384c5f237c9b2dda70d084668fe902226388bc0 Pull Request resolved: #7059
issue: #6983 Before this PR, if we want to return a struct type in a real function, we flatten the struct in LLVM. For example, `struct(a: Ta, s: struct(b: Tb, c: Tc))` is flattened to `struct(a: Ta, b: Tb, c: Tc)`. After this PR, we do not flatten anymore. We directly return `struct(a: Ta, s: struct(b: Tb, c: Tc))`. Note that we still need to pass the flattened return values from Python to CHI-IR because we can't pass a Python struct into C++. We compose the target struct type from the flattened values and the return type in the codegen. [ghstack-poisoned]
lin-hitonami
added a commit
that referenced
this pull request
Jan 6, 2023
ghstack-source-id: c7345fbae605793d13fd4c358e65ab20815c9155 Pull Request resolved: #7059
lin-hitonami
added a commit
that referenced
this pull request
Jan 6, 2023
ghstack-source-id: c7345fbae605793d13fd4c358e65ab20815c9155 Pull Request resolved: #7059
quadpixels
pushed a commit
to quadpixels/taichi
that referenced
this pull request
May 13, 2023
ghstack-source-id: c7345fbae605793d13fd4c358e65ab20815c9155 Pull Request resolved: taichi-dev#7059
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Stack from ghstack (oldest at bottom):
issue: #6983
Before this PR, if we want to return a struct type in a real function, we flatten the struct in LLVM. For example,
struct(a: Ta, s: struct(b: Tb, c: Tc))is flattened tostruct(a: Ta, b: Tb, c: Tc). After this PR, we do not flatten anymore. We directly returnstruct(a: Ta, s: struct(b: Tb, c: Tc)).Note that we still need to pass the flattened return values from Python to CHI-IR because we can't pass a Python struct into C++. We compose the target struct type from the flattened values and the return type in the codegen.