Optimize enum comparisons #81780
Merged
Optimize enum comparisons #81780
Conversation
This file contains hidden or 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
eeckstein
requested review from
jckarter,
a team,
slavapestov,
hborla and
xedin
as code owners
eeckstein
requested review from
atrick,
meg-gupta and
nate-chandler
and removed request for
hborla
|
@swift-ci test |
|
@swift-ci apple silicon benchmark |
1 similar comment
|
@swift-ci apple silicon benchmark |
|
@swift-ci clean apple silicon benchmark |
|
@swift-ci benchmark |
Optimize (the very inefficient) RawRepresentable comparison function call to a simple compare of enum tags.
For example,
```
enum E: String {
case a, b, c
}
```
is compared by getting the raw values of both operands and doing a string compare.
This peephole optimizations replaces the call to such a comparison function with a direct compare of the enum tags, which boils down to a single integer comparison instruction.
rdar://151788987
…nctions So that optimizations can identify and deal with them.
… of the operands is a constant enum
If there is a "constant" enum argument to a synthesized enum comparison, we can always inline it, because most of it will be constant folded anyway.
This ensures the compiler is not creating terrible code for very simple enum comparisons, like
```
if someEnum == .someCase {
...
}
```
rdar://85677499
eeckstein
force-pushed
the
optimize-enum-comparison
branch
from
ed521c7 to
ed8922b
Compare
|
@swift-ci test |
stephentyrone
approved these changes
May 27, 2025
| Func ==(_:_:) has generic signature change from to <T where T : Swift.RawRepresentable, T.RawValue : Swift.Equatable> | ||
| Func ==(_:_:) has mangled name changing from 'Swift.== infix(Swift.Optional<Any.Type>, Swift.Optional<Any.Type>) -> Swift.Bool' to 'Swift.== infix<A where A: Swift.RawRepresentable, A.RawValue: Swift.Equatable>(A, A) -> Swift.Bool' | ||
| Func ==(_:_:) has parameter 0 type change from (any Any.Type)? to τ_0_0 | ||
| Func ==(_:_:) has parameter 1 type change from (any Any.Type)? to τ_0_0 |
There was a problem hiding this comment.
Are these ABI changes caused just by the addition of @_semantics("rawrepresentable.is_equal")?
There was a problem hiding this comment.
Yes, I think what's happening here is that the api-digester is mixing up different overloads of the func ==
There was a problem hiding this comment.
Ah, that's unfortunate.
There was a problem hiding this comment.
(probably worth a bug report against the api-digester, if you can file one)
There was a problem hiding this comment.
@nkcsgexi do you know, is my assumption correct?
|
@swift-ci smoke test windows |
|
@swift-ci smoke test macos |
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 PR contains two optimizations which dramatically improve performance of certain enum comparisons:
Peephole optimization for raw-value enum comparisons
Optimize (the very inefficient) RawRepresentable comparison function call to a simple compare of enum tags.
For example,
is compared by getting the raw values of both operands and doing a string compare.
This peephole optimizations replaces the call to such a comparison function with a direct compare of the enum tags, which boils down to a single integer comparison instruction.
rdar://151788987
Always inline synthesized enum comparisons if one of the operands is a constant enum
If there is a "constant" enum argument to a synthesized enum comparison, we can always inline it, because most of it will be constant folded anyway.
This ensures the compiler is not creating terrible code for very simple enum comparisons, like
rdar://85677499