Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

[CIR][IR] Bypass get_member verifier for incomplete types #257

Merged
merged 1 commit into from
Sep 13, 2023
Merged

[CIR][IR] Bypass get_member verifier for incomplete types #257

merged 1 commit into from
Sep 13, 2023

Conversation

sitio-couto
Copy link
Collaborator

Temporary workaround until we patch the codegen for record types.

@sitio-couto
[CIR][IR] Bypass get_member verifier for incomplete types
52fe3a6 
Temporary workaround until we patch the codegen for record types.
bcardosolopes
bcardosolopes approved these changes Sep 13, 2023
View reviewed changes
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

@sitio-couto sitio-couto merged commit 86d68fd into llvm:main Sep 13, 2023
1 check passed
@gitoleg gitoleg mentioned this pull request Sep 15, 2023
Closed
@gitoleg gitoleg mentioned this pull request Sep 23, 2023
Merged
bcardosolopes pushed a commit that referenced this pull request Oct 18, 2023
@gitoleg
[CIR][IR] Relax get_member verifier for incomplete types (#269)
37aa0f2 
This is a suggestion to relax the existing verification even more than
we did it in PR #257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {    
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {        
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in #256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in #257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
lanza pushed a commit that referenced this pull request Oct 25, 2023
@gitoleg @lanza
[CIR][IR] Relax get_member verifier for incomplete types (#269)
fbcce23 
This is a suggestion to relax the existing verification even more than
we did it in PR #257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {    
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {        
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in #256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in #257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
lanza pushed a commit that referenced this pull request Oct 27, 2023
@gitoleg @lanza
[CIR][IR] Relax get_member verifier for incomplete types (#269)
0f9c438 
This is a suggestion to relax the existing verification even more than
we did it in PR #257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {    
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {        
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in #256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in #257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
@sitio-couto sitio-couto deleted the vinicius/bypass-incomplete-types branch November 14, 2023 11:56
lanza pushed a commit that referenced this pull request Dec 20, 2023
@gitoleg @lanza
[CIR][IR] Relax get_member verifier for incomplete types (#269)
50f0b59 
This is a suggestion to relax the existing verification even more than
we did it in PR #257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {    
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {        
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in #256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in #257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
lanza pushed a commit that referenced this pull request Jan 29, 2024
@gitoleg @lanza
[CIR][IR] Relax get_member verifier for incomplete types (#269)
6f1ce63 
This is a suggestion to relax the existing verification even more than
we did it in PR #257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {    
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {        
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in #256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in #257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
lanza pushed a commit that referenced this pull request Mar 23, 2024
@gitoleg @lanza
[CIR][IR] Relax get_member verifier for incomplete types (#269)
a2bfdbb 
This is a suggestion to relax the existing verification even more than
we did it in PR #257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {    
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {        
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in #256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in #257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
eZWALT pushed a commit to eZWALT/clangir that referenced this pull request Mar 24, 2024
@gitoleg @lanza
[CIR][IR] Relax get_member verifier for incomplete types (llvm#269)
2e08b4e 
This is a suggestion to relax the existing verification even more than
we did it in PR llvm#257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {    
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {        
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in llvm#256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in llvm#257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
eZWALT pushed a commit to eZWALT/clangir that referenced this pull request Mar 24, 2024
@gitoleg @lanza
[CIR][IR] Relax get_member verifier for incomplete types (llvm#269)
4980edd 
This is a suggestion to relax the existing verification even more than
we did it in PR llvm#257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {    
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {        
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in llvm#256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in llvm#257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
lanza pushed a commit that referenced this pull request Apr 29, 2024
@gitoleg @lanza
[CIR][IR] Relax get_member verifier for incomplete types (#269)
6084541 
This is a suggestion to relax the existing verification even more than
we did it in PR #257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {    
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {        
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in #256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in #257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
lanza pushed a commit that referenced this pull request Apr 29, 2024
@gitoleg @lanza
[CIR][IR] Relax get_member verifier for incomplete types (#269)
c224b2e 
This is a suggestion to relax the existing verification even more than
we did it in PR #257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {    
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {        
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in #256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in #257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
eZWALT pushed a commit to eZWALT/clangir that referenced this pull request Apr 29, 2024
@gitoleg @lanza
[CIR][IR] Relax get_member verifier for incomplete types (llvm#269)
ce84943 
This is a suggestion to relax the existing verification even more than
we did it in PR llvm#257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {    
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {        
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in llvm#256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in llvm#257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
lanza pushed a commit that referenced this pull request Apr 29, 2024
@gitoleg @lanza
[CIR][IR] Relax get_member verifier for incomplete types (#269)
185d94d 
This is a suggestion to relax the existing verification even more than
we did it in PR #257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in #256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in #257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
bruteforceboy pushed a commit to bruteforceboy/clangir that referenced this pull request Oct 2, 2024
@gitoleg @lanza
[CIR][IR] Relax get_member verifier for incomplete types (llvm#269)
4c250c5 
This is a suggestion to relax the existing verification even more than
we did it in PR llvm#257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in llvm#256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in llvm#257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
Hugobros3 pushed a commit to shady-gang/clangir that referenced this pull request Oct 2, 2024
@gitoleg @lanza
[CIR][IR] Relax get_member verifier for incomplete types (llvm#269)
47bedc8 
This is a suggestion to relax the existing verification even more than
we did it in PR llvm#257.
Here we also skip verification if a field on the given index is also of
incomplete type - and we can not compare it with the result type of the
operation.

Now the next code fails with type mismatch error:
```
typedef struct Node {
    struct Node* next;
} NodeStru;

void foo(NodeStru* a) {
    a->next = 0;
}
```
because the result type is kind of full and the type of field is not
(for the reasons discussed in llvm#256).
Basically, the problem is in the `GetMemberOp` result type generated as
following (via `CIRGenTypes::convertType`)
`!cir.ptr<!cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node"
incomplete #cir.record.decl.ast>>} #cir.record.decl.ast>>`

where the field type at index differs from the record type - compare
with
 `!cir.ptr<!cir.struct<struct "Node" incomplete #cir.record.decl.ast>>`

We just slightly relax the previous solution in llvm#257 - and the
compilation won't fail in the case of recursive types.

Well, if there are some other thoughts?
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Reviewers

@bcardosolopes bcardosolopes bcardosolopes approved these changes

Assignees
No one assigned
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

Successfully merging this pull request may close these issues.
2 participants
@sitio-couto @bcardosolopes