Refactor class/type lowering, add static calls #312
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
Adding qualifiers as an MLIR attribute to function declarations.
rengolin
requested review from
mjp41,
davidchisnall,
plietar,
sylvanc and
Theodus
rengolin
force-pushed
the
mlir-class
branch
4 times, most recently
from
ef0ff1a
to
8e93a60
Compare
This is a massive change, but it's one that moves towards simpler code and IR. The main changes are: 1. There are no special types any more Integer, float, bool are all "classes" and they get casted to whatever needed for arguments and return values. All numeric types will be coded like classes with dynamic calls in the future, so that fits better with the model. Lowering of native arithmetic will be done when lowering to LLVM, with special lowering for known patterns. 2. The DescriptorType was created That's a handler to a class for static calls. Unlike dynamic calls, we don't have an object to infer what the type is, so we create this type that will hold a (global, unique) handler to lower a call in the same way as dynamic calls, but with that handler instead of an object. 3. Two new operations were created: Call and Static Call implements both dynamic and static calls, by taking the handlers (descriptor or object) and call a method by name and arguments. Static gets the descriptor of a type, to be able to call its static methods.
davidchisnall
approved these changes
Oct 9, 2020
There was a problem hiding this comment.
Some minor nits, nothing that should block a merge. This looks like a big improvement and will make it fairly trivial to support things like U27 as storage-only types and U32 as types with operations defined on them.
There are a few bits where the terminology in the compiler appears to be diverging from the terminology in the language, we should try to unify those.
- Clean up some misleading comments - Only add function attributes if non-empy
plietar
reviewed
Oct 9, 2020
plietar
reviewed
Oct 12, 2020
| } | ||
|
|
||
| UnknownType UnknownType::get(MLIRContext* ctx) | ||
| Type StaticClassType::getTypes() const |
There was a problem hiding this comment.
This shouldn't be in the plural form.
There was a problem hiding this comment.
good catch, I'll fix it.
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.
This is a massive change, but it's one that moves towards simpler code
and IR. The main changes are:
Integer, float, bool are all "classes" and they get casted to whatever
needed for arguments and return values. All numeric types will be coded
like classes with dynamic calls in the future, so that fits better with
the model.
Lowering of native arithmetic will be done when lowering to LLVM, with
special lowering for known patterns.
That's a handler to a class for static calls. Unlike dynamic calls, we
don't have an object to infer what the type is, so we create this type
that will hold a (global, unique) handler to lower a call in the same
way as dynamic calls, but with that handler instead of an object.
Call implements both dynamic and static calls, by taking the handlers
(descriptor or object) and call a method by name and arguments.
Static gets the descriptor of a type, to be able to call its static
methods.
We should start annotating our nodes with the extra information that
comes from the AST and the difference between static and dynamic
calls is an important one.
The implementation is not limited to it, but so far, we only have examples
to that one.
VeronaTypes.h)Please check to make sure my comments are accurate.
Fixes #280