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.

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

Leverage #cir.zero in large constant strings initializers #248

Closed
sitio-couto opened this issue Aug 30, 2023 · 2 comments · Fixed by #617
Closed

Leverage #cir.zero in large constant strings initializers #248

sitio-couto opened this issue Aug 30, 2023 · 2 comments · Fixed by #617
Assignees
Labels
good first issue Good for newcomers

Comments

@sitio-couto
Copy link
Collaborator

sitio-couto commented Aug 30, 2023

The initializer for the null strings should leverage #cir.zero in some way. The reason for this is to improve performance when facing large zero/prefix-initialized strings. For example:

struct {
  char r[100000];
  char g[100000];
  char b[100000];
} image = {"", "1234", "\0"};

The resulting CIR code for this example consists of three #cir.const_arrays with thousands \00 hexadecimal chars each, making them unnecessarily large.

Originally posted by @sitio-couto in #244 (comment)

@bcardosolopes bcardosolopes added the good first issue Good for newcomers label Oct 23, 2023
bcardosolopes pushed a commit that referenced this issue Jan 4, 2024
This PR addresses #248 .

Currently string literals are always lowered to a `cir.const_array`
attribute even if the string literal only contains null bytes. This
patch make the CodeGen emits `cir.zero` for these string literals.
lanza pushed a commit that referenced this issue Jan 29, 2024
This PR addresses #248 .

Currently string literals are always lowered to a `cir.const_array`
attribute even if the string literal only contains null bytes. This
patch make the CodeGen emits `cir.zero` for these string literals.
lanza pushed a commit that referenced this issue Mar 23, 2024
This PR addresses #248 .

Currently string literals are always lowered to a `cir.const_array`
attribute even if the string literal only contains null bytes. This
patch make the CodeGen emits `cir.zero` for these string literals.
eZWALT pushed a commit to eZWALT/clangir that referenced this issue Mar 24, 2024
This PR addresses llvm#248 .

Currently string literals are always lowered to a `cir.const_array`
attribute even if the string literal only contains null bytes. This
patch make the CodeGen emits `cir.zero` for these string literals.
eZWALT pushed a commit to eZWALT/clangir that referenced this issue Mar 24, 2024
This PR addresses llvm#248 .

Currently string literals are always lowered to a `cir.const_array`
attribute even if the string literal only contains null bytes. This
patch make the CodeGen emits `cir.zero` for these string literals.
@bcardosolopes
Copy link
Member

We have trailing_zeros these days, could be use here.

lanza pushed a commit that referenced this issue Apr 29, 2024
This PR addresses #248 .

Currently string literals are always lowered to a `cir.const_array`
attribute even if the string literal only contains null bytes. This
patch make the CodeGen emits `cir.zero` for these string literals.
lanza pushed a commit that referenced this issue Apr 29, 2024
This PR addresses #248 .

Currently string literals are always lowered to a `cir.const_array`
attribute even if the string literal only contains null bytes. This
patch make the CodeGen emits `cir.zero` for these string literals.
eZWALT pushed a commit to eZWALT/clangir that referenced this issue Apr 29, 2024
This PR addresses llvm#248 .

Currently string literals are always lowered to a `cir.const_array`
attribute even if the string literal only contains null bytes. This
patch make the CodeGen emits `cir.zero` for these string literals.
lanza pushed a commit that referenced this issue Apr 29, 2024
This PR addresses #248 .

Currently string literals are always lowered to a `cir.const_array`
attribute even if the string literal only contains null bytes. This
patch make the CodeGen emits `cir.zero` for these string literals.
@ivanmurashko
Copy link
Contributor

ivanmurashko commented May 13, 2024

I am going to take this task

ivanmurashko added a commit to ivanmurashko/clangir that referenced this issue May 19, 2024
The patch resolves [issue llvm#248](llvm#248). It can be considered a subsequent patch to [llvm#373](llvm#373), where the case of empty strings was processed.

The new patch adds processing for non-empty strings that may contain trailing zeros, such as:
```
char big_string[100000] = "123";
```
That is converted to
```
@big_string = #cir.const_array<"123" : !cir.array<!s8i x 3>, trailing_zeros> : !cir.array<!s8i x 100000>
```

It's worth noting that ordinary strings that are terminated with a single zero also get the trailing zeros, for instance
```
char string[] = "whatnow";
```
Is converted to
```
@string = #cir.const_array<"whatnow" : !cir.array<!s8i x 7>, trailing_zeros> : !cir.array<!s8i x 8>
```
bcardosolopes pushed a commit that referenced this issue May 24, 2024
)

The patch resolves [issue
#248](#248). It can be considered
a subsequent patch to [#373](#373),
where the case of empty strings was processed.

The new patch adds processing for non-empty strings that may contain
trailing zeros, such as:
```
char big_string[100000] = "123";
```
That is converted to
```
@big_string = #cir.const_array<"123" : !cir.array<!s8i x 3>, trailing_zeros> : !cir.array<!s8i x 100000>
```
pysuxing pushed a commit to pysuxing/llvm-project that referenced this issue Jul 17, 2024
…lvm#617)

The patch resolves [issue
llvm#248](llvm/clangir#248). It can be considered
a subsequent patch to [llvm#373](llvm/clangir#373),
where the case of empty strings was processed.

The new patch adds processing for non-empty strings that may contain
trailing zeros, such as:
```
char big_string[100000] = "123";
```
That is converted to
```
@big_string = #cir.const_array<"123" : !cir.array<!s8i x 3>, trailing_zeros> : !cir.array<!s8i x 100000>
```
bruteforceboy pushed a commit to bruteforceboy/clangir that referenced this issue Oct 2, 2024
This PR addresses llvm#248 .

Currently string literals are always lowered to a `cir.const_array`
attribute even if the string literal only contains null bytes. This
patch make the CodeGen emits `cir.zero` for these string literals.
Hugobros3 pushed a commit to shady-gang/clangir that referenced this issue Oct 2, 2024
This PR addresses llvm#248 .

Currently string literals are always lowered to a `cir.const_array`
attribute even if the string literal only contains null bytes. This
patch make the CodeGen emits `cir.zero` for these string literals.
Hugobros3 pushed a commit to shady-gang/clangir that referenced this issue Oct 2, 2024
…lvm#617)

The patch resolves [issue
llvm#248](llvm#248). It can be considered
a subsequent patch to [llvm#373](llvm#373),
where the case of empty strings was processed.

The new patch adds processing for non-empty strings that may contain
trailing zeros, such as:
```
char big_string[100000] = "123";
```
That is converted to
```
@big_string = #cir.const_array<"123" : !cir.array<!s8i x 3>, trailing_zeros> : !cir.array<!s8i x 100000>
```
smeenai pushed a commit to smeenai/clangir that referenced this issue Oct 9, 2024
…lvm#617)

The patch resolves [issue
llvm#248](llvm#248). It can be considered
a subsequent patch to [llvm#373](llvm#373),
where the case of empty strings was processed.

The new patch adds processing for non-empty strings that may contain
trailing zeros, such as:
```
char big_string[100000] = "123";
```
That is converted to
```
@big_string = #cir.const_array<"123" : !cir.array<!s8i x 3>, trailing_zeros> : !cir.array<!s8i x 100000>
```
keryell pushed a commit to keryell/clangir that referenced this issue Oct 19, 2024
This PR addresses llvm#248 .

Currently string literals are always lowered to a `cir.const_array`
attribute even if the string literal only contains null bytes. This
patch make the CodeGen emits `cir.zero` for these string literals.
keryell pushed a commit to keryell/clangir that referenced this issue Oct 19, 2024
…lvm#617)

The patch resolves [issue
llvm#248](llvm#248). It can be considered
a subsequent patch to [llvm#373](llvm#373),
where the case of empty strings was processed.

The new patch adds processing for non-empty strings that may contain
trailing zeros, such as:
```
char big_string[100000] = "123";
```
That is converted to
```
@big_string = #cir.const_array<"123" : !cir.array<!s8i x 3>, trailing_zeros> : !cir.array<!s8i x 100000>
```
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
good first issue Good for newcomers
Projects
None yet
Development

Successfully merging a pull request may close this issue.

3 participants