[clang][CodeGen]Fix clang crash and add bitfield support in __builtin_dump_struct

[yihanaa]

Summary

Fix clang crash and add bitfield support in __builtin_dump_struct.

In clang13.0.x, a struct with three or more members and a bitfield at the same time will cause a crash. In clang15.x, as long as the struct has one bitfield, it will cause a crash in clang.

Open issue: https://github.com/llvm/llvm-project/issues/54462

[xbolva00]

the remaining changes are code formatting

Please remove code formatting changes.

[yihanaa]

Remove code formatting changes.

[yihanaa]

In D122248#3400408, @xbolva00 wrote:

the remaining changes are code formatting

Please remove code formatting changes.

Okay, i have removed.

[yihanaa]

Remove useless comments.

[aaron.ballman]

Thanks for the fix! Can you please add a release note as well?

clang/test/CodeGen/dump-struct-builtin.c

737

Can you add some test coverage for zero-width bit-fields and unnamed bit-fields just to demonstrate how they behave?

[erichkeane]

Seems reasonable to me. Obviously needs release notes + the tests that Aaron did, but I think this looks right.

[yihanaa]

In D122248#3402875, @aaron.ballman wrote:

Thanks for the fix! Can you please add a release note as well?

Okay, i try to add some test case for zero-width bitfield and unnamed bitfield, and add a release notes.

[yihanaa]

1. Support zero-width bitfield, named bitfield and unnamed bitfield.
2. Add a release notes.

The builtin function __builtin_dump_struct behaves for zero-width bitfield and unnamed bitfield as follows

int printf(const char *fmt, ...);

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

int main() {
  foo();
  return 0;
}

Output:

struct Bar {
unsigned int c : 1
unsigned int  : 0
unsigned int b : 2022
}

[yihanaa]

In D122248#3402924, @erichkeane wrote:

Seems reasonable to me. Obviously needs release notes + the tests that Aaron did, but I think this looks right.

Thank you for reminding，i have add a release notes entry and a test case for zero-width bitfield & unnamed bitfield.

[aaron.ballman]

In D122248#3403143, @yihanaa wrote:

1. Support zero-width bitfield, named bitfield and unnamed bitfield.
2. Add a release notes.

The builtin function __builtin_dump_struct behaves for zero-width bitfield and unnamed bitfield as follows

int printf(const char *fmt, ...);

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

int main() {
  foo();
  return 0;
}

Output:

struct Bar {
unsigned int c : 1
unsigned int  : 0
unsigned int b : 2022
}

Thank you for the release note and additional test coverage. I'm wondering why we handle the zero-width bit-field differently from the anonymous one (e.g., why do we not have unsigned int : 3 before the unsigned int : 0? It seems a bit odd to drop that from the output.

[yihanaa]

In D122248#3403315, @aaron.ballman wrote:

In D122248#3403143, @yihanaa wrote:

1. Support zero-width bitfield, named bitfield and unnamed bitfield.
2. Add a release notes.

The builtin function __builtin_dump_struct behaves for zero-width bitfield and unnamed bitfield as follows

int printf(const char *fmt, ...);

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

int main() {
  foo();
  return 0;
}

Output:

struct Bar {
unsigned int c : 1
unsigned int  : 0
unsigned int b : 2022
}

Thank you for the release note and additional test coverage. I'm wondering why we handle the zero-width bit-field differently from the anonymous one (e.g., why do we not have unsigned int : 3 before the unsigned int : 0? It seems a bit odd to drop that from the output.

Thanks, I don't know what the value of this zero-width bitfield should output, can it be a empty value as same as unnamed-bitfield’ she field name?

for example:

struct Bar {
unsigned int c : 1
unsigned int  : 0
unsigned int  :
unsigned int b : 2022
}

[erichkeane]

In D122248#3403343, @yihanaa wrote:

In D122248#3403315, @aaron.ballman wrote:

In D122248#3403143, @yihanaa wrote:

1. Support zero-width bitfield, named bitfield and unnamed bitfield.
2. Add a release notes.

The builtin function __builtin_dump_struct behaves for zero-width bitfield and unnamed bitfield as follows

int printf(const char *fmt, ...);

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

int main() {
  foo();
  return 0;
}

Output:

struct Bar {
unsigned int c : 1
unsigned int  : 0
unsigned int b : 2022
}

Thank you for the release note and additional test coverage. I'm wondering why we handle the zero-width bit-field differently from the anonymous one (e.g., why do we not have unsigned int : 3 before the unsigned int : 0? It seems a bit odd to drop that from the output.

Thanks, I don't know what the value of this zero-width bitfield should output, can it be a empty value as same as unnamed-bitfield’ she field name?

for example:

struct Bar {
unsigned int c : 1
unsigned int  : 0
unsigned int  :
unsigned int b : 2022
}

I would definitely expect this, yes.

[yihanaa]

In D122248#3403349, @erichkeane wrote:

In D122248#3403343, @yihanaa wrote:

In D122248#3403315, @aaron.ballman wrote:

In D122248#3403143, @yihanaa wrote:

1. Support zero-width bitfield, named bitfield and unnamed bitfield.
2. Add a release notes.

The builtin function __builtin_dump_struct behaves for zero-width bitfield and unnamed bitfield as follows

int printf(const char *fmt, ...);

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

int main() {
  foo();
  return 0;
}

Output:

struct Bar {
unsigned int c : 1
unsigned int  : 0
unsigned int b : 2022
}

Thank you for the release note and additional test coverage. I'm wondering why we handle the zero-width bit-field differently from the anonymous one (e.g., why do we not have unsigned int : 3 before the unsigned int : 0? It seems a bit odd to drop that from the output.

Thanks, I don't know what the value of this zero-width bitfield should output, can it be a empty value as same as unnamed-bitfield’ she field name?

for example:

struct Bar {
unsigned int c : 1
unsigned int  : 0
unsigned int  :
unsigned int b : 2022
}

I would definitely expect this, yes.

I will try to modify it according to this rule.

[aaron.ballman]

In D122248#3403349, @erichkeane wrote:

In D122248#3403343, @yihanaa wrote:

In D122248#3403315, @aaron.ballman wrote:

In D122248#3403143, @yihanaa wrote:

1. Support zero-width bitfield, named bitfield and unnamed bitfield.
2. Add a release notes.

The builtin function __builtin_dump_struct behaves for zero-width bitfield and unnamed bitfield as follows

int printf(const char *fmt, ...);

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

int main() {
  foo();
  return 0;
}

Output:

struct Bar {
unsigned int c : 1
unsigned int  : 0
unsigned int b : 2022
}

Thank you for the release note and additional test coverage. I'm wondering why we handle the zero-width bit-field differently from the anonymous one (e.g., why do we not have unsigned int : 3 before the unsigned int : 0? It seems a bit odd to drop that from the output.

Thanks, I don't know what the value of this zero-width bitfield should output, can it be a empty value as same as unnamed-bitfield’ she field name?

for example:

struct Bar {
unsigned int c : 1
unsigned int  : 0
unsigned int  :
unsigned int b : 2022
}

I would definitely expect this, yes.

Oh wow... I was seeing the : in the output and thinking that was showing me the bit width after the colon (given that we show the type information), not the value. I wonder how many other folks are tripped up by that sort of thing? In the meantime, now that I understand the printing format better, I would expect that output as well.

[erichkeane]

In D122248#3403468, @aaron.ballman wrote:

In D122248#3403349, @erichkeane wrote:

In D122248#3403343, @yihanaa wrote:

In D122248#3403315, @aaron.ballman wrote:

In D122248#3403143, @yihanaa wrote:

1. Support zero-width bitfield, named bitfield and unnamed bitfield.
2. Add a release notes.

The builtin function __builtin_dump_struct behaves for zero-width bitfield and unnamed bitfield as follows

int printf(const char *fmt, ...);

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

int main() {
  foo();
  return 0;
}

Output:

struct Bar {
unsigned int c : 1
unsigned int  : 0
unsigned int b : 2022
}

Thank you for the release note and additional test coverage. I'm wondering why we handle the zero-width bit-field differently from the anonymous one (e.g., why do we not have unsigned int : 3 before the unsigned int : 0? It seems a bit odd to drop that from the output.

Thanks, I don't know what the value of this zero-width bitfield should output, can it be a empty value as same as unnamed-bitfield’ she field name?

for example:

struct Bar {
unsigned int c : 1
unsigned int  : 0
unsigned int  :
unsigned int b : 2022
}

I would definitely expect this, yes.

Oh wow... I was seeing the : in the output and thinking that was showing me the bit width after the colon (given that we show the type information), not the value. I wonder how many other folks are tripped up by that sort of thing? In the meantime, now that I understand the printing format better, I would expect that output as well.

Now that you mention it: SHOULD we emit the size of the bitfield on that line? The 'colon' is quite unfortunate there for exactly that reason (the way you misread it).

[erichkeane]

If it is ok, I think we should probably change the format of the 'dump' for fields. Using the colon to split up the field from the value is unfortunate, may I suggest replacing it with '=' instead? As well as printing the size after a colon. So for:

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

Output:

struct Bar {
unsigned int c : 1 = 1
unsigned int : 3  = 0
unsigned int : 0 = 
unsigned int b = 2022
}

What do you all think?

[aaron.ballman]

In D122248#3403478, @erichkeane wrote:

If it is ok, I think we should probably change the format of the 'dump' for fields. Using the colon to split up the field from the value is unfortunate, may I suggest replacing it with '=' instead? As well as printing the size after a colon. So for:

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

Output:

struct Bar {
unsigned int c : 1 = 1
unsigned int : 3  = 0
unsigned int : 0 = 
unsigned int b = 2022
}

What do you all think?

I think that's a good idea for clarity. For the case where we have no value, I wonder if we want to do something like: unsigned int : 0 = <uninitialized> (or something else to make it exceptionally clear that there's nothing missing after the =)?

[yihanaa]

In D122248#3403478, @erichkeane wrote:

If it is ok, I think we should probably change the format of the 'dump' for fields. Using the colon to split up the field from the value is unfortunate, may I suggest replacing it with '=' instead? As well as printing the size after a colon. So for:

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

Output:

struct Bar {
unsigned int c : 1 = 1
unsigned int : 3  = 0
unsigned int : 0 = 
unsigned int b = 2022
}

What do you all think?

good idea！

[yihanaa]

In D122248#3403518, @aaron.ballman wrote:

In D122248#3403478, @erichkeane wrote:

If it is ok, I think we should probably change the format of the 'dump' for fields. Using the colon to split up the field from the value is unfortunate, may I suggest replacing it with '=' instead? As well as printing the size after a colon. So for:

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

Output:

struct Bar {
unsigned int c : 1 = 1
unsigned int : 3  = 0
unsigned int : 0 = 
unsigned int b = 2022
}

What do you all think?

I think that's a good idea for clarity. For the case where we have no value, I wonder if we want to do something like: unsigned int : 0 = <uninitialized> (or something else to make it exceptionally clear that there's nothing missing after the =)?

In D122248#3403518, @aaron.ballman wrote:

In D122248#3403478, @erichkeane wrote:

If it is ok, I think we should probably change the format of the 'dump' for fields. Using the colon to split up the field from the value is unfortunate, may I suggest replacing it with '=' instead? As well as printing the size after a colon. So for:

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

Output:

struct Bar {
unsigned int c : 1 = 1
unsigned int : 3  = 0
unsigned int : 0 = 
unsigned int b = 2022
}

What do you all think?

I think that's a good idea for clarity. For the case where we have no value, I wonder if we want to do something like: unsigned int : 0 = <uninitialized> (or something else to make it exceptionally clear that there's nothing missing after the =)?

How to judge whether this field is initialized? Maybe this memory has been initialized by memset.

Does it just need to be marked with an zero-width bitfield?because we cannot get its value.

[erichkeane]

In D122248#3403636, @yihanaa wrote:

In D122248#3403518, @aaron.ballman wrote:

In D122248#3403478, @erichkeane wrote:

If it is ok, I think we should probably change the format of the 'dump' for fields. Using the colon to split up the field from the value is unfortunate, may I suggest replacing it with '=' instead? As well as printing the size after a colon. So for:

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

Output:

struct Bar {
unsigned int c : 1 = 1
unsigned int : 3  = 0
unsigned int : 0 = 
unsigned int b = 2022
}

What do you all think?

I think that's a good idea for clarity. For the case where we have no value, I wonder if we want to do something like: unsigned int : 0 = <uninitialized> (or something else to make it exceptionally clear that there's nothing missing after the =)?

how

In D122248#3403518, @aaron.ballman wrote:

In D122248#3403478, @erichkeane wrote:

If it is ok, I think we should probably change the format of the 'dump' for fields. Using the colon to split up the field from the value is unfortunate, may I suggest replacing it with '=' instead? As well as printing the size after a colon. So for:

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

Output:

struct Bar {
unsigned int c : 1 = 1
unsigned int : 3  = 0
unsigned int : 0 = 
unsigned int b = 2022
}

What do you all think?

I think that's a good idea for clarity. For the case where we have no value, I wonder if we want to do something like: unsigned int : 0 = <uninitialized> (or something else to make it exceptionally clear that there's nothing missing after the =)?

How to judge whether this field is initialized? Maybe this memory has been initialized by memset

He means a special-case for the 0-size bitfield, which HAS no value (actually, wonder if this is a problem with the no-unique-address types as well?). I might suggest N/A instead of uninitialized, but am open to bikeshedding.

[yihanaa]

In D122248#3403637, @erichkeane wrote:

In D122248#3403636, @yihanaa wrote:

In D122248#3403518, @aaron.ballman wrote:

In D122248#3403478, @erichkeane wrote:

If it is ok, I think we should probably change the format of the 'dump' for fields. Using the colon to split up the field from the value is unfortunate, may I suggest replacing it with '=' instead? As well as printing the size after a colon. So for:

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

Output:

struct Bar {
unsigned int c : 1 = 1
unsigned int : 3  = 0
unsigned int : 0 = 
unsigned int b = 2022
}

What do you all think?

I think that's a good idea for clarity. For the case where we have no value, I wonder if we want to do something like: unsigned int : 0 = <uninitialized> (or something else to make it exceptionally clear that there's nothing missing after the =)?

how

In D122248#3403518, @aaron.ballman wrote:

In D122248#3403478, @erichkeane wrote:

If it is ok, I think we should probably change the format of the 'dump' for fields. Using the colon to split up the field from the value is unfortunate, may I suggest replacing it with '=' instead? As well as printing the size after a colon. So for:

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

Output:

struct Bar {
unsigned int c : 1 = 1
unsigned int : 3  = 0
unsigned int : 0 = 
unsigned int b = 2022
}

What do you all think?

I think that's a good idea for clarity. For the case where we have no value, I wonder if we want to do something like: unsigned int : 0 = <uninitialized> (or something else to make it exceptionally clear that there's nothing missing after the =)?

How to judge whether this field is initialized? Maybe this memory has been initialized by memset

He means a special-case for the 0-size bitfield, which HAS no value (actually, wonder if this is a problem with the no-unique-address types as well?). I might suggest N/A instead of uninitialized, but am open to bikeshedding.

I'm sorry, I misunderstood @aaron.ballman.

In D122248#3403637, @erichkeane wrote:

In D122248#3403636, @yihanaa wrote:

In D122248#3403518, @aaron.ballman wrote:

In D122248#3403478, @erichkeane wrote:

If it is ok, I think we should probably change the format of the 'dump' for fields. Using the colon to split up the field from the value is unfortunate, may I suggest replacing it with '=' instead? As well as printing the size after a colon. So for:

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

Output:

struct Bar {
unsigned int c : 1 = 1
unsigned int : 3  = 0
unsigned int : 0 = 
unsigned int b = 2022
}

What do you all think?

I think that's a good idea for clarity. For the case where we have no value, I wonder if we want to do something like: unsigned int : 0 = <uninitialized> (or something else to make it exceptionally clear that there's nothing missing after the =)?

how

In D122248#3403518, @aaron.ballman wrote:

In D122248#3403478, @erichkeane wrote:

If it is ok, I think we should probably change the format of the 'dump' for fields. Using the colon to split up the field from the value is unfortunate, may I suggest replacing it with '=' instead? As well as printing the size after a colon. So for:

void foo(void) {
  struct Bar {
    unsigned c : 1;
    unsigned : 3;
    unsigned : 0;
    unsigned b;
  };

  struct Bar a = {
    .c = 1,
    .b = 2022,
  };

  __builtin_dump_struct(&a, &printf);
}

Output:

struct Bar {
unsigned int c : 1 = 1
unsigned int : 3  = 0
unsigned int : 0 = 
unsigned int b = 2022
}

What do you all think?

I think that's a good idea for clarity. For the case where we have no value, I wonder if we want to do something like: unsigned int : 0 = <uninitialized> (or something else to make it exceptionally clear that there's nothing missing after the =)?

How to judge whether this field is initialized? Maybe this memory has been initialized by memset

He means a special-case for the 0-size bitfield, which HAS no value (actually, wonder if this is a problem with the no-unique-address types as well?). I might suggest N/A instead of uninitialized, but am open to bikeshedding.

I'm sorry I misunderstood what you meant @aaron.ballman.

Can we follow the lead of LLVM IR？it use 'undef'
for example:

struct T6A {
    unsigned a : 1;
    unsigned  : 0;
    unsigned c : 1;
};

@__const.foo.a = private unnamed_addr constant %struct.T6A { i8 1, [3 x i8] undef, i8 1, [3 x i8] undef }, align 4

i'm open to bikeshedding too.

[erichkeane]

I'm sorry I misunderstood what you meant @aaron.ballman.

Can we follow the lead of LLVM IR？it use 'undef'
for example:

struct T6A {
    unsigned a : 1;
    unsigned  : 0;
    unsigned c : 1;
};

@__const.foo.a = private unnamed_addr constant %struct.T6A { i8 1, [3 x i8] undef, i8 1, [3 x i8] undef }, align 4

I misunderstood him too, he told me off line :)

I guess I would be 'ok' with undef, though that has a different meaning (it means, this has an arbitrary value). In this case, it has NO value, which is somewhat different.

[yihanaa]

In D122248#3403698, @erichkeane wrote:

I'm sorry I misunderstood what you meant @aaron.ballman.

Can we follow the lead of LLVM IR？it use 'undef'
for example:

struct T6A {
    unsigned a : 1;
    unsigned  : 0;
    unsigned c : 1;
};

@__const.foo.a = private unnamed_addr constant %struct.T6A { i8 1, [3 x i8] undef, i8 1, [3 x i8] undef }, align 4

I misunderstood him too, he told me off line :)

I guess I would be 'ok' with undef, though that has a different meaning (it means, this has an arbitrary value). In this case, it has NO value, which is somewhat different.

What if we don't emit '=' for zero-width bitfield, like this:

struct Bar {
unsigned c : 1;
unsigned : 3;
unsigned : 0;
unsigned b;
};

struct Bar {
unsigned int c : 1 = 0
unsigned int   : 3 = 0
unsigned int   : 0
unsigned int b = 0
}

What do you all think?

[aaron.ballman]

In D122248#3403734, @yihanaa wrote:

What if we don't emit '=' for zero-width bitfield, like this:

struct Bar {
unsigned c : 1;
unsigned : 3;
unsigned : 0;
unsigned b;
};

struct Bar {
unsigned int c : 1 = 0
unsigned int   : 3 = 0
unsigned int   : 0
unsigned int b = 0
}

What do you all think?

I like this idea best of all!

[erichkeane]

In D122248#3405062, @aaron.ballman wrote:

In D122248#3403734, @yihanaa wrote:

What if we don't emit '=' for zero-width bitfield, like this:

struct Bar {
unsigned c : 1;
unsigned : 3;
unsigned : 0;
unsigned b;
};

struct Bar {
unsigned int c : 1 = 0
unsigned int   : 3 = 0
unsigned int   : 0
unsigned int b = 0
}

What do you all think?

I like this idea best of all!

Agreed!

[yihanaa]

In D122248#3405166, @erichkeane wrote:

In D122248#3405062, @aaron.ballman wrote:

In D122248#3403734, @yihanaa wrote:

What if we don't emit '=' for zero-width bitfield, like this:

struct Bar {
unsigned c : 1;
unsigned : 3;
unsigned : 0;
unsigned b;
};

struct Bar {
unsigned int c : 1 = 0
unsigned int   : 3 = 0
unsigned int   : 0
unsigned int b = 0
}

What do you all think?

I like this idea best of all!

Agreed!

@erichkeane @aaron.ballman
Previously we used FieldDecl->getNameAsString to get the field name, but the comments for this function indicate that it is Deprecated，and suggestion move clients to getName().

The FieldDecl->getName() return the anonymous inner struct's name like:

struct T3A {
  union {
    int a;
    char b[4];
  };
};

struct T3A {
union T3A::(anonymous at ./builtin_dump_struct.c:77:5) {
    int a = 42
    char[4] b = 0x2a
    }
}

what do you all think?

[aaron.ballman]

In D122248#3405644, @yihanaa wrote:

In D122248#3405166, @erichkeane wrote:

In D122248#3405062, @aaron.ballman wrote:

In D122248#3403734, @yihanaa wrote:

What if we don't emit '=' for zero-width bitfield, like this:

struct Bar {
unsigned c : 1;
unsigned : 3;
unsigned : 0;
unsigned b;
};

struct Bar {
unsigned int c : 1 = 0
unsigned int   : 3 = 0
unsigned int   : 0
unsigned int b = 0
}

What do you all think?

I like this idea best of all!

Agreed!

@erichkeane @aaron.ballman
Previously we used FieldDecl->getNameAsString to get the field name, but the comments for this function indicate that it is Deprecated，and suggestion move clients to getName().

The FieldDecl->getName() return the anonymous inner struct's name like:

struct T3A {
  union {
    int a;
    char b[4];
  };
};

struct T3A {
union T3A::(anonymous at ./builtin_dump_struct.c:77:5) {
    int a = 42
    char[4] b = 0x2a
    }
}

what do you all think?

I would probably keep using getNameAsString() as I don't think the extra information helps overly much. That interface was marked deprecated 13 years ago, so don't feel bad for making use of it.

[erichkeane]

Agreed. DeclarationName::getAsString is in no way marked deprecated though, so you could call that?

FieldDecl->getDeclName()->getAsString() or the DeclarationName operator<< would both be equivalent with no threat of deprecation.

[yihanaa]

Support dump bitwidth of bitfields, and unnamed bitfields.
for example:

struct Bar {
unsigned c : 1;
unsigned : 3;
unsigned : 0;
unsigned b;
};

struct Bar {
unsigned int c : 1 = 0
unsigned int   : 3 = 0
unsigned int   : 0
unsigned int b = 0
}

[yihanaa]

In D122248#3405866, @aaron.ballman wrote:

In D122248#3405644, @yihanaa wrote:

In D122248#3405166, @erichkeane wrote:

In D122248#3405062, @aaron.ballman wrote:

In D122248#3403734, @yihanaa wrote:

What if we don't emit '=' for zero-width bitfield, like this:

struct Bar {
unsigned c : 1;
unsigned : 3;
unsigned : 0;
unsigned b;
};

struct Bar {
unsigned int c : 1 = 0
unsigned int   : 3 = 0
unsigned int   : 0
unsigned int b = 0
}

What do you all think?

I like this idea best of all!

Agreed!

@erichkeane @aaron.ballman
Previously we used FieldDecl->getNameAsString to get the field name, but the comments for this function indicate that it is Deprecated，and suggestion move clients to getName().

The FieldDecl->getName() return the anonymous inner struct's name like:

struct T3A {
  union {
    int a;
    char b[4];
  };
};

struct T3A {
union T3A::(anonymous at ./builtin_dump_struct.c:77:5) {
    int a = 42
    char[4] b = 0x2a
    }
}

what do you all think?

I would probably keep using getNameAsString() as I don't think the extra information helps overly much. That interface was marked deprecated 13 years ago, so don't feel bad for making use of it.

Okay,

In D122248#3405926, @erichkeane wrote:

Agreed. DeclarationName::getAsString is in no way marked deprecated though, so you could call that?

FieldDecl->getDeclName()->getAsString() or the DeclarationName operator<< would both be equivalent with no threat of deprecation.

Thanks @erichkeane @aaron.ballman , i have updated the diff.

[erichkeane]

clang/docs/ReleaseNotes.rst

81

Perhaps worth making a separate release note for the change in format?

clang/lib/CodeGen/CGBuiltin.cpp

2093

This seems like a pretty expensive way to do this... Can you do this as FD->getDeclName().empty()?

[yihanaa]

Maybe add the changes under "Attribute Changes in Clang"?

clang/docs/ReleaseNotes.rst

81

Okay, Under which ReleaseNotes tag should I add? i can't think of a good idea 😂

clang/lib/CodeGen/CGBuiltin.cpp

2093

Okay

[erichkeane]

clang/docs/ReleaseNotes.rst

81

I think attribute changes would be a good idea (in addition to this one staying where it is).

[yihanaa]

Use `FD->getDeclName().empty() instead of FD->getNameAsString().empty()`
Add a the format changes to release notes

[yihanaa]

Waitting for CI...

[erichkeane]

LGTM! Please give Aaron a few hours (perhaps until tomorrow?) to take 1 last look before committing.

Also, if you lack commit rights and need someone to commit for you, please provide the name + email address you'd like it committed under.

[yihanaa]

In D122248#3406117, @erichkeane wrote:

LGTM! Please give Aaron a few hours (perhaps until tomorrow?) to take 1 last look before committing.

Also, if you lack commit rights and need someone to commit for you, please provide the name + email address you'd like it committed under.

Thanks for your help and review @erichkeane, @aaron.ballman 😉 . I don’t have commit access, (if Aaron are no objections after a few hours) Please use “wangyihan [e-mail]” to commit the change.

[aaron.ballman]

LGTM aside from a tiny nit with one of the release notes.

clang/docs/ReleaseNotes.rst

140–144

Er, this is a builtin and not an attribute, so I'd put it under the "Non-comprehensive list of changes in this release" heading instead.

[yihanaa]

In D122248#3406145, @aaron.ballman wrote:

LGTM aside from a tiny nit with one of the release notes.

I'd be happy to fix it

In D122248#3406145, @aaron.ballman wrote:

LGTM aside from a tiny nit with one of the release notes.

[erichkeane]

In D122248#3406162, @yihanaa wrote:

In D122248#3406145, @aaron.ballman wrote:

LGTM aside from a tiny nit with one of the release notes.

I'd be happy to fix it

In D122248#3406145, @aaron.ballman wrote:

LGTM aside from a tiny nit with one of the release notes.

Don't worry about it, I'll make the change as part of committing.

[yihanaa]

Put the dump format changes under the "Non-comprehensive list of changes in this release" heading instead.

[yihanaa]

In D122248#3406180, @erichkeane wrote:

In D122248#3406162, @yihanaa wrote:

In D122248#3406145, @aaron.ballman wrote:

LGTM aside from a tiny nit with one of the release notes.

I'd be happy to fix it

In D122248#3406145, @aaron.ballman wrote:

LGTM aside from a tiny nit with one of the release notes.

Don't worry about it, I'll make the change as part of committing.

Thanks, i edited it, if there is anything wrong, please help me correct it😊

[aaron.ballman]

Thank you for the fix and the improvements here, @yihanaa!

[tambre]

clang/docs/ReleaseNotes.rst

95–96

Though I'd split the note about supporting dumping of bitfield widths into a separate point.

144

[rsmith]

clang/lib/CodeGen/CGBuiltin.cpp

2113–2117

After this patch, this case no longer prints the field name. Eg: https://godbolt.org/z/o7vcbWaEf

#include <stdio.h>

struct A {};

struct B {
    A a;
};


int main() {
    B x;
    __builtin_dump_struct(&x, &printf);
}

now prints:

B {
    A {
    }
}

This seems like an important regression; please can you take a look? This also suggests to me that there's a hole in our test coverage.

[yihanaa]

clang/lib/CodeGen/CGBuiltin.cpp

2113–2117

Thanks for taking the time to review my patch and writing the Compiler Explorer examples, I'll take a look at this problem

[yihanaa]

clang/lib/CodeGen/CGBuiltin.cpp

2113–2117

After this patch, this case no longer prints the field name. Eg: https://godbolt.org/z/o7vcbWaEf

#include <stdio.h>

struct A {};

struct B {
    A a;
};


int main() {
    B x;
    __builtin_dump_struct(&x, &printf);
}

now prints:

B {
    A {
    }
}

This seems like an important regression; please can you take a look? This also suggests to me that there's a hole in our test coverage.

I'm sorry for introducing this bug. 😔 Do you think the following is correct behavior? If yes I will try to fix it.

struct B {
    struct A a = {
    }
}

[yihanaa]

clang/lib/CodeGen/CGBuiltin.cpp

2113–2117

I have submitted a patch to fix this. https://reviews.llvm.org/D122920

[yihanaa]

clang/lib/CodeGen/CGBuiltin.cpp

2113–2117

I have submitted a patch to fix this. https://reviews.llvm.org/D122920

Please can you take a review？@rsmith

clang/docs/ReleaseNotes.rst

- Previously invalid member variables with template parameters would crash clang.
   Now fixed by setting identifiers for them.
   This fixes `Issue 28475 (PR28101) <https://github.com/llvm/llvm-project/issues/28475>`_.
 - Now allow the `restrict` and `_Atomic` qualifiers to be used in conjunction
   with `__auto_type` to match the behavior in GCC. This fixes
   `Issue 53652 <https://github.com/llvm/llvm-project/issues/53652>`_.
 - No longer crash when specifying a variably-modified parameter type in a
   function with the ``naked`` attribute. This fixes
   `Issue 50541 <https://github.com/llvm/llvm-project/issues/50541>`_.
 
-
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - ``-Wliteral-range`` will warn on floating-point equality comparisons with
   constants that are not representable in a casted value. For example,
   ``(float) f == 0.1`` is always false.
 - ``-Winline-namespace-reopened-noninline`` now takes into account that the
   ``inline`` keyword must appear on the original but not necessarily all
   extension definitions of an inline namespace and therefore points its note
   at the original definition. This fixes `Issue 50794 (PR51452)
   <https://github.com/llvm/llvm-project/issues/50794>`_.
 
 Non-comprehensive list of changes in this release
+- The builtin function __builtin_dump_struct would crash clang when the target 
+  struct have bitfield. Now it fixed, and __builtin_dump_struct support dump
+  the bitwidth of bitfields.
+  This fixes `Issue 54462 <https://github.com/llvm/llvm-project/issues/54462>`_.
 -------------------------------------------------
 
 New Compiler Flags
 ------------------
 
 Deprecated Compiler Flags
 -------------------------
 

 - Statement attributes ``[[clang::noinline]]`` and  ``[[clang::always_inline]]``
   can be used to control inlining decisions at callsites.
 
 - ``#pragma clang attribute push`` now supports multiple attributes within a single directive.
 
 - The ``__declspec(naked)`` attribute can no longer be written on a member
   function in Microsoft compatibility mode, matching the behavior of cl.exe.
 
+- Improve __builtin_dump_struct:
+
+  - Support bitfields in struct and union.
+  
+  - Improve the dump format, dump both bitwidth(if its a bitfield) and field value.
+
 Windows Support
 ---------------
 
 - Add support for MSVC-compatible ``/JMC``/``/JMC-`` flag in clang-cl (supports
   X86/X64/ARM/ARM64). ``/JMC`` could only be used when ``/Zi`` or ``/Z7`` is
   turned on. With this addition, clang-cl can be used in Visual Studio for the
   JustMyCode feature. Note, you may need to manually add ``/JMC`` as additional
   compile options in the Visual Studio since it currently assumes clang-cl does not support ``/JMC``.

clang/lib/CodeGen/CGBuiltin.cpp

EmitCheckedMixedSignMultiply(CodeGenFunction &CGF, const clang::Expr *Op1,
   bool isVolatile =
       ResultArg->getType()->getPointeeType().isVolatileQualified();
   CGF.Builder.CreateStore(CGF.EmitToMemory(Result, ResultQTy), ResultPtr,
                           isVolatile);
   return RValue::get(Overflow);
 }
 
 static llvm::Value *dumpRecord(CodeGenFunction &CGF, QualType RType,
-                               Value *&RecordPtr, CharUnits Align,
+                               LValue RecordLV, CharUnits Align,
                                llvm::FunctionCallee Func, int Lvl) {
   ASTContext &Context = CGF.getContext();
   RecordDecl *RD = RType->castAs<RecordType>()->getDecl()->getDefinition();
   std::string Pad = std::string(Lvl * 4, ' ');
 
   Value *GString =
       CGF.Builder.CreateGlobalStringPtr(RType.getAsString() + " {\n");
   Value *Res = CGF.Builder.CreateCall(Func, {GString});
if (Types.empty()) {
     Types[Context.FloatTy] = "%f";
     Types[Context.DoubleTy] = "%f";
     Types[Context.LongDoubleTy] = "%Lf";
     Types[Context.getPointerType(Context.CharTy)] = "%s";
     Types[Context.getPointerType(Context.getConstType(Context.CharTy))] = "%s";
   }
 
   for (const auto *FD : RD->fields()) {
-    Value *FieldPtr = RecordPtr;
-    if (RD->isUnion())
-      FieldPtr = CGF.Builder.CreatePointerCast(
-          FieldPtr, CGF.ConvertType(Context.getPointerType(FD->getType())));
-    else
-      FieldPtr = CGF.Builder.CreateStructGEP(CGF.ConvertType(RType), FieldPtr,
-                                             FD->getFieldIndex());
+    Value *TmpRes = nullptr;
 
-    GString = CGF.Builder.CreateGlobalStringPtr(
-        llvm::Twine(Pad)
+    std::string Format = llvm::Twine(Pad)
                              .concat(FD->getType().getAsString())
                              .concat(llvm::Twine(' '))
                              .concat(FD->getNameAsString())
-            .concat(" : ")
-            .str());
-    Value *TmpRes = CGF.Builder.CreateCall(Func, {GString});
+                             .str();
+
+    if (FD->isBitField()) {
+      unsigned BitfieldWidth = FD->getBitWidthValue(CGF.getContext());
+
+      // If current field is a unnamed bitfield, we should dump only one ' '
+      // between type-name and ':'
+      if (!FD->getDeclName().isEmpty())
+        Format += ' ';
+      Format += llvm::Twine(": ").concat(llvm::Twine(BitfieldWidth)).str();
+
+      // If current field is a zero-width bitfield, we just dump a string like
+      // 'type-name : 0'
+      if (FD->isZeroSize(CGF.getContext())) {
+        Format += "\n";
+        GString = CGF.Builder.CreateGlobalStringPtr(Format);
+        TmpRes = CGF.Builder.CreateCall(Func, {GString});
         Res = CGF.Builder.CreateAdd(Res, TmpRes);
+        continue;
+      }
+    }
 
+    LValue FieldLV = CGF.EmitLValueForField(RecordLV, FD);
     QualType CanonicalType =
         FD->getType().getUnqualifiedType().getCanonicalType();
 
     // We check whether we are in a recursive type
     if (CanonicalType->isRecordType()) {
-      TmpRes = dumpRecord(CGF, CanonicalType, FieldPtr, Align, Func, Lvl + 1);
+      TmpRes = dumpRecord(CGF, CanonicalType, FieldLV, Align, Func, Lvl + 1);
       Res = CGF.Builder.CreateAdd(TmpRes, Res);
       continue;
     }
 
     // We try to determine the best format to print the current field
-    llvm::Twine Format = Types.find(CanonicalType) == Types.end()
+    const char *TypeFormat = Types.find(CanonicalType) == Types.end()
                                  ? Types[Context.VoidPtrTy]
                                  : Types[CanonicalType];
 
-    Address FieldAddress =
-        Address(FieldPtr, CGF.ConvertTypeForMem(FD->getType()), Align);
-    FieldPtr = CGF.Builder.CreateLoad(FieldAddress);
-
-    // FIXME Need to handle bitfield here
-    GString = CGF.Builder.CreateGlobalStringPtr(
-        Format.concat(llvm::Twine('\n')).str());
-    TmpRes = CGF.Builder.CreateCall(Func, {GString, FieldPtr});
+    GString = CGF.Builder.CreateGlobalStringPtr(llvm::Twine(Format)
+                                                    .concat(" = ")
+                                                    .concat(TypeFormat)
+                                                    .concat(llvm::Twine('\n'))
+                                                    .str());
+
+    RValue RV = FD->isBitField()
+                    ? CGF.EmitLoadOfBitfieldLValue(FieldLV, FD->getLocation())
+                    : CGF.EmitLoadOfLValue(FieldLV, FD->getLocation());
+    TmpRes = CGF.Builder.CreateCall(Func, {GString, RV.getScalarVal()});
     Res = CGF.Builder.CreateAdd(Res, TmpRes);
   }
 
   GString = CGF.Builder.CreateGlobalStringPtr(Pad + "}\n");
   Value *TmpRes = CGF.Builder.CreateCall(Func, {GString});
   Res = CGF.Builder.CreateAdd(Res, TmpRes);
   return Res;
 }
case Builtin::BI__builtin_dump_struct: {
 
     Value *Func = EmitScalarExpr(E->getArg(1)->IgnoreImpCasts());
     CharUnits Arg0Align = EmitPointerWithAlignment(E->getArg(0)).getAlignment();
 
     const Expr *Arg0 = E->getArg(0)->IgnoreImpCasts();
     QualType Arg0Type = Arg0->getType()->getPointeeType();
 
     Value *RecordPtr = EmitScalarExpr(Arg0);
-    Value *Res = dumpRecord(*this, Arg0Type, RecordPtr, Arg0Align,
+    LValue RecordLV = MakeAddrLValue(RecordPtr, Arg0Type, Arg0Align);
+    Value *Res = dumpRecord(*this, Arg0Type, RecordLV, Arg0Align,
                             {LLVMFuncType, Func}, 0);
     return RValue::get(Res);
   }
 
   case Builtin::BI__builtin_preserve_access_index: {
     // Only enabled preserved access index region when debuginfo
     // is available as debuginfo is needed to preserve user-level
     // access pattern.

clang/test/CodeGen/dump-struct-builtin.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
 
 #include "Inputs/stdio.h"
 #include <stdint.h>
 
 // CHECK: @__const.unit1.a = private unnamed_addr constant %struct.U1A { i16 12 }, align 2
-// CHECK-NEXT: [[STRUCT_STR_U1:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U1A {\0A\00"
-// CHECK-NEXT: [[FIELD_U1:@[0-9]+]] = private unnamed_addr constant [11 x i8] c"short a : \00"
-// CHECK-NEXT: [[FORMAT_U1:@[0-9]+]] = private unnamed_addr constant [5 x i8] c"%hd\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U1:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U1:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U1A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U1:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"short a = %hd\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U1:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit2.a = private unnamed_addr constant %struct.U2A { i16 12 }, align 2
-// CHECK-NEXT: [[STRUCT_STR_U2:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U2A {\0A\00"
-// CHECK-NEXT: [[FIELD_U2:@[0-9]+]] = private unnamed_addr constant [20 x i8] c"unsigned short a : \00"
-// CHECK-NEXT: [[FORMAT_U2:@[0-9]+]] = private unnamed_addr constant [5 x i8] c"%hu\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U2:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U2:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U2A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U2:@[0-9]+]] = private unnamed_addr constant [24 x i8] c"unsigned short a = %hu\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U2:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit3.a = private unnamed_addr constant %struct.U3A { i32 12 }, align 4
-// CHECK-NEXT: [[STRUCT_STR_U3:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U3A {\0A\00"
-// CHECK-NEXT: [[FIELD_U3:@[0-9]+]] = private unnamed_addr constant [9 x i8] c"int a : \00"
-// CHECK-NEXT: [[FORMAT_U3:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%d\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U3:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U3:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U3A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U3:@[0-9]+]] = private unnamed_addr constant [12 x i8] c"int a = %d\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U3:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit4.a = private unnamed_addr constant %struct.U4A { i32 12 }, align 4
-// CHECK-NEXT: [[STRUCT_STR_U4:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U4A {\0A\00"
-// CHECK-NEXT: [[FIELD_U4:@[0-9]+]] = private unnamed_addr constant [18 x i8] c"unsigned int a : \00"
-// CHECK-NEXT: [[FORMAT_U4:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%u\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U4:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U4:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U4A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U4:@[0-9]+]] = private unnamed_addr constant [21 x i8] c"unsigned int a = %u\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U4:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit5.a = private unnamed_addr constant %struct.U5A { i64 12 }, align 8
-// CHECK-NEXT: [[STRUCT_STR_U5:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U5A {\0A\00"
-// CHECK-NEXT: [[FIELD_U5:@[0-9]+]] = private unnamed_addr constant [10 x i8] c"long a : \00"
-// CHECK-NEXT: [[FORMAT_U5:@[0-9]+]] = private unnamed_addr constant [5 x i8] c"%ld\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U5:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U5:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U5A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U5:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"long a = %ld\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U5:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit6.a = private unnamed_addr constant %struct.U6A { i64 12 }, align 8
-// CHECK-NEXT: [[STRUCT_STR_U6:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U6A {\0A\00"
-// CHECK-NEXT: [[FIELD_U6:@[0-9]+]] = private unnamed_addr constant [19 x i8] c"unsigned long a : \00"
-// CHECK-NEXT: [[FORMAT_U6:@[0-9]+]] = private unnamed_addr constant [5 x i8] c"%lu\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U6:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U6:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U6A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U6:@[0-9]+]] = private unnamed_addr constant [23 x i8] c"unsigned long a = %lu\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U6:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit7.a = private unnamed_addr constant %struct.U7A { i64 12 }, align 8
-// CHECK-NEXT: [[STRUCT_STR_U7:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U7A {\0A\00"
-// CHECK-NEXT: [[FIELD_U7:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"long long a : \00"
-// CHECK-NEXT: [[FORMAT_U7:@[0-9]+]] = private unnamed_addr constant [6 x i8] c"%lld\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U7:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U7:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U7A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U7:@[0-9]+]] = private unnamed_addr constant [20 x i8] c"long long a = %lld\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U7:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit8.a = private unnamed_addr constant %struct.U8A { i64 12 }, align 8
-// CHECK-NEXT: [[STRUCT_STR_U8:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U8A {\0A\00"
-// CHECK-NEXT: [[FIELD_U8:@[0-9]+]] = private unnamed_addr constant [24 x i8] c"unsigned long long a : \00"
-// CHECK-NEXT: [[FORMAT_U8:@[0-9]+]] = private unnamed_addr constant [6 x i8] c"%llu\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U8:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U8:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U8A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U8:@[0-9]+]] = private unnamed_addr constant [29 x i8] c"unsigned long long a = %llu\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U8:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit9.a = private unnamed_addr constant %struct.U9A { i8 97 }, align 1
-// CHECK-NEXT: [[STRUCT_STR_U9:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U9A {\0A\00"
-// CHECK-NEXT: [[FIELD_U9:@[0-9]+]] = private unnamed_addr constant [10 x i8] c"char a : \00"
-// CHECK-NEXT: [[FORMAT_U9:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%c\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U9:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U9:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U9A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U9:@[0-9]+]] = private unnamed_addr constant [13 x i8] c"char a = %c\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U9:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @.str = private unnamed_addr constant [4 x i8] c"LSE\00", align 1
-
 // CHECK: @__const.unit10.a = private unnamed_addr constant %struct.U10A { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0) }, align 8
-// CHECK-NEXT: [[STRUCT_STR_U10:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U10A {\0A\00"
-// CHECK-NEXT: [[FIELD_U10:@[0-9]+]] = private unnamed_addr constant [12 x i8] c"char * a : \00"
-// CHECK-NEXT: [[FORMAT_U10:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%s\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U10:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U10:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U10A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U10:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"char * a = %s\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U10:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit11.a = private unnamed_addr constant %struct.U11A { i8* inttoptr (i64 305419896 to i8*) }, align 8
-// CHECK-NEXT: [[STRUCT_STR_U11:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U11A {\0A\00"
-// CHECK-NEXT: [[FIELD_U11:@[0-9]+]] = private unnamed_addr constant [12 x i8] c"void * a : \00"
-// CHECK-NEXT: [[FORMAT_U11:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%p\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U11:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U11:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U11A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U11:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"void * a = %p\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U11:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit12.a = private unnamed_addr constant %struct.U12A { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0) }, align 8
-// CHECK-NEXT: [[STRUCT_STR_U12:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U12A {\0A\00"
-// CHECK-NEXT: [[FIELD_U12:@[0-9]+]] = private unnamed_addr constant [18 x i8] c"const char * a : \00"
-// CHECK-NEXT: [[FORMAT_U12:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%s\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U12:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U12:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U12A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U12:@[0-9]+]] = private unnamed_addr constant [21 x i8] c"const char * a = %s\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U12:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit13.a = private unnamed_addr constant %struct.U13A { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0) }, align 8
-// CHECK-NEXT: [[STRUCT_STR_U13:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U13A {\0A\00"
-// CHECK-NEXT: [[FIELD_U13:@[0-9]+]] = private unnamed_addr constant [20 x i8] c"const charstar a : \00"
-// CHECK-NEXT: [[FORMAT_U13:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%s\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U13:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U13:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U13A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U13:@[0-9]+]] = private unnamed_addr constant [23 x i8] c"const charstar a = %s\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U13:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit14.a = private unnamed_addr constant %struct.U14A { double 0x3FF1F9ACFFA7EB6C }, align 8
-// CHECK-NEXT: [[STRUCT_STR_U14:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U14A {\0A\00"
-// CHECK-NEXT: [[FIELD_U14:@[0-9]+]] = private unnamed_addr constant [12 x i8] c"double a : \00"
-// CHECK-NEXT: [[FORMAT_U14:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%f\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U14:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U14:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U14A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U14:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"double a = %f\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U14:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit15.a = private unnamed_addr constant %struct.U15A { [3 x i32] [i32 1, i32 2, i32 3] }, align 4
-// CHECK-NEXT: [[STRUCT_STR_U15:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U15A {\0A\00"
-// CHECK-NEXT: [[FIELD_U15:@[0-9]+]] = private unnamed_addr constant [12 x i8] c"int[3] a : \00"
-// CHECK-NEXT: [[FORMAT_U15:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%p\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U15:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U15:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U15A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U15:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"int[3] a = %p\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U15:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit16.a = private unnamed_addr constant %struct.U16A { i8 12 }, align 1
-// CHECK-NEXT: [[STRUCT_STR_U16:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U16A {\0A\00"
-// CHECK-NEXT: [[FIELD_U16:@[0-9]+]] = private unnamed_addr constant [13 x i8] c"uint8_t a : \00"
-// CHECK-NEXT: [[FORMAT_U16:@[0-9]+]] = private unnamed_addr constant [6 x i8] c"%hhu\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U16:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U16:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U16A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U16:@[0-9]+]] = private unnamed_addr constant [18 x i8] c"uint8_t a = %hhu\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U16:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit17.a = private unnamed_addr constant %struct.U17A { i8 12 }, align 1
-// CHECK-NEXT: [[STRUCT_STR_U17:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U17A {\0A\00"
-// CHECK-NEXT: [[FIELD_U17:@[0-9]+]] = private unnamed_addr constant [12 x i8] c"int8_t a : \00"
-// CHECK-NEXT: [[FORMAT_U17:@[0-9]+]] = private unnamed_addr constant [6 x i8] c"%hhd\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U17:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U17:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U17A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U17:@[0-9]+]] = private unnamed_addr constant [17 x i8] c"int8_t a = %hhd\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U17:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit18.a = private unnamed_addr constant %struct.U18A { x86_fp80 0xK3FFF8FCD67FD3F5B6000 }, align 16
-// CHECK-NEXT: [[STRUCT_STR_U18:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U18A {\0A\00"
-// CHECK-NEXT: [[FIELD_U18:@[0-9]+]] = private unnamed_addr constant [17 x i8] c"long double a : \00"
-// CHECK-NEXT: [[FORMAT_U18:@[0-9]+]] = private unnamed_addr constant [5 x i8] c"%Lf\0A\00"
-// CHECK-NEXT: [[END_STRUCT_U18:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
+// CHECK-NEXT: [[STRUCT_STR_U18:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U18A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U18:@[0-9]+]] = private unnamed_addr constant [21 x i8] c"long double a = %Lf\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U18:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 int printf(const char *fmt, ...) {
     return 0;
 }
 
 void unit1(void) {
   struct U1A {
     short a;
   };
 
   struct U1A a = {
       .a = 12,
   };
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U1]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U1A, %struct.U1A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* [[FIELD_U1]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U1A, %struct.U1A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i16, i16* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* [[FORMAT_U1]], i32 0, i32 0), i16 [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[FIELD_U1]], i32 0, i32 0), i16 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U1]], i32 0, i32 0))
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit2(void) {
   struct U2A {
     unsigned short a;
   };
 
   struct U2A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U2]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U2A, %struct.U2A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* [[FIELD_U2]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U2A, %struct.U2A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i16, i16* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* [[FORMAT_U2]], i32 0, i32 0), i16 [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* [[FIELD_U2]], i32 0, i32 0), i16 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U2]], i32 0, i32 0))
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit3(void) {
   struct U3A {
     int a;
   };
 
   struct U3A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U3]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U3A, %struct.U3A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* [[FIELD_U3]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U3A, %struct.U3A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i32, i32* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* [[FORMAT_U3]], i32 0, i32 0), i32 [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* [[FIELD_U3]], i32 0, i32 0), i32 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U3]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit4(void) {
   struct U4A {
     unsigned int a;
   };
 
   struct U4A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U4]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U4A, %struct.U4A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* [[FIELD_U4]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U4A, %struct.U4A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i32, i32* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* [[FORMAT_U4]], i32 0, i32 0), i32 [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* [[FIELD_U4]], i32 0, i32 0), i32 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U4]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit5(void) {
   struct U5A {
     long a;
   };
 
   struct U5A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U5]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U5A, %struct.U5A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* [[FIELD_U5]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U5A, %struct.U5A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i64, i64* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* [[FORMAT_U5]], i32 0, i32 0), i64 [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[FIELD_U5]], i32 0, i32 0), i64 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U5]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit6(void) {
   struct U6A {
     unsigned long a;
   };
 
   struct U6A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U6]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U6A, %struct.U6A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* [[FIELD_U6]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U6A, %struct.U6A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i64, i64* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* [[FORMAT_U6]], i32 0, i32 0), i64 [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* [[FIELD_U6]], i32 0, i32 0), i64 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U6]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit7(void) {
   struct U7A {
     long long a;
   };
 
   struct U7A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U7]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U7A, %struct.U7A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[FIELD_U7]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U7A, %struct.U7A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i64, i64* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* [[FORMAT_U7]], i32 0, i32 0), i64 [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* [[FIELD_U7]], i32 0, i32 0), i64 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U7]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit8(void) {
   struct U8A {
     unsigned long long a;
   };
 
   struct U8A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U8]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U8A, %struct.U8A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* [[FIELD_U8]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U8A, %struct.U8A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i64, i64* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* [[FORMAT_U8]], i32 0, i32 0), i64 [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* [[FIELD_U8]], i32 0, i32 0), i64 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U8]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit9(void) {
   struct U9A {
     char a;
   };
 
   struct U9A a = {
       .a = 'a',
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U9]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U9A, %struct.U9A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* [[FIELD_U9]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U9A, %struct.U9A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i8, i8* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* [[FORMAT_U9]], i32 0, i32 0), i8 [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* [[FIELD_U9]], i32 0, i32 0), i8 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U9]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit10(void) {
   struct U10A {
     char *a;
   };
 
   struct U10A a = {
       .a = "LSE",
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U10]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U10A, %struct.U10A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* [[FIELD_U10]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U10A, %struct.U10A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i8*, i8** [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* [[FORMAT_U10]], i32 0, i32 0), i8* [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[FIELD_U10]], i32 0, i32 0), i8* [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U10]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit11(void) {
   struct U11A {
     void *a;
   };
 
   struct U11A a = {
       .a = (void *)0x12345678,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U11]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U11A, %struct.U11A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* [[FIELD_U11]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U11A, %struct.U11A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i8*, i8** [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* [[FORMAT_U11]], i32 0, i32 0), i8* [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[FIELD_U11]], i32 0, i32 0), i8* [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U11]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit12(void) {
   struct U12A {
     const char *a;
   };
 
   struct U12A a = {
       .a = "LSE",
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U12]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U12A, %struct.U12A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* [[FIELD_U12]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U12A, %struct.U12A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i8*, i8** [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* [[FORMAT_U12]], i32 0, i32 0), i8* [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* [[FIELD_U12]], i32 0, i32 0), i8* [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U12]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit13(void) {
   typedef char *charstar;
   struct U13A {
     const charstar a;
   };
 
   struct U13A a = {
       .a = "LSE",
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U13]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U13A, %struct.U13A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* [[FIELD_U13]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U13A, %struct.U13A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i8*, i8** [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* [[FORMAT_U13]], i32 0, i32 0), i8* [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* [[FIELD_U13]], i32 0, i32 0), i8* [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U13]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit14(void) {
   struct U14A {
     double a;
   };
 
   struct U14A a = {
       .a = 1.123456,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U14]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U14A, %struct.U14A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* [[FIELD_U14]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U14A, %struct.U14A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load double, double* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* [[FORMAT_U14]], i32 0, i32 0), double [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[FIELD_U14]], i32 0, i32 0), double [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U14]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit15(void) {
   struct U15A {
     int a[3];
   };
 
   struct U15A a = {
       .a = {1, 2, 3},
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U15]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U15A, %struct.U15A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* [[FIELD_U15]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U15A, %struct.U15A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load [3 x i32], [3 x i32]* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* [[FORMAT_U15]], i32 0, i32 0), [3 x i32] [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[FIELD_U15]], i32 0, i32 0), [3 x i32] [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U15]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit16(void) {
   struct U16A {
     uint8_t a;
   };
 
   struct U16A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U16]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U16A, %struct.U16A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* [[FIELD_U16]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U16A, %struct.U16A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i8, i8* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* [[FORMAT_U16]], i32 0, i32 0), i8 [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* [[FIELD_U16]], i32 0, i32 0), i8 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U16]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit17(void) {
   struct U17A {
     int8_t a;
   };
 
   struct U17A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U17]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U17A, %struct.U17A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* [[FIELD_U17]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U17A, %struct.U17A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i8, i8* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* [[FORMAT_U17]], i32 0, i32 0), i8 [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* [[FIELD_U17]], i32 0, i32 0), i8 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U17]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit18(void) {
   struct U18A {
     long double a;
   };
 
   struct U18A a = {
       .a = 1.123456,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U18]], i32 0, i32 0))
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.U18A, %struct.U18A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* [[FIELD_U18]], i32 0, i32 0))
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U18A, %struct.U18A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load x86_fp80, x86_fp80* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* [[FORMAT_U18]], i32 0, i32 0), x86_fp80 [[LOAD1]])
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* [[FIELD_U18]], i32 0, i32 0), x86_fp80 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U18]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void test1(void) {
   struct T1A {
     int a;
     char *b;
   };
 
   struct T1A a = {
       .a = 12,
       .b = "LSE",
   };
 
   // CHECK: call i32 (i8*, ...) @printf(
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.T1A, %struct.T1A* %a, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[RES1:%[a-z0-9]+]] = getelementptr inbounds %struct.T1A, %struct.T1A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i32, i32* [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf({{.*}}, i32 [[LOAD1]])
-  // CHECK: [[RES2:%[0-9]+]] = getelementptr inbounds %struct.T1A, %struct.T1A* %a, i32 0, i32 1
-  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[RES2:%[a-z0-9]+]] = getelementptr inbounds %struct.T1A, %struct.T1A* %a, i32 0, i32 1
   // CHECK: [[LOAD2:%[0-9]+]] = load i8*, i8** [[RES2]],
   // CHECK: call i32 (i8*, ...) @printf({{.*}}, i8* [[LOAD2]])
   // CHECK: call i32 (i8*, ...) @printf(
   __builtin_dump_struct(&a, &printf);
 }
 
 void test2(void) {
   struct T2A {
     int a;
   };
 
   struct T2B {
     int b;
     struct T2A a;
   };
 
   struct T2B b = {
       .b = 24,
       .a = {
           .a = 12,
       }
   };
 
   // CHECK: call i32 (i8*, ...) @printf(
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.T2B, %struct.T2B* %b, i32 0, i32 0
-  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[RES1:%[a-z0-9]+]] = getelementptr inbounds %struct.T2B, %struct.T2B* %b, i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i32, i32* [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf({{.*}}, i32 [[LOAD1]])
-  // CHECK: [[NESTED_STRUCT:%[0-9]+]] = getelementptr inbounds %struct.T2B, %struct.T2B* %b, i32 0, i32 1
-  // CHECK: call i32 (i8*, ...) @printf(
-  // CHECK: [[RES2:%[0-9]+]] = getelementptr inbounds %struct.T2A, %struct.T2A* [[NESTED_STRUCT]], i32 0, i32 0
+  // CHECK: [[NESTED_STRUCT:%[a-z0-9]+]] = getelementptr inbounds %struct.T2B, %struct.T2B* %b, i32 0, i32 1
   // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[RES2:%[a-z0-9]+]] = getelementptr inbounds %struct.T2A, %struct.T2A* [[NESTED_STRUCT]], i32 0, i32 0
   // CHECK: [[LOAD2:%[0-9]+]] = load i32, i32* [[RES2]],
   // CHECK: call i32 (i8*, ...) @printf({{.*}}, i32 [[LOAD2]])
   // CHECK: call i32 (i8*, ...) @printf(
   __builtin_dump_struct(&b, &printf);
 }
 
 void test3(void) {
   struct T3A {
     union {
       int a;
       char b[4];
     };
   };
 
   struct T3A a = {
       .a = 42,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.T3A, %struct.T3A* %a, i32 0, i32 0
+  // CHECK: [[RES1:%[a-z0-9]+]] = getelementptr inbounds %struct.T3A, %struct.T3A* %a, i32 0, i32 0
   // CHECK: call i32 (i8*, ...) @printf(
-  // CHECK: [[BC1:%[0-9]+]] = bitcast %union.anon* [[RES1]] to i32*
+  // CHECK: [[BC1:%[a-z0-9]+]] = bitcast %union.anon* [[RES1]] to i32*
   // CHECK: [[LOAD1:%[0-9]+]] = load i32, i32* [[BC1]],
   // CHECK: call i32 (i8*, ...) @printf({{.*}}, i32 [[LOAD1]])
-  // CHECK: [[BC2:%[0-9]+]] = bitcast %union.anon* [[RES1]] to [4 x i8]*
+  // CHECK: [[BC2:%[a-z0-9]+]] = bitcast %union.anon* [[RES1]] to [4 x i8]*
   // CHECK: [[LOAD2:%[0-9]+]] = load [4 x i8], [4 x i8]* [[BC2]],
   // CHECK: call i32 (i8*, ...) @printf({{.*}}, [4 x i8] [[LOAD2]])
   // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: call i32 (i8*, ...) @printf(
   __builtin_dump_struct(&a, &printf);
 }
 
 void test4(void) {
   struct T4A {
     union {
       struct {
         void *a;
       };
       struct {
         unsigned long b;
       };
     };
   };
 
   struct T4A a = {
       .a = (void *)0x12345678,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(
-  // CHECK: [[RES1:%[0-9]+]] = getelementptr inbounds %struct.T4A, %struct.T4A* %a, i32 0, i32 0
+  // CHECK: [[RES1:%[a-z0-9]+]] = getelementptr inbounds %struct.T4A, %struct.T4A* %a, i32 0, i32 0
+  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[BC1:%[a-z0-9]+]] = bitcast %union.anon.0* [[RES1]] to %struct.anon*
   // CHECK: call i32 (i8*, ...) @printf(
-  // CHECK: [[BC1:%[0-9]+]] = bitcast %union.anon.0* [[RES1]] to %struct.anon*
-  // CHECK: [[RES2:%[0-9]+]] = getelementptr inbounds %struct.anon, %struct.anon* [[BC1]], i32 0, i32 0
+  // CHECK: [[RES2:%[a-z0-9]+]] = getelementptr inbounds %struct.anon, %struct.anon* [[BC1]], i32 0, i32 0
   // CHECK: [[LOAD1:%[0-9]+]] = load i8*, i8** [[RES2]],
   // CHECK: call i32 (i8*, ...) @printf({{.*}}, i8* [[LOAD1]])
-
-  // CHECK: [[BC2:%[0-9]+]] = bitcast %union.anon.0* [[RES1]] to %struct.anon.1*
-  // CHECK: [[RES3:%[0-9]+]] = getelementptr inbounds %struct.anon.1, %struct.anon.1* [[BC2]], i32 0, i32 0
+  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[BC2:%[a-z0-9]+]] = bitcast %union.anon.0* [[RES1]] to %struct.anon.1*
+  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[RES3:%[a-z0-9]+]] = getelementptr inbounds %struct.anon.1, %struct.anon.1* [[BC2]], i32 0, i32 0
   // CHECK: [[LOAD2:%[0-9]+]] = load i64, i64* [[RES3]],
   // CHECK: call i32 (i8*, ...) @printf({{.*}}, i64 [[LOAD2]])
   // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: call i32 (i8*, ...) @printf(
+  __builtin_dump_struct(&a, &printf);
+}
+
+void test5(void) {
+  struct T5A {
+    unsigned a : 1;
+  };
+
+  struct T5A a = {
+    .a = 0,
+  };
+
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* {{.*}}, i32 0, i32 0))
+  // CHECK: [[BC1:%[0-9a-z.]+]] = bitcast %struct.T5A* %a to i8*
+  // CHECK: [[LOAD1:%[0-9a-z.]+]] = load i8, i8* [[BC1]],
+  // CHECK: [[CLEAR1:%[0-9a-z.]+]] = and i8 [[LOAD1]], 1
+  // CHECK: [[CAST1:%[0-9a-z.]+]] = zext i8 [[CLEAR1]] to i32
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* {{.*}}, i32 0, i32 0), i32 [[CAST1]])
+  // CHECK: call i32 (i8*, ...) @printf(
+  __builtin_dump_struct(&a, &printf);
+}
+
+void test6(void) {
+  struct T6A {
+    unsigned a : 1;
+    unsigned b : 1;
+    unsigned c : 1;
+  };
+
+  struct T6A a = {
+    .a = 1,
+    .b = 0,
+    .c = 1,
+  };
+
+  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[BC1:%[0-9a-z.]+]] = bitcast %struct.T6A* %a to i8*
+  // CHECK: [[LOAD1:%[0-9a-z.]+]] = load i8, i8* [[BC1]],
+  // CHECK: [[CLEAR1:%[0-9a-z.]+]] = and i8 [[LOAD1]], 1
+  // CHECK: [[CAST1:%[0-9a-z.]+]] = zext i8 [[CLEAR1]] to i32
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* {{.*}}, i32 0, i32 0), i32 [[CAST1]])
+  // CHECK: [[BC2:%[0-9a-z.]+]] = bitcast %struct.T6A* %a to i8*
+  // CHECK: [[LOAD2:%[0-9a-z.]+]] = load i8, i8* [[BC2]], align 4
+  // CHECK: [[LSHR2:%[0-9a-z.]+]] = lshr i8 [[LOAD2]], 1
+  // CHECK: [[CLEAR2:%[0-9a-z.]+]] = and i8 [[LSHR2]], 1
+  // CHECK: [[CAST2:%[0-9a-z.]+]] = zext i8 [[CLEAR2]] to i32
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* {{.*}}, i32 0, i32 0), i32 [[CAST2]])
+  // CHECK: [[BC3:%[0-9a-z.]+]] = bitcast %struct.T6A* %a to i8*
+  // CHECK: [[LOAD3:%[0-9a-z.]+]] = load i8, i8* [[BC3]], align 4
+  // CHECK: [[LSHR3:%[0-9a-z.]+]] = lshr i8 [[LOAD3]], 2
+  // CHECK: [[CLEAR3:%[0-9a-z.]+]] = and i8 [[LSHR3]], 1
+  // CHECK: [[CAST3:%[0-9a-z.]+]] = zext i8 [[CLEAR3]] to i32
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* {{.*}}, i32 0, i32 0), i32 [[CAST3]])
+  // CHECK: call i32 (i8*, ...) @printf(
+  __builtin_dump_struct(&a, &printf);
+}
+
+void test7(void) {
+
+  struct T7A {
+    unsigned a : 1;
+  };
+
+  struct T7B {
+    struct T7A a;
+    unsigned b : 1;
+  };
+
+  struct T7B a = {
+    .a = {.a = 0},
+    .b = 1,
+  };
+
+  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.T7B, %struct.T7B* %a, i32 0, i32 0
+  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[BC1:%[−a−zA−Z._0-9]+]] = bitcast %struct.T7A* [[RES1]] to i8*
+  // CHECK: [[LOAD1:%[-a-zA-Z._0-9]+]] = load i8, i8* [[BC1]],
+  // CHECK: [[CLEAR1:%[-a-zA-Z._0-9]+]] = and i8 [[LOAD1]], 1
+  // CHECK: [[CAST1:%[-a-zA-Z._0-9]+]] = zext i8 [[CLEAR1]] to i32
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* {{.*}}, i32 0, i32 0), i32 [[CAST1]])
+  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[RES2:%[-a-zA-Z._0-9]+]] = getelementptr inbounds %struct.T7B, %struct.T7B* %a, i32 0, i32 1
+  // CHECK: [[LOAD2:%[-a-zA-Z._0-9]+]] = load i8, i8* [[RES2]], align 4
+  // CHECK: [[CLEAR2:%[-a-zA-Z._0-9]+]] = and i8 [[LOAD2]], 1
+  // CHECK: [[CAST2:%[-a-zA-Z._0-9]+]] = zext i8 [[CLEAR2]] to i32
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* {{.*}}, i32 0, i32 0), i32 [[CAST2]])
+  // CHECK: call i32 (i8*, ...) @printf(
+   __builtin_dump_struct(&a, &printf);
+}
+
+void test8(void) {
+  struct T8A {
+    unsigned c : 1;
+    unsigned : 3;
+    unsigned : 0;
+    unsigned b;
+  };
+
+  struct T8A a = {
+    .b = 2022,
+  };
+
+  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[BC1:%[−a−zA−Z._0-9]+]] = bitcast %struct.T8A* %a to i8*
+  // CHECK: [[LOAD1:%[-a-zA-Z._0-9]+]] = load i8, i8* [[BC1]],
+  // CHECK: [[CLEAR1:%[-a-zA-Z._0-9]+]] = and i8 [[LOAD1]], 1
+  // CHECK: [[CAST1:%[-a-zA-Z._0-9]+]] = zext i8 [[CLEAR1]] to i32
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* {{.*}}, i32 0, i32 0), i32 [[CAST1]])
+  // CHECK: [[BC2:%[−a−zA−Z._0-9]+]] = bitcast %struct.T8A* %a to i8*
+  // CHECK: [[LOAD2:%[-a-zA-Z._0-9]+]] = load i8, i8* [[BC2]],
+  // CHECK: [[LSHR2:%[0-9a-z.]+]] = lshr i8 [[LOAD2]], 1
+  // CHECK: [[CLEAR2:%[-a-zA-Z._0-9]+]] = and i8 [[LSHR2]], 7
+  // CHECK: [[CAST2:%[-a-zA-Z._0-9]+]] = zext i8 [[CLEAR2]] to i32
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* {{.*}}, i32 0, i32 0), i32 [[CAST2]])
+  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[RES3:%[-a-zA-Z._0-9]+]] = getelementptr inbounds %struct.T8A, %struct.T8A* %a, i32 0, i32 1
+  // CHECK: [[LOAD3:%[-a-zA-Z._0-9]+]] = load i32, i32* [[RES3]],
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* {{.*}}, i32 0, i32 0), i32 [[LOAD3]])
+  // CHECK: call i32 (i8*, ...) @printf(
   __builtin_dump_struct(&a, &printf);
 }