Revise Usual Arithmetic Conversions #311
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
There are a few discrepancies between what I originally wrote here and what DXC does. These changes adjust to the actual behavior and more closely align with implicit conversion sequences. Fixes microsoft#308
bfavela
reviewed
Sep 4, 2024
damyanp
reviewed
Sep 4, 2024
llvm-beanz
added a commit
to llvm-beanz/llvm-project
that referenced
this pull request
Sep 5, 2024
HLSL has a different set of usual arithmetic conversions for vector types to resolve a common type for binary operator expressions. This PR implements the current spec proposal from: microsoft/hlsl-specs#311 There is one case that may need additional handling for implicitly truncating `vector<T,1>` to `T` early to allow other transformations.
damyanp
approved these changes
Sep 5, 2024
llvm-beanz
added a commit
to llvm-beanz/llvm-project
that referenced
this pull request
Sep 6, 2024
HLSL has a different set of usual arithmetic conversions for vector types to resolve a common type for binary operator expressions. This PR implements the current spec proposal from: microsoft/hlsl-specs#311 There is one case that may need additional handling for implicitly truncating `vector<T,1>` to `T` early to allow other transformations.
llvm-beanz
added a commit
to llvm-beanz/llvm-project
that referenced
this pull request
Sep 13, 2024
HLSL has a different set of usual arithmetic conversions for vector types to resolve a common type for binary operator expressions. This PR implements the current spec proposal from: microsoft/hlsl-specs#311 There is one case that may need additional handling for implicitly truncating `vector<T,1>` to `T` early to allow other transformations. Fixes llvm#106253
This was referenced Sep 13, 2024
bfavela
approved these changes
Sep 16, 2024
llvm-beanz
added a commit
to llvm/llvm-project
that referenced
this pull request
Sep 26, 2024
HLSL has a different set of usual arithmetic conversions for vector types to resolve a common type for binary operator expressions. This PR implements the current spec proposal from: microsoft/hlsl-specs#311 There is one case that may need additional handling for implicitly truncating `vector<T,1>` to `T` early to allow other transformations. Fixes #106253
llvm-beanz
added a commit
to llvm-beanz/llvm-project
that referenced
this pull request
Sep 27, 2024
types to resolve a common type for binary operator expressions. This PR implements the current spec proposal from: microsoft/hlsl-specs#311 There is one case that may need additional handling for implicitly truncating vector<T,1> to T early to allow other transformations. Fixes llvm#106253 ../clang/test/SemaHLSL/Language/UsualArithmeticConversions.hlsl
llvm-beanz
added a commit
to llvm/llvm-project
that referenced
this pull request
Sep 27, 2024
HLSL has a different set of usual arithmetic conversions for vector types to resolve a common type for binary operator expressions. This PR implements the current spec proposal from: microsoft/hlsl-specs#311 There is one case that may need additional handling for implicitly truncating vector<T,1> to T early to allow other transformations. Fixes #106253 Re-lands #108659
Sterling-Augustine
pushed a commit
to Sterling-Augustine/llvm-project
that referenced
this pull request
Sep 27, 2024
HLSL has a different set of usual arithmetic conversions for vector types to resolve a common type for binary operator expressions. This PR implements the current spec proposal from: microsoft/hlsl-specs#311 There is one case that may need additional handling for implicitly truncating `vector<T,1>` to `T` early to allow other transformations. Fixes llvm#106253
puja2196
pushed a commit
to puja2196/LLVM-tutorial
that referenced
this pull request
Sep 30, 2024
HLSL has a different set of usual arithmetic conversions for vector types to resolve a common type for binary operator expressions. This PR implements the current spec proposal from: microsoft/hlsl-specs#311 There is one case that may need additional handling for implicitly truncating `vector<T,1>` to `T` early to allow other transformations. Fixes #106253
puja2196
pushed a commit
to puja2196/LLVM-tutorial
that referenced
this pull request
Sep 30, 2024
HLSL has a different set of usual arithmetic conversions for vector types to resolve a common type for binary operator expressions. This PR implements the current spec proposal from: microsoft/hlsl-specs#311 There is one case that may need additional handling for implicitly truncating vector<T,1> to T early to allow other transformations. Fixes #106253 Re-lands #108659
puja2196
pushed a commit
to puja2196/LLVM-tutorial
that referenced
this pull request
Oct 2, 2024
HLSL has a different set of usual arithmetic conversions for vector types to resolve a common type for binary operator expressions. This PR implements the current spec proposal from: microsoft/hlsl-specs#311 There is one case that may need additional handling for implicitly truncating `vector<T,1>` to `T` early to allow other transformations. Fixes #106253
puja2196
pushed a commit
to puja2196/LLVM-tutorial
that referenced
this pull request
Oct 2, 2024
HLSL has a different set of usual arithmetic conversions for vector types to resolve a common type for binary operator expressions. This PR implements the current spec proposal from: microsoft/hlsl-specs#311 There is one case that may need additional handling for implicitly truncating vector<T,1> to T early to allow other transformations. Fixes #106253 Re-lands #108659
xgupta
pushed a commit
to xgupta/llvm-project
that referenced
this pull request
Oct 4, 2024
HLSL has a different set of usual arithmetic conversions for vector types to resolve a common type for binary operator expressions. This PR implements the current spec proposal from: microsoft/hlsl-specs#311 There is one case that may need additional handling for implicitly truncating `vector<T,1>` to `T` early to allow other transformations. Fixes llvm#106253
xgupta
pushed a commit
to xgupta/llvm-project
that referenced
this pull request
Oct 4, 2024
HLSL has a different set of usual arithmetic conversions for vector types to resolve a common type for binary operator expressions. This PR implements the current spec proposal from: microsoft/hlsl-specs#311 There is one case that may need additional handling for implicitly truncating vector<T,1> to T early to allow other transformations. Fixes llvm#106253 Re-lands llvm#108659
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.
There are a few discrepancies between what I originally wrote here and what DXC does. These changes adjust to the actual behavior and more closely align with implicit conversion sequences.
Fixes #308