diff mbox series

[net-next,v8,03/10] lib: packing: add pack_fields() and unpack_fields()

Message ID 20241203-packing-pack-fields-and-ice-implementation-v8-3-2ed68edfe583@intel.com (mailing list archive)
State Superseded
Delegated to: Netdev Maintainers
Headers show
Series lib: packing: introduce and use (un)pack_fields | expand

Checks

Context Check Description
netdev/series_format success Posting correctly formatted
netdev/tree_selection success Clearly marked for net-next
netdev/ynl success Generated files up to date; no warnings/errors; no diff in generated;
netdev/fixes_present success Fixes tag not required for -next series
netdev/header_inline success No static functions without inline keyword in header files
netdev/build_32bit success Errors and warnings before: 3 this patch: 3
netdev/build_tools success Errors and warnings before: 0 (+23) this patch: 0 (+23)
netdev/cc_maintainers warning 3 maintainers not CCed: linux-kbuild@vger.kernel.org nathan@kernel.org nicolas@fjasle.eu
netdev/build_clang success Errors and warnings before: 4 this patch: 4
netdev/verify_signedoff success Signed-off-by tag matches author and committer
netdev/deprecated_api success None detected
netdev/check_selftest success No net selftest shell script
netdev/verify_fixes success No Fixes tag
netdev/build_allmodconfig_warn success Errors and warnings before: 308 this patch: 308
netdev/checkpatch fail CHECK: Please don't use multiple blank lines ERROR: Macros with multiple statements should be enclosed in a do - while loop WARNING: line length of 112 exceeds 80 columns WARNING: line length of 117 exceeds 80 columns WARNING: line length of 120 exceeds 80 columns WARNING: line length of 137 exceeds 80 columns WARNING: line length of 81 exceeds 80 columns WARNING: line length of 85 exceeds 80 columns WARNING: line length of 86 exceeds 80 columns WARNING: line length of 87 exceeds 80 columns WARNING: line length of 88 exceeds 80 columns WARNING: line length of 89 exceeds 80 columns WARNING: line length of 90 exceeds 80 columns WARNING: line length of 91 exceeds 80 columns WARNING: line length of 98 exceeds 80 columns
netdev/build_clang_rust success No Rust files in patch. Skipping build
netdev/kdoc success Errors and warnings before: 0 this patch: 0
netdev/source_inline success Was 0 now: 0
netdev/contest success net-next-2024-12-04--15-02 (tests: 760)

Commit Message

Jacob Keller Dec. 3, 2024, 11:53 p.m. UTC 
From: Vladimir Oltean <vladimir.oltean@nxp.com>

This is new API which caters to the following requirements:

- Pack or unpack a large number of fields to/from a buffer with a small
  code footprint. The current alternative is to open-code a large number
  of calls to pack() and unpack(), or to use packing() to reduce that
  number to half. But packing() is not const-correct.

- Use unpacked numbers stored in variables smaller than u64. This
  reduces the rodata footprint of the stored field arrays.

- Perform error checking at compile time, rather than runtime, and return
  void from the API functions. Because the C preprocessor can't generate
  variable length code (loops), this is a bit tricky to do with macros.

  To handle this, implement macros which sanity check the packed field
  definitions based on their size. Finally, a single macro with a chain of
  __builtin_choose_expr() is used to select the appropriate macros. We
  enforce the use of ascending or descending order to avoid O(N^2) scaling
  when checking for overlap. Note that the macros are written with care to
  ensure that the compilers can correctly evaluate the resulting code at
  compile time. In particular, the expressions for the pbuflen and the
  ordering check are passed all the way down via macros. Earlier versions
  attempted to use statement expressions with local variables, but not all
  compilers were able to fully analyze these at compile time, resulting in
  BUILD_BUG_ON failures.

  The overlap macro is passed a condition determining whether the fields
  are expected to be in ascending or descending order based on the relative
  ordering of the first two fields. This allows users to keep the fields in
  whichever order is most natural for their hardware, while still keeping
  the overlap checks scaling to O(N).

  This method also enables calling CHECK_PACKED_FIELDS directly from within
  the pack_fields and unpack_fields macros, ensuring all drivers using this
  API will receive type checking, without needing to remember to call the
  CHECK_PACKED_FIELDS macro themselves.

- Reduced rodata footprint for the storage of the packed field arrays.
  To that end, we have struct packed_field_s (small) and packed_field_m
  (medium). More can be added as needed (unlikely for now). On these
  types, the same generic pack_fields() and unpack_fields() API can be
  used, thanks to the new C11 _Generic() selection feature, which can
  call pack_fields_s() or pack_fields_m(), depending on the type of the
  "fields" array - a simplistic form of polymorphism. It is evaluated at
  compile time which function will actually be called.

Over time, packing() is expected to be completely replaced either with
pack() or with pack_fields().

Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
Co-developed-by: Jacob Keller <jacob.e.keller@intel.com>
Signed-off-by: Jacob Keller <jacob.e.keller@intel.com>
---
 Makefile                          |    4 +
 include/linux/packing.h           | 2855 +++++++++++++++++++++++++++++++++++++
 lib/packing.c                     |  145 ++
 lib/packing_test.c                |   61 +
 scripts/gen_packed_field_checks.c |   38 +
 MAINTAINERS                       |    1 +
 scripts/Makefile                  |    2 +-
 7 files changed, 3105 insertions(+), 1 deletion(-)

Comments

Vladimir Oltean Dec. 4, 2024, 5:12 p.m. UTC | #1 
On Tue, Dec 03, 2024 at 03:53:49PM -0800, Jacob Keller wrote:
> +#define CHECK_PACKED_FIELD(field) ({ \
> +	typeof(field) __f = (field); \
> +	BUILD_BUG_ON(__f.startbit < __f.endbit); \
> +	BUILD_BUG_ON(__f.startbit - __f.endbit >= BITS_PER_BYTE * __f.size); \
> +	BUILD_BUG_ON(__f.size != 1 && __f.size != 2 && \
> +		     __f.size != 4 && __f.size != 8); \
> +})
> +
> +
> +#define CHECK_PACKED_FIELD_OVERLAP(ascending, field1, field2) ({ \
> +	typeof(field1) _f1 = (field1); typeof(field2) _f2 = (field2); \
> +	const bool _a = (ascending); \
> +	BUILD_BUG_ON(_a && _f1.startbit >= _f2.startbit); \
> +	BUILD_BUG_ON(!_a && _f1.startbit <= _f2.startbit); \
> +	BUILD_BUG_ON(max(_f1.endbit, _f2.endbit) <= \
> +		     min(_f1.startbit, _f2.startbit)); \
> +})
> +
> +#define CHECK_PACKED_FIELDS_SIZE(fields, pbuflen) ({ \
> +	typeof(&(fields)[0]) _f = (fields); \
> +	typeof(pbuflen) _len = (pbuflen); \
> +	const size_t num_fields = ARRAY_SIZE(fields); \
> +	BUILD_BUG_ON(!__builtin_constant_p(_len)); \
> +	BUILD_BUG_ON(_f[0].startbit >= BITS_PER_BYTE * _len); \

Please add a comment here stating that we check both the first and last
element to cover the ascending as well as descending ordering scenarios.
It took me a while to realize this, I thought the _f[0] check was unnecessary.

> +	BUILD_BUG_ON(_f[num_fields - 1].startbit >= BITS_PER_BYTE * _len); \
> +})
> +
>  #define QUIRK_MSB_ON_THE_RIGHT	BIT(0)
>  #define QUIRK_LITTLE_ENDIAN	BIT(1)
>  #define QUIRK_LSW32_IS_FIRST	BIT(2)

I spent some time today to play around with this version, and it seems
to work, but I took some liberty and made the following changes:

- Tail-call CHECK_PACKED_FIELD_OVERLAP() from CHECK_PACKED_FIELD(). This
  reduces the size of the generated code from 2753 lines to 1478 lines,
  which already brings it a little bit more into the realm of "tolerable" IMO.

- Remove the BUILD_BUG_ON(ARRAY_SIZE(fields) == N), since I think
  that's just wasteful (in terms of space and compiler CPU cycles) and
  ultra-defensive, when the auto-generated __builtin_choose_expr() is
  the only caller. It was justified when the consumer had to explicitly
  select the right checking macro.

- Add some prettier error messages. Compare (for an error injected by me):

../drivers/net/ethernet/intel/ice/ice_common.c:1419:2: error: call to '__compiletime_assert_3302' declared with 'error' attribute: BUILD_BUG_ON failed: max(_f1.endbit, _f2.endbit) <= min(_f1.startbit, _f2.startbit)
        pack_fields(buf, sizeof(*buf), ctx, ice_rlan_ctx_fields,
        ^

with:


../drivers/net/ethernet/intel/ice/ice_common.c:1419:2: error: call to '__compiletime_assert_3414' declared with 'error' attribute: ice_rlan_ctx_fields field 3 overlaps with previous field
        pack_fields(buf, sizeof(*buf), ctx, ice_rlan_ctx_fields,
        ^


That incremental improvement is below, if you'd be interested in including it
(the auto-generated code is not part of the diff):

diff --git a/include/linux/packing.h b/include/linux/packing.h
index c4fc76ae64a5..1c89a5129b06 100644
--- a/include/linux/packing.h
+++ b/include/linux/packing.h
@@ -36,22 +36,38 @@ struct packed_field_m {
 	sizeof_field(struct_name, struct_field), \
 }
 
-#define CHECK_PACKED_FIELD(field) ({ \
-	typeof(field) __f = (field); \
-	BUILD_BUG_ON(__f.startbit < __f.endbit); \
-	BUILD_BUG_ON(__f.startbit - __f.endbit >= BITS_PER_BYTE * __f.size); \
-	BUILD_BUG_ON(__f.size != 1 && __f.size != 2 && \
-		     __f.size != 4 && __f.size != 8); \
+#define CHECK_PACKED_FIELD_OVERLAP(fields, index1, index2) ({ \
+	typeof(&(fields)[0]) __f = (fields); \
+	typeof(__f[0]) _f1 = __f[index1]; typeof(__f[0]) _f2 = __f[index2]; \
+	const bool _ascending = __f[0].startbit < __f[1].startbit; \
+	BUILD_BUG_ON_MSG(_ascending && _f1.startbit >= _f2.startbit, \
+			 __stringify(fields) " field " __stringify(index2) \
+			 " breaks ascending order"); \
+	BUILD_BUG_ON_MSG(!_ascending && _f1.startbit <= _f2.startbit, \
+			 __stringify(fields) " field " __stringify(index2) \
+			 " breaks descending order"); \
+	BUILD_BUG_ON_MSG(max(_f1.endbit, _f2.endbit) <= \
+			 min(_f1.startbit, _f2.startbit), \
+			 __stringify(fields) " field " __stringify(index2) \
+			 " overlaps with previous field"); \
 })
 
-
-#define CHECK_PACKED_FIELD_OVERLAP(ascending, field1, field2) ({ \
-	typeof(field1) _f1 = (field1); typeof(field2) _f2 = (field2); \
-	const bool _a = (ascending); \
-	BUILD_BUG_ON(_a && _f1.startbit >= _f2.startbit); \
-	BUILD_BUG_ON(!_a && _f1.startbit <= _f2.startbit); \
-	BUILD_BUG_ON(max(_f1.endbit, _f2.endbit) <= \
-		     min(_f1.startbit, _f2.startbit)); \
+#define CHECK_PACKED_FIELD(fields, index) ({ \
+	typeof(&(fields)[0]) _f = (fields); \
+	typeof(_f[0]) __f = _f[index]; \
+	BUILD_BUG_ON_MSG(__f.startbit < __f.endbit, \
+			 __stringify(fields) " field " __stringify(index) \
+			 " start bit must not be smaller than end bit"); \
+	BUILD_BUG_ON_MSG(__f.size != 1 && __f.size != 2 && \
+			 __f.size != 4 && __f.size != 8, \
+			 __stringify(fields) " field " __stringify(index) \
+			" has unsupported unpacked storage size"); \
+	BUILD_BUG_ON_MSG(__f.startbit - __f.endbit >= BITS_PER_BYTE * __f.size, \
+			 __stringify(fields) " field " __stringify(index) \
+			 " exceeds unpacked storage size"); \
+	__builtin_choose_expr(index != 0, \
+			      CHECK_PACKED_FIELD_OVERLAP(fields, index - 1, index), \
+			      1); \
 })
 
 #define CHECK_PACKED_FIELDS_SIZE(fields, pbuflen) ({ \
diff --git a/scripts/gen_packed_field_checks.c b/scripts/gen_packed_field_checks.c
index 09a21afd640b..fabbb741c9a8 100644
--- a/scripts/gen_packed_field_checks.c
+++ b/scripts/gen_packed_field_checks.c
@@ -9,15 +9,9 @@ int main(int argc, char **argv)
 {
 	for (int i = 1; i <= MAX_PACKED_FIELD_SIZE; i++) {
 		printf("#define CHECK_PACKED_FIELDS_%d(fields) ({ \\\n", i);
-		printf("\ttypeof(&(fields)[0]) _f = (fields); \\\n");
-		printf("\tBUILD_BUG_ON(ARRAY_SIZE(fields) != %d); \\\n", i);
 
 		for (int j = 0; j < i; j++)
-			printf("\tCHECK_PACKED_FIELD(_f[%d]); \\\n", j);
-
-		for (int j = 1; j < i; j++)
-			printf("\tCHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[%d], _f[%d]); \\\n",
-			       j - 1, j);
+			printf("\tCHECK_PACKED_FIELD(fields, %d); \\\n", j);
 
 		printf("})\n\n");
 	}

And there's one more thing I tried, which mostly worked. That was to
express CHECK_PACKED_FIELDS_N in terms of CHECK_PACKED_FIELDS_N-1.
This further reduced the auto-generated code size from 1478 lines to 302
lines, which I think is appealing.

diff --git a/scripts/gen_packed_field_checks.c b/scripts/gen_packed_field_checks.c
index fabbb741c9a8..bac85c04ef20 100644
--- a/scripts/gen_packed_field_checks.c
+++ b/scripts/gen_packed_field_checks.c
@@ -10,9 +10,10 @@ int main(int argc, char **argv)
 	for (int i = 1; i <= MAX_PACKED_FIELD_SIZE; i++) {
 		printf("#define CHECK_PACKED_FIELDS_%d(fields) ({ \\\n", i);
 
-		for (int j = 0; j < i; j++)
-			printf("\tCHECK_PACKED_FIELD(fields, %d); \\\n", j);
+		if (i != 1)
+			printf("\tCHECK_PACKED_FIELDS_%d(fields); \\\n", i - 1);
 
+		printf("\tCHECK_PACKED_FIELD(fields, %d); \\\n", i);
 		printf("})\n\n");
 	}
 

The problem is that, for some reason, it introduces this sparse warning:

../lib/packing_test.c:436:9: warning: invalid access past the end of 'test_fields' (24 24)
../lib/packing_test.c:448:9: warning: invalid access past the end of 'test_fields' (24 24)

Nobody accesses past element 6 (ARRAY_SIZE) of test_fields[]. I ran the
KUnit with kasan and I saw no warning. The strace warning comes from
check_access() in flow.c, but I don't have any energy left today to go
further into this.

I'm suspecting either a strace bug/false positive, or some sort of
variable name aliasing issue which I haven't identified yet.
Jacob Keller Dec. 4, 2024, 6:47 p.m. UTC | #2 
On 12/4/2024 9:12 AM, Vladimir Oltean wrote:
> On Tue, Dec 03, 2024 at 03:53:49PM -0800, Jacob Keller wrote:
>> +#define CHECK_PACKED_FIELD(field) ({ \
>> +	typeof(field) __f = (field); \
>> +	BUILD_BUG_ON(__f.startbit < __f.endbit); \
>> +	BUILD_BUG_ON(__f.startbit - __f.endbit >= BITS_PER_BYTE * __f.size); \
>> +	BUILD_BUG_ON(__f.size != 1 && __f.size != 2 && \
>> +		     __f.size != 4 && __f.size != 8); \
>> +})
>> +
>> +
>> +#define CHECK_PACKED_FIELD_OVERLAP(ascending, field1, field2) ({ \
>> +	typeof(field1) _f1 = (field1); typeof(field2) _f2 = (field2); \
>> +	const bool _a = (ascending); \
>> +	BUILD_BUG_ON(_a && _f1.startbit >= _f2.startbit); \
>> +	BUILD_BUG_ON(!_a && _f1.startbit <= _f2.startbit); \
>> +	BUILD_BUG_ON(max(_f1.endbit, _f2.endbit) <= \
>> +		     min(_f1.startbit, _f2.startbit)); \
>> +})
>> +
>> +#define CHECK_PACKED_FIELDS_SIZE(fields, pbuflen) ({ \
>> +	typeof(&(fields)[0]) _f = (fields); \
>> +	typeof(pbuflen) _len = (pbuflen); \
>> +	const size_t num_fields = ARRAY_SIZE(fields); \
>> +	BUILD_BUG_ON(!__builtin_constant_p(_len)); \
>> +	BUILD_BUG_ON(_f[0].startbit >= BITS_PER_BYTE * _len); \
> 
> Please add a comment here stating that we check both the first and last
> element to cover the ascending as well as descending ordering scenarios.
> It took me a while to realize this, I thought the _f[0] check was unnecessary.
> 

Sure. I will also try to adopt the BUILD_BUG_ON_MSG style you have used
for the overlap to help with better error messages.

>> +	BUILD_BUG_ON(_f[num_fields - 1].startbit >= BITS_PER_BYTE * _len); \
>> +})
>> +
>>  #define QUIRK_MSB_ON_THE_RIGHT	BIT(0)
>>  #define QUIRK_LITTLE_ENDIAN	BIT(1)
>>  #define QUIRK_LSW32_IS_FIRST	BIT(2)
> 
> I spent some time today to play around with this version, and it seems
> to work, but I took some liberty and made the following changes:
> 
> - Tail-call CHECK_PACKED_FIELD_OVERLAP() from CHECK_PACKED_FIELD(). This
>   reduces the size of the generated code from 2753 lines to 1478 lines,
>   which already brings it a little bit more into the realm of "tolerable" IMO.
> 

Nice thats a good improvement.

> - Remove the BUILD_BUG_ON(ARRAY_SIZE(fields) == N), since I think
>   that's just wasteful (in terms of space and compiler CPU cycles) and
>   ultra-defensive, when the auto-generated __builtin_choose_expr() is
>   the only caller. It was justified when the consumer had to explicitly
>   select the right checking macro.
> 

Sure, we can drop these. I had kept them because I felt it was
worthwhile in case someone does call them manually, but I don't think we
should encourage that behavior, and it is otherwise completely wasted
cycles. I guess its defense against screwing up the builtin_choose_expr,
but that is auto-generated now too.

> - Add some prettier error messages. Compare (for an error injected by me):
> 
> ../drivers/net/ethernet/intel/ice/ice_common.c:1419:2: error: call to '__compiletime_assert_3302' declared with 'error' attribute: BUILD_BUG_ON failed: max(_f1.endbit, _f2.endbit) <= min(_f1.startbit, _f2.startbit)
>         pack_fields(buf, sizeof(*buf), ctx, ice_rlan_ctx_fields,
>         ^
> 
> with:
> 
> 
> ../drivers/net/ethernet/intel/ice/ice_common.c:1419:2: error: call to '__compiletime_assert_3414' declared with 'error' attribute: ice_rlan_ctx_fields field 3 overlaps with previous field
>         pack_fields(buf, sizeof(*buf), ctx, ice_rlan_ctx_fields,
>         ^
> 

That is much nicer, thanks.

> 
> That incremental improvement is below, if you'd be interested in including it
> (the auto-generated code is not part of the diff):
> 
> diff --git a/include/linux/packing.h b/include/linux/packing.h
> index c4fc76ae64a5..1c89a5129b06 100644
> --- a/include/linux/packing.h
> +++ b/include/linux/packing.h
> @@ -36,22 +36,38 @@ struct packed_field_m {
>  	sizeof_field(struct_name, struct_field), \
>  }
>  
> -#define CHECK_PACKED_FIELD(field) ({ \
> -	typeof(field) __f = (field); \
> -	BUILD_BUG_ON(__f.startbit < __f.endbit); \
> -	BUILD_BUG_ON(__f.startbit - __f.endbit >= BITS_PER_BYTE * __f.size); \
> -	BUILD_BUG_ON(__f.size != 1 && __f.size != 2 && \
> -		     __f.size != 4 && __f.size != 8); \
> +#define CHECK_PACKED_FIELD_OVERLAP(fields, index1, index2) ({ \
> +	typeof(&(fields)[0]) __f = (fields); \
> +	typeof(__f[0]) _f1 = __f[index1]; typeof(__f[0]) _f2 = __f[index2]; \
> +	const bool _ascending = __f[0].startbit < __f[1].startbit; \
> +	BUILD_BUG_ON_MSG(_ascending && _f1.startbit >= _f2.startbit, \
> +			 __stringify(fields) " field " __stringify(index2) \
> +			 " breaks ascending order"); \
> +	BUILD_BUG_ON_MSG(!_ascending && _f1.startbit <= _f2.startbit, \
> +			 __stringify(fields) " field " __stringify(index2) \
> +			 " breaks descending order"); \
> +	BUILD_BUG_ON_MSG(max(_f1.endbit, _f2.endbit) <= \
> +			 min(_f1.startbit, _f2.startbit), \
> +			 __stringify(fields) " field " __stringify(index2) \
> +			 " overlaps with previous field"); \
>  })
>  
> -
> -#define CHECK_PACKED_FIELD_OVERLAP(ascending, field1, field2) ({ \
> -	typeof(field1) _f1 = (field1); typeof(field2) _f2 = (field2); \
> -	const bool _a = (ascending); \
> -	BUILD_BUG_ON(_a && _f1.startbit >= _f2.startbit); \
> -	BUILD_BUG_ON(!_a && _f1.startbit <= _f2.startbit); \
> -	BUILD_BUG_ON(max(_f1.endbit, _f2.endbit) <= \
> -		     min(_f1.startbit, _f2.startbit)); \
> +#define CHECK_PACKED_FIELD(fields, index) ({ \
> +	typeof(&(fields)[0]) _f = (fields); \
> +	typeof(_f[0]) __f = _f[index]; \
> +	BUILD_BUG_ON_MSG(__f.startbit < __f.endbit, \
> +			 __stringify(fields) " field " __stringify(index) \
> +			 " start bit must not be smaller than end bit"); \
> +	BUILD_BUG_ON_MSG(__f.size != 1 && __f.size != 2 && \
> +			 __f.size != 4 && __f.size != 8, \
> +			 __stringify(fields) " field " __stringify(index) \
> +			" has unsupported unpacked storage size"); \
> +	BUILD_BUG_ON_MSG(__f.startbit - __f.endbit >= BITS_PER_BYTE * __f.size, \
> +			 __stringify(fields) " field " __stringify(index) \
> +			 " exceeds unpacked storage size"); \
> +	__builtin_choose_expr(index != 0, \
> +			      CHECK_PACKED_FIELD_OVERLAP(fields, index - 1, index), \
> +			      1); \
>  })
>  
>  #define CHECK_PACKED_FIELDS_SIZE(fields, pbuflen) ({ \
> diff --git a/scripts/gen_packed_field_checks.c b/scripts/gen_packed_field_checks.c
> index 09a21afd640b..fabbb741c9a8 100644
> --- a/scripts/gen_packed_field_checks.c
> +++ b/scripts/gen_packed_field_checks.c
> @@ -9,15 +9,9 @@ int main(int argc, char **argv)
>  {
>  	for (int i = 1; i <= MAX_PACKED_FIELD_SIZE; i++) {
>  		printf("#define CHECK_PACKED_FIELDS_%d(fields) ({ \\\n", i);
> -		printf("\ttypeof(&(fields)[0]) _f = (fields); \\\n");
> -		printf("\tBUILD_BUG_ON(ARRAY_SIZE(fields) != %d); \\\n", i);
>  
>  		for (int j = 0; j < i; j++)
> -			printf("\tCHECK_PACKED_FIELD(_f[%d]); \\\n", j);
> -
> -		for (int j = 1; j < i; j++)
> -			printf("\tCHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[%d], _f[%d]); \\\n",
> -			       j - 1, j);
> +			printf("\tCHECK_PACKED_FIELD(fields, %d); \\\n", j);
>  
>  		printf("})\n\n");
>  	}
> 
> And there's one more thing I tried, which mostly worked. That was to
> express CHECK_PACKED_FIELDS_N in terms of CHECK_PACKED_FIELDS_N-1.
> This further reduced the auto-generated code size from 1478 lines to 302
> lines, which I think is appealing.
> 
> diff --git a/scripts/gen_packed_field_checks.c b/scripts/gen_packed_field_checks.c
> index fabbb741c9a8..bac85c04ef20 100644
> --- a/scripts/gen_packed_field_checks.c
> +++ b/scripts/gen_packed_field_checks.c
> @@ -10,9 +10,10 @@ int main(int argc, char **argv)
>  	for (int i = 1; i <= MAX_PACKED_FIELD_SIZE; i++) {
>  		printf("#define CHECK_PACKED_FIELDS_%d(fields) ({ \\\n", i);
>  
> -		for (int j = 0; j < i; j++)
> -			printf("\tCHECK_PACKED_FIELD(fields, %d); \\\n", j);
> +		if (i != 1)
> +			printf("\tCHECK_PACKED_FIELDS_%d(fields); \\\n", i - 1);
>  
> +		printf("\tCHECK_PACKED_FIELD(fields, %d); \\\n", i);
>  		printf("})\n\n");
>  	}
>  
> 
> The problem is that, for some reason, it introduces this sparse warning:
> 
> ../lib/packing_test.c:436:9: warning: invalid access past the end of 'test_fields' (24 24)
> ../lib/packing_test.c:448:9: warning: invalid access past the end of 'test_fields' (24 24)
> 

I'll take a look and see if I can spot it.

> Nobody accesses past element 6 (ARRAY_SIZE) of test_fields[]. I ran the
> KUnit with kasan and I saw no warning. The strace warning comes from
> check_access() in flow.c, but I don't have any energy left today to go
> further into this.
> 
> I'm suspecting either a strace bug/false positive, or some sort of
> variable name aliasing issue which I haven't identified yet.

I had some issues with various attempts I made at the compiler checks
because different compilers would not always track constants.
Jacob Keller Dec. 4, 2024, 11:24 p.m. UTC | #3 
On 12/4/2024 9:12 AM, Vladimir Oltean wrote:
> And there's one more thing I tried, which mostly worked. That was to
> express CHECK_PACKED_FIELDS_N in terms of CHECK_PACKED_FIELDS_N-1.
> This further reduced the auto-generated code size from 1478 lines to 302
> lines, which I think is appealing.
> 

I figured it out! There are two key issues involved:

> diff --git a/scripts/gen_packed_field_checks.c b/scripts/gen_packed_field_checks.c
> index fabbb741c9a8..bac85c04ef20 100644
> --- a/scripts/gen_packed_field_checks.c
> +++ b/scripts/gen_packed_field_checks.c
> @@ -10,9 +10,10 @@ int main(int argc, char **argv)
>  	for (int i = 1; i <= MAX_PACKED_FIELD_SIZE; i++) {
>  		printf("#define CHECK_PACKED_FIELDS_%d(fields) ({ \\\n", i);
>  
> -		for (int j = 0; j < i; j++)
> -			printf("\tCHECK_PACKED_FIELD(fields, %d); \\\n", j);
> +		if (i != 1)
> +			printf("\tCHECK_PACKED_FIELDS_%d(fields); \\\n", i - 1);
>  
> +		printf("\tCHECK_PACKED_FIELD(fields, %d); \\\n", i);

This needs to be i - 1, since arrays are 0-indexed, so this code expands
to checking the wrong value.

CHECK_PACKED_FIELDS_1 needs to become

CHECK_PACKED_FIELD(fields, 0)

but this code makes it:

CHECK_PACKED_FIELD(fields, 1)

Thus, all the array definitions are off-by-one, leading to the last one
being out-of-bounds.

>  		printf("})\n\n");
>  	}
>  
> 
> The problem is that, for some reason, it introduces this sparse warning:
> 
> ../lib/packing_test.c:436:9: warning: invalid access past the end of 'test_fields' (24 24)
> ../lib/packing_test.c:448:9: warning: invalid access past the end of 'test_fields' (24 24)
> 
> Nobody accesses past element 6 (ARRAY_SIZE) of test_fields[]. I ran the

The array size is 6, but we try to access element 6 which is one past
the array... good old off-by-one error :)

There is one further complication which is that the nested statement
expressions ({ ... }) for each CHECK_PACKED_FIELD_N eventually make GCC
confused, as it doesn't seem to keep track of the types very well.

I fixed that by changing the individual CHECK_PACKED_FIELD_N to be
non-statement expressions, and then wrapping their calls in the
builtin_choose_expr() with ({ ... }), which prevents us from creating
too many expression layers for GCC. It actually results in identical
code being evaluated as with the old version but now with a constant
scaling of the text size: 2 lines per additional check. Of course the
complexity scales linearly, but that means our text size no longer
scales with O(n*log(n)) but just as O(N).

Its fantastic improvement, thanks for the suggestion. I'll have v9 out
with these improvements soon.
Przemek Kitszel Dec. 4, 2024, 11:43 p.m. UTC | #4 
On 12/4/24 18:12, Vladimir Oltean wrote:
> On Tue, Dec 03, 2024 at 03:53:49PM -0800, Jacob Keller wrote:

Amazing stuff :), I really like the fact that you both keep striving for
the best result, even way past the point of cut off of most other ;)

> diff --git a/scripts/gen_packed_field_checks.c b/scripts/gen_packed_field_checks.c
> index 09a21afd640b..fabbb741c9a8 100644
> --- a/scripts/gen_packed_field_checks.c
> +++ b/scripts/gen_packed_field_checks.c
> @@ -9,15 +9,9 @@ int main(int argc, char **argv)
>   {
>   	for (int i = 1; i <= MAX_PACKED_FIELD_SIZE; i++) {
>   		printf("#define CHECK_PACKED_FIELDS_%d(fields) ({ \\\n", i);

[i]
@i in range 1..MAX_PACKED_FIELD_SIZE; inclusive

> -		printf("\ttypeof(&(fields)[0]) _f = (fields); \\\n");
> -		printf("\tBUILD_BUG_ON(ARRAY_SIZE(fields) != %d); \\\n", i);
>   
>   		for (int j = 0; j < i; j++)
> -			printf("\tCHECK_PACKED_FIELD(_f[%d]); \\\n", j);
> -
> -		for (int j = 1; j < i; j++)
> -			printf("\tCHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[%d], _f[%d]); \\\n",
> -			       j - 1, j);
> +			printf("\tCHECK_PACKED_FIELD(fields, %d); \\\n", j);

[j]
@j < @i

>   
>   		printf("})\n\n");
>   	}
> 
> And there's one more thing I tried, which mostly worked. That was to
> express CHECK_PACKED_FIELDS_N in terms of CHECK_PACKED_FIELDS_N-1.
> This further reduced the auto-generated code size from 1478 lines to 302
> lines, which I think is appealing.

a lot :)

> 
> diff --git a/scripts/gen_packed_field_checks.c b/scripts/gen_packed_field_checks.c
> index fabbb741c9a8..bac85c04ef20 100644
> --- a/scripts/gen_packed_field_checks.c
> +++ b/scripts/gen_packed_field_checks.c
> @@ -10,9 +10,10 @@ int main(int argc, char **argv)
>   	for (int i = 1; i <= MAX_PACKED_FIELD_SIZE; i++) {
>   		printf("#define CHECK_PACKED_FIELDS_%d(fields) ({ \\\n", i);

same as [i] above, ok

>   
> -		for (int j = 0; j < i; j++)
> -			printf("\tCHECK_PACKED_FIELD(fields, %d); \\\n", j);
> +		if (i != 1)
> +			printf("\tCHECK_PACKED_FIELDS_%d(fields); \\\n", i - 1);
>   
> +		printf("\tCHECK_PACKED_FIELD(fields, %d); \\\n", i);

prior to the change CHECK_PACKED_FIELD() was called on values smaller
than MAX_PACKED_FIELD_SIZE, compare with [j] above, now you call it also
for the MAX one

>   		printf("})\n\n");
>   	}
>   
> 
> The problem is that, for some reason, it introduces this sparse warning:
> 
> ../lib/packing_test.c:436:9: warning: invalid access past the end of 'test_fields' (24 24)
> ../lib/packing_test.c:448:9: warning: invalid access past the end of 'test_fields' (24 24)
> 

off by one error? see above

> Nobody accesses past element 6 (ARRAY_SIZE) of test_fields[]. I ran the
> KUnit with kasan and I saw no warning. The strace warning comes from
> check_access() in flow.c, but I don't have any energy left today to go
> further into this.
> 
> I'm suspecting either a strace bug/false positive, or some sort of
> variable name aliasing issue which I haven't identified yet.

PS. incremental diff in a single patch is harder to apply, but easier to
review, comment both in a single reply == great idea
Vladimir Oltean Dec. 4, 2024, 11:52 p.m. UTC | #5 
On Wed, Dec 04, 2024 at 03:24:59PM -0800, Jacob Keller wrote:
> On 12/4/2024 9:12 AM, Vladimir Oltean wrote:
> > And there's one more thing I tried, which mostly worked. That was to
> > express CHECK_PACKED_FIELDS_N in terms of CHECK_PACKED_FIELDS_N-1.
> > This further reduced the auto-generated code size from 1478 lines to 302
> > lines, which I think is appealing.
> > 
> 
> I figured it out! There are two key issues involved:
> 
> > diff --git a/scripts/gen_packed_field_checks.c b/scripts/gen_packed_field_checks.c
> > index fabbb741c9a8..bac85c04ef20 100644
> > --- a/scripts/gen_packed_field_checks.c
> > +++ b/scripts/gen_packed_field_checks.c
> > @@ -10,9 +10,10 @@ int main(int argc, char **argv)
> >  	for (int i = 1; i <= MAX_PACKED_FIELD_SIZE; i++) {
> >  		printf("#define CHECK_PACKED_FIELDS_%d(fields) ({ \\\n", i);
> >  
> > -		for (int j = 0; j < i; j++)
> > -			printf("\tCHECK_PACKED_FIELD(fields, %d); \\\n", j);
> > +		if (i != 1)
> > +			printf("\tCHECK_PACKED_FIELDS_%d(fields); \\\n", i - 1);
> >  
> > +		printf("\tCHECK_PACKED_FIELD(fields, %d); \\\n", i);
> 
> This needs to be i - 1, since arrays are 0-indexed, so this code expands
> to checking the wrong value.
> 
> CHECK_PACKED_FIELDS_1 needs to become
> 
> CHECK_PACKED_FIELD(fields, 0)
> 
> but this code makes it:
> 
> CHECK_PACKED_FIELD(fields, 1)
> 
> Thus, all the array definitions are off-by-one, leading to the last one
> being out-of-bounds.

ah :-/

I should have paid more attention, sorry.

> >  		printf("})\n\n");
> >  	}
> >  
> > 
> > The problem is that, for some reason, it introduces this sparse warning:
> > 
> > ../lib/packing_test.c:436:9: warning: invalid access past the end of 'test_fields' (24 24)
> > ../lib/packing_test.c:448:9: warning: invalid access past the end of 'test_fields' (24 24)
> > 
> > Nobody accesses past element 6 (ARRAY_SIZE) of test_fields[]. I ran the
> 
> The array size is 6, but we try to access element 6 which is one past
> the array... good old off-by-one error :)
> 
> There is one further complication which is that the nested statement
> expressions ({ ... }) for each CHECK_PACKED_FIELD_N eventually make GCC
> confused, as it doesn't seem to keep track of the types very well.

I only tested with clang which didn't complain, sorry.

> I fixed that by changing the individual CHECK_PACKED_FIELD_N to be
> non-statement expressions, and then wrapping their calls in the
> builtin_choose_expr() with ({ ... }), which prevents us from creating
> too many expression layers for GCC. It actually results in identical
> code being evaluated as with the old version but now with a constant
> scaling of the text size: 2 lines per additional check.

Yeah, I think that was the logical next development step. By doing this now,
I think you just saved an extra patch iteration, thanks.

> Of course the complexity scales linearly, but that means our text size
> no longer scales with O(n*log(n)) but just as O(N).

Well, technically, the number of lines of code required, in "naive" form,
for overlap checking of arrays up to length N should be N*(N+1)/2, which
"grows quicker" than N*log(N).

But I don't think we can talk about algorithmic complexity here (big O
notation), which stays the same (linear) in both ways of expressing the
same thing.

> Its fantastic improvement, thanks for the suggestion. I'll have v9 out
> with these improvements soon.

And thanks for staying online with this effort for more than an entire
kernel development cycle! Looking forward to v9.
Jacob Keller Dec. 5, 2024, 12:23 a.m. UTC | #6 
On 12/4/2024 3:52 PM, Vladimir Oltean wrote:
> On Wed, Dec 04, 2024 at 03:24:59PM -0800, Jacob Keller wrote:
>> On 12/4/2024 9:12 AM, Vladimir Oltean wrote:
>> Thus, all the array definitions are off-by-one, leading to the last one
>> being out-of-bounds.
> 
> ah :-/
> 
> I should have paid more attention, sorry.
> 

It happens to the best of us. As they say, in programming there are 3
hard problems: naming things, and off-by-one errors.

>>>  		printf("})\n\n");
>>>  	}
>>>  
>>>
>>> The problem is that, for some reason, it introduces this sparse warning:
>>>
>>> ../lib/packing_test.c:436:9: warning: invalid access past the end of 'test_fields' (24 24)
>>> ../lib/packing_test.c:448:9: warning: invalid access past the end of 'test_fields' (24 24)
>>>
>>> Nobody accesses past element 6 (ARRAY_SIZE) of test_fields[]. I ran the
>>
>> The array size is 6, but we try to access element 6 which is one past
>> the array... good old off-by-one error :)
>>
>> There is one further complication which is that the nested statement
>> expressions ({ ... }) for each CHECK_PACKED_FIELD_N eventually make GCC
>> confused, as it doesn't seem to keep track of the types very well.
> 
> I only tested with clang which didn't complain, sorry.
> 

Yea, I have had mixed luck between compilers. Masahiro had suggested a
for-loop which clang handles just fine, but GCC doesn't bother parsing.
I don't like only having the checks on some compilers.

>> I fixed that by changing the individual CHECK_PACKED_FIELD_N to be
>> non-statement expressions, and then wrapping their calls in the
>> builtin_choose_expr() with ({ ... }), which prevents us from creating
>> too many expression layers for GCC. It actually results in identical
>> code being evaluated as with the old version but now with a constant
>> scaling of the text size: 2 lines per additional check.
> 
> Yeah, I think that was the logical next development step. By doing this now,
> I think you just saved an extra patch iteration, thanks.
> 
>> Of course the complexity scales linearly, but that means our text size
>> no longer scales with O(n*log(n)) but just as O(N).
> 
> Well, technically, the number of lines of code required, in "naive" form,
> for overlap checking of arrays up to length N should be N*(N+1)/2, which
> "grows quicker" than N*log(N).
> 

Right. I was thinking of with this ordered check, you have O(N) scaling
for the number of checks, but that means that we have O(N^2) number of
lines as we scale the number of checks up. Each macro required ~N lines,
but we have N macros, so we get N^2 number of lines.

> But I don't think we can talk about algorithmic complexity here (big O
> notation), which stays the same (linear) in both ways of expressing the
> same thing.
>

Right. The computation stays the same. But now, we only need 4 lines per
check, because each check is built on top of the previous ones recursively.

>> Its fantastic improvement, thanks for the suggestion. I'll have v9 out
>> with these improvements soon.
> 
> And thanks for staying online with this effort for more than an entire
> kernel development cycle! Looking forward to v9.

Yea. This has certainly taken longer than I would have liked, but I'm
happy with the end result. We got something much better, even if it took
fiddling around in the wrong areas for longer than I would have liked. I
think these changes are great for ice, and also make packing much easier
to use for others on the long run. Hopefully we can see more adoption now.
Vladimir Oltean Dec. 5, 2024, 9:52 a.m. UTC | #7 
On Thu, Dec 05, 2024 at 12:43:35AM +0100, Przemek Kitszel wrote:
> On 12/4/24 18:12, Vladimir Oltean wrote:
> > On Tue, Dec 03, 2024 at 03:53:49PM -0800, Jacob Keller wrote:
> 
> Amazing stuff :), I really like the fact that you both keep striving for
> the best result, even way past the point of cut off of most other ;)

It's all Jake. I openly admit I would have given up and not followed
through with the review feedback to go to modpost and back.
Additionally, the __builtin_choose_expr() breakthrough was all his.

Jake's determination, perseverence, discipline and level of skill are
something to aspire to. It's safe to say that without him, this set
would have gotten nowhere.

> prior to the change CHECK_PACKED_FIELD() was called on values smaller
> than MAX_PACKED_FIELD_SIZE, compare with [j] above, now you call it also
> for the MAX one
(...)
> 
> off by one error? see above

Yes, indeed, thank you for pointing this out. Jake also replied a few
minutes prior to your message.

> PS. incremental diff in a single patch is harder to apply, but easier to
> review, comment both in a single reply == great idea

I'm interpreting this as a positive comment :) I got mixed feedback
about posting diffs in reply to patches, it seems to confuse b4 when
applying.
Jacob Keller Dec. 5, 2024, 9:26 p.m. UTC | #8 
On 12/5/2024 1:52 AM, Vladimir Oltean wrote:
> On Thu, Dec 05, 2024 at 12:43:35AM +0100, Przemek Kitszel wrote:
>> On 12/4/24 18:12, Vladimir Oltean wrote:
>>> On Tue, Dec 03, 2024 at 03:53:49PM -0800, Jacob Keller wrote:
>>
>> Amazing stuff :), I really like the fact that you both keep striving for
>> the best result, even way past the point of cut off of most other ;)
> 
> It's all Jake. I openly admit I would have given up and not followed
> through with the review feedback to go to modpost and back.
> Additionally, the __builtin_choose_expr() breakthrough was all his.
> 
> Jake's determination, perseverence, discipline and level of skill are
> something to aspire to. It's safe to say that without him, this set
> would have gotten nowhere.
> 

Thanks :) I'm happy to finally arrive at a version I am quite happy
with. It certainly took longer than I had planned, but I believe the end
result is significant improvement and code which hopefully many other
drivers can adopt.

>> prior to the change CHECK_PACKED_FIELD() was called on values smaller
>> than MAX_PACKED_FIELD_SIZE, compare with [j] above, now you call it also
>> for the MAX one
> (...)
>>
>> off by one error? see above
> 
> Yes, indeed, thank you for pointing this out. Jake also replied a few
> minutes prior to your message.
> 
>> PS. incremental diff in a single patch is harder to apply, but easier to
>> review, comment both in a single reply == great idea
> 
> I'm interpreting this as a positive comment :) I got mixed feedback
> about posting diffs in reply to patches, it seems to confuse b4 when
> applying.

Yea, b4 am / b4 shazam don't seem to handle inline diffs like this very
well. However, I've made good use of:

$ b4 mbox --single-message <message-id>

and then editing the file to extract the diffs myself.

I think there may be some possibility to use the scissors lines as a way
to identify the diffs, but I don't know if b4 has this builtin. See the
section from git mailinfo:

>        --scissors
>            Remove everything in body before a scissors line (e.g. "-- >8 --"). The line represents scissors and perforation marks, and is used to request
>            the reader to cut the message at that line. If that line appears in the body of the message before the patch, everything before it (including the
>            scissors line itself) is ignored when this option is used.
> 
>            This is useful if you want to begin your message in a discussion thread with comments and suggestions on the message you are responding to, and
>            to conclude it with a patch submission, separating the discussion and the beginning of the proposed commit log message with a scissors line.
> 
>            This can be enabled by default with the configuration option mailinfo.scissors.
> 

Perhaps some way of marking diffs with the -- >8 -- lines could be used
as convenient markers for where a diff in a message is, vs regular text.
diff mbox series

Patch

diff --git a/Makefile b/Makefile
index 8129de0b214f5b73a3b1cca0798041d74270836b..58496942a7d13c6a53e4210d83deb2cc2033d00a 100644
--- a/Makefile
+++ b/Makefile
@@ -1315,6 +1315,10 @@  PHONY += scripts_unifdef
 scripts_unifdef: scripts_basic
 	$(Q)$(MAKE) $(build)=scripts scripts/unifdef
 
+PHONY += scripts_gen_packed_field_checks
+scripts_gen_packed_field_checks: scripts_basic
+	$(Q)$(MAKE) $(build)=scripts scripts/gen_packed_field_checks
+
 # ---------------------------------------------------------------------------
 # Install
 
diff --git a/include/linux/packing.h b/include/linux/packing.h
index 5d36dcd06f60420325473dae3a0e9ac37d03da4b..c4fc76ae64a512cf977f3a89da25717bd99a5d91 100644
--- a/include/linux/packing.h
+++ b/include/linux/packing.h
@@ -8,6 +8,61 @@ 
 #include <linux/types.h>
 #include <linux/bitops.h>
 
+#define GEN_PACKED_FIELD_MEMBERS(__type) \
+	__type startbit; \
+	__type endbit; \
+	__type offset; \
+	__type size
+
+/* Small packed field. Use with bit offsets < 256, buffers < 32B and
+ * unpacked structures < 256B.
+ */
+struct packed_field_s {
+	GEN_PACKED_FIELD_MEMBERS(u8);
+};
+
+/* Medium packed field. Use with bit offsets < 65536, buffers < 8KB and
+ * unpacked structures < 64KB.
+ */
+struct packed_field_m {
+	GEN_PACKED_FIELD_MEMBERS(u16);
+};
+
+#define PACKED_FIELD(start, end, struct_name, struct_field) \
+{ \
+	(start), \
+	(end), \
+	offsetof(struct_name, struct_field), \
+	sizeof_field(struct_name, struct_field), \
+}
+
+#define CHECK_PACKED_FIELD(field) ({ \
+	typeof(field) __f = (field); \
+	BUILD_BUG_ON(__f.startbit < __f.endbit); \
+	BUILD_BUG_ON(__f.startbit - __f.endbit >= BITS_PER_BYTE * __f.size); \
+	BUILD_BUG_ON(__f.size != 1 && __f.size != 2 && \
+		     __f.size != 4 && __f.size != 8); \
+})
+
+
+#define CHECK_PACKED_FIELD_OVERLAP(ascending, field1, field2) ({ \
+	typeof(field1) _f1 = (field1); typeof(field2) _f2 = (field2); \
+	const bool _a = (ascending); \
+	BUILD_BUG_ON(_a && _f1.startbit >= _f2.startbit); \
+	BUILD_BUG_ON(!_a && _f1.startbit <= _f2.startbit); \
+	BUILD_BUG_ON(max(_f1.endbit, _f2.endbit) <= \
+		     min(_f1.startbit, _f2.startbit)); \
+})
+
+#define CHECK_PACKED_FIELDS_SIZE(fields, pbuflen) ({ \
+	typeof(&(fields)[0]) _f = (fields); \
+	typeof(pbuflen) _len = (pbuflen); \
+	const size_t num_fields = ARRAY_SIZE(fields); \
+	BUILD_BUG_ON(!__builtin_constant_p(_len)); \
+	BUILD_BUG_ON(_f[0].startbit >= BITS_PER_BYTE * _len); \
+	BUILD_BUG_ON(_f[num_fields - 1].startbit >= BITS_PER_BYTE * _len); \
+})
+
 #define QUIRK_MSB_ON_THE_RIGHT	BIT(0)
 #define QUIRK_LITTLE_ENDIAN	BIT(1)
 #define QUIRK_LSW32_IS_FIRST	BIT(2)
@@ -26,4 +81,2804 @@  int pack(void *pbuf, u64 uval, size_t startbit, size_t endbit, size_t pbuflen,
 int unpack(const void *pbuf, u64 *uval, size_t startbit, size_t endbit,
 	   size_t pbuflen, u8 quirks);
 
+void pack_fields_s(void *pbuf, size_t pbuflen, const void *ustruct,
+		   const struct packed_field_s *fields, size_t num_fields,
+		   u8 quirks);
+
+void pack_fields_m(void *pbuf, size_t pbuflen, const void *ustruct,
+		   const struct packed_field_m *fields, size_t num_fields,
+		   u8 quirks);
+
+void unpack_fields_s(const void *pbuf, size_t pbuflen, void *ustruct,
+		     const struct packed_field_s *fields, size_t num_fields,
+		     u8 quirks);
+
+void unpack_fields_m(const void *pbuf, size_t pbuflen, void *ustruct,
+		     const struct packed_field_m *fields, size_t num_fields,
+		     u8 quirks);
+
+/* Do not hand-edit the following packed field check macros!
+ *
+ * They are generated using scripts/gen_packed_field_checks.c, which may be
+ * built via "make scripts_gen_packed_field_checks". If larger macro sizes are
+ * needed in the future, please use this program to re-generate the macros and
+ * insert them here.
+ */
+
+#define CHECK_PACKED_FIELDS_1(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 1); \
+	 CHECK_PACKED_FIELD(_f[0]); })
+
+#define CHECK_PACKED_FIELDS_2(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 2); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); })
+
+#define CHECK_PACKED_FIELDS_3(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 3); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); })
+
+#define CHECK_PACKED_FIELDS_4(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 4); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); })
+
+#define CHECK_PACKED_FIELDS_5(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 5); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); })
+
+#define CHECK_PACKED_FIELDS_6(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 6); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); })
+
+#define CHECK_PACKED_FIELDS_7(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 7); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); })
+
+#define CHECK_PACKED_FIELDS_8(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 8); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); })
+
+#define CHECK_PACKED_FIELDS_9(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 9); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); })
+
+#define CHECK_PACKED_FIELDS_10(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 10); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); })
+
+#define CHECK_PACKED_FIELDS_11(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 11); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); })
+
+#define CHECK_PACKED_FIELDS_12(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 12); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); })
+
+#define CHECK_PACKED_FIELDS_13(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 13); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); })
+
+#define CHECK_PACKED_FIELDS_14(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 14); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); })
+
+#define CHECK_PACKED_FIELDS_15(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 15); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); })
+
+#define CHECK_PACKED_FIELDS_16(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 16); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); })
+
+#define CHECK_PACKED_FIELDS_17(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 17); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); })
+
+#define CHECK_PACKED_FIELDS_18(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 18); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); })
+
+#define CHECK_PACKED_FIELDS_19(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 19); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); })
+
+#define CHECK_PACKED_FIELDS_20(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 20); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); })
+
+#define CHECK_PACKED_FIELDS_21(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 21); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); })
+
+#define CHECK_PACKED_FIELDS_22(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 22); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); })
+
+#define CHECK_PACKED_FIELDS_23(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 23); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); })
+
+#define CHECK_PACKED_FIELDS_24(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 24); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); })
+
+#define CHECK_PACKED_FIELDS_25(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 25); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); })
+
+#define CHECK_PACKED_FIELDS_26(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 26); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); })
+
+#define CHECK_PACKED_FIELDS_27(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 27); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); })
+
+#define CHECK_PACKED_FIELDS_28(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 28); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); })
+
+#define CHECK_PACKED_FIELDS_29(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 29); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); })
+
+#define CHECK_PACKED_FIELDS_30(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 30); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); })
+
+#define CHECK_PACKED_FIELDS_31(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 31); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); })
+
+#define CHECK_PACKED_FIELDS_32(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 32); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); })
+
+#define CHECK_PACKED_FIELDS_33(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 33); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); })
+
+#define CHECK_PACKED_FIELDS_34(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 34); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); })
+
+#define CHECK_PACKED_FIELDS_35(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 35); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); })
+
+#define CHECK_PACKED_FIELDS_36(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 36); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); })
+
+#define CHECK_PACKED_FIELDS_37(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 37); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); })
+
+#define CHECK_PACKED_FIELDS_38(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 38); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD(_f[37]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[36], _f[37]); })
+
+#define CHECK_PACKED_FIELDS_39(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 39); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD(_f[37]); \
+	 CHECK_PACKED_FIELD(_f[38]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[36], _f[37]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[37], _f[38]); })
+
+#define CHECK_PACKED_FIELDS_40(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 40); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD(_f[37]); \
+	 CHECK_PACKED_FIELD(_f[38]); \
+	 CHECK_PACKED_FIELD(_f[39]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[36], _f[37]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[37], _f[38]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[38], _f[39]); })
+
+#define CHECK_PACKED_FIELDS_41(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 41); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD(_f[37]); \
+	 CHECK_PACKED_FIELD(_f[38]); \
+	 CHECK_PACKED_FIELD(_f[39]); \
+	 CHECK_PACKED_FIELD(_f[40]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[36], _f[37]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[37], _f[38]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[38], _f[39]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[39], _f[40]); })
+
+#define CHECK_PACKED_FIELDS_42(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 42); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD(_f[37]); \
+	 CHECK_PACKED_FIELD(_f[38]); \
+	 CHECK_PACKED_FIELD(_f[39]); \
+	 CHECK_PACKED_FIELD(_f[40]); \
+	 CHECK_PACKED_FIELD(_f[41]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[36], _f[37]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[37], _f[38]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[38], _f[39]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[39], _f[40]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[40], _f[41]); })
+
+#define CHECK_PACKED_FIELDS_43(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 43); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD(_f[37]); \
+	 CHECK_PACKED_FIELD(_f[38]); \
+	 CHECK_PACKED_FIELD(_f[39]); \
+	 CHECK_PACKED_FIELD(_f[40]); \
+	 CHECK_PACKED_FIELD(_f[41]); \
+	 CHECK_PACKED_FIELD(_f[42]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[36], _f[37]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[37], _f[38]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[38], _f[39]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[39], _f[40]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[40], _f[41]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[41], _f[42]); })
+
+#define CHECK_PACKED_FIELDS_44(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 44); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD(_f[37]); \
+	 CHECK_PACKED_FIELD(_f[38]); \
+	 CHECK_PACKED_FIELD(_f[39]); \
+	 CHECK_PACKED_FIELD(_f[40]); \
+	 CHECK_PACKED_FIELD(_f[41]); \
+	 CHECK_PACKED_FIELD(_f[42]); \
+	 CHECK_PACKED_FIELD(_f[43]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[36], _f[37]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[37], _f[38]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[38], _f[39]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[39], _f[40]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[40], _f[41]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[41], _f[42]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[42], _f[43]); })
+
+#define CHECK_PACKED_FIELDS_45(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 45); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD(_f[37]); \
+	 CHECK_PACKED_FIELD(_f[38]); \
+	 CHECK_PACKED_FIELD(_f[39]); \
+	 CHECK_PACKED_FIELD(_f[40]); \
+	 CHECK_PACKED_FIELD(_f[41]); \
+	 CHECK_PACKED_FIELD(_f[42]); \
+	 CHECK_PACKED_FIELD(_f[43]); \
+	 CHECK_PACKED_FIELD(_f[44]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[36], _f[37]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[37], _f[38]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[38], _f[39]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[39], _f[40]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[40], _f[41]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[41], _f[42]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[42], _f[43]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[43], _f[44]); })
+
+#define CHECK_PACKED_FIELDS_46(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 46); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD(_f[37]); \
+	 CHECK_PACKED_FIELD(_f[38]); \
+	 CHECK_PACKED_FIELD(_f[39]); \
+	 CHECK_PACKED_FIELD(_f[40]); \
+	 CHECK_PACKED_FIELD(_f[41]); \
+	 CHECK_PACKED_FIELD(_f[42]); \
+	 CHECK_PACKED_FIELD(_f[43]); \
+	 CHECK_PACKED_FIELD(_f[44]); \
+	 CHECK_PACKED_FIELD(_f[45]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[36], _f[37]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[37], _f[38]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[38], _f[39]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[39], _f[40]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[40], _f[41]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[41], _f[42]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[42], _f[43]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[43], _f[44]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[44], _f[45]); })
+
+#define CHECK_PACKED_FIELDS_47(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 47); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD(_f[37]); \
+	 CHECK_PACKED_FIELD(_f[38]); \
+	 CHECK_PACKED_FIELD(_f[39]); \
+	 CHECK_PACKED_FIELD(_f[40]); \
+	 CHECK_PACKED_FIELD(_f[41]); \
+	 CHECK_PACKED_FIELD(_f[42]); \
+	 CHECK_PACKED_FIELD(_f[43]); \
+	 CHECK_PACKED_FIELD(_f[44]); \
+	 CHECK_PACKED_FIELD(_f[45]); \
+	 CHECK_PACKED_FIELD(_f[46]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[36], _f[37]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[37], _f[38]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[38], _f[39]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[39], _f[40]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[40], _f[41]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[41], _f[42]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[42], _f[43]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[43], _f[44]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[44], _f[45]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[45], _f[46]); })
+
+#define CHECK_PACKED_FIELDS_48(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 48); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD(_f[37]); \
+	 CHECK_PACKED_FIELD(_f[38]); \
+	 CHECK_PACKED_FIELD(_f[39]); \
+	 CHECK_PACKED_FIELD(_f[40]); \
+	 CHECK_PACKED_FIELD(_f[41]); \
+	 CHECK_PACKED_FIELD(_f[42]); \
+	 CHECK_PACKED_FIELD(_f[43]); \
+	 CHECK_PACKED_FIELD(_f[44]); \
+	 CHECK_PACKED_FIELD(_f[45]); \
+	 CHECK_PACKED_FIELD(_f[46]); \
+	 CHECK_PACKED_FIELD(_f[47]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[36], _f[37]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[37], _f[38]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[38], _f[39]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[39], _f[40]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[40], _f[41]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[41], _f[42]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[42], _f[43]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[43], _f[44]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[44], _f[45]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[45], _f[46]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[46], _f[47]); })
+
+#define CHECK_PACKED_FIELDS_49(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 49); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD(_f[37]); \
+	 CHECK_PACKED_FIELD(_f[38]); \
+	 CHECK_PACKED_FIELD(_f[39]); \
+	 CHECK_PACKED_FIELD(_f[40]); \
+	 CHECK_PACKED_FIELD(_f[41]); \
+	 CHECK_PACKED_FIELD(_f[42]); \
+	 CHECK_PACKED_FIELD(_f[43]); \
+	 CHECK_PACKED_FIELD(_f[44]); \
+	 CHECK_PACKED_FIELD(_f[45]); \
+	 CHECK_PACKED_FIELD(_f[46]); \
+	 CHECK_PACKED_FIELD(_f[47]); \
+	 CHECK_PACKED_FIELD(_f[48]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[36], _f[37]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[37], _f[38]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[38], _f[39]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[39], _f[40]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[40], _f[41]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[41], _f[42]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[42], _f[43]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[43], _f[44]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[44], _f[45]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[45], _f[46]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[46], _f[47]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[47], _f[48]); })
+
+#define CHECK_PACKED_FIELDS_50(fields) \
+	({ typeof(&(fields)[0]) _f = (fields); \
+	 BUILD_BUG_ON(ARRAY_SIZE(fields) != 50); \
+	 CHECK_PACKED_FIELD(_f[0]); \
+	 CHECK_PACKED_FIELD(_f[1]); \
+	 CHECK_PACKED_FIELD(_f[2]); \
+	 CHECK_PACKED_FIELD(_f[3]); \
+	 CHECK_PACKED_FIELD(_f[4]); \
+	 CHECK_PACKED_FIELD(_f[5]); \
+	 CHECK_PACKED_FIELD(_f[6]); \
+	 CHECK_PACKED_FIELD(_f[7]); \
+	 CHECK_PACKED_FIELD(_f[8]); \
+	 CHECK_PACKED_FIELD(_f[9]); \
+	 CHECK_PACKED_FIELD(_f[10]); \
+	 CHECK_PACKED_FIELD(_f[11]); \
+	 CHECK_PACKED_FIELD(_f[12]); \
+	 CHECK_PACKED_FIELD(_f[13]); \
+	 CHECK_PACKED_FIELD(_f[14]); \
+	 CHECK_PACKED_FIELD(_f[15]); \
+	 CHECK_PACKED_FIELD(_f[16]); \
+	 CHECK_PACKED_FIELD(_f[17]); \
+	 CHECK_PACKED_FIELD(_f[18]); \
+	 CHECK_PACKED_FIELD(_f[19]); \
+	 CHECK_PACKED_FIELD(_f[20]); \
+	 CHECK_PACKED_FIELD(_f[21]); \
+	 CHECK_PACKED_FIELD(_f[22]); \
+	 CHECK_PACKED_FIELD(_f[23]); \
+	 CHECK_PACKED_FIELD(_f[24]); \
+	 CHECK_PACKED_FIELD(_f[25]); \
+	 CHECK_PACKED_FIELD(_f[26]); \
+	 CHECK_PACKED_FIELD(_f[27]); \
+	 CHECK_PACKED_FIELD(_f[28]); \
+	 CHECK_PACKED_FIELD(_f[29]); \
+	 CHECK_PACKED_FIELD(_f[30]); \
+	 CHECK_PACKED_FIELD(_f[31]); \
+	 CHECK_PACKED_FIELD(_f[32]); \
+	 CHECK_PACKED_FIELD(_f[33]); \
+	 CHECK_PACKED_FIELD(_f[34]); \
+	 CHECK_PACKED_FIELD(_f[35]); \
+	 CHECK_PACKED_FIELD(_f[36]); \
+	 CHECK_PACKED_FIELD(_f[37]); \
+	 CHECK_PACKED_FIELD(_f[38]); \
+	 CHECK_PACKED_FIELD(_f[39]); \
+	 CHECK_PACKED_FIELD(_f[40]); \
+	 CHECK_PACKED_FIELD(_f[41]); \
+	 CHECK_PACKED_FIELD(_f[42]); \
+	 CHECK_PACKED_FIELD(_f[43]); \
+	 CHECK_PACKED_FIELD(_f[44]); \
+	 CHECK_PACKED_FIELD(_f[45]); \
+	 CHECK_PACKED_FIELD(_f[46]); \
+	 CHECK_PACKED_FIELD(_f[47]); \
+	 CHECK_PACKED_FIELD(_f[48]); \
+	 CHECK_PACKED_FIELD(_f[49]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[0], _f[1]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[1], _f[2]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[2], _f[3]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[3], _f[4]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[4], _f[5]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[5], _f[6]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[6], _f[7]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[7], _f[8]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[8], _f[9]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[9], _f[10]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[10], _f[11]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[11], _f[12]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[12], _f[13]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[13], _f[14]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[14], _f[15]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[15], _f[16]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[16], _f[17]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[17], _f[18]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[18], _f[19]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[19], _f[20]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[20], _f[21]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[21], _f[22]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[22], _f[23]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[23], _f[24]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[24], _f[25]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[25], _f[26]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[26], _f[27]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[27], _f[28]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[28], _f[29]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[29], _f[30]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[30], _f[31]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[31], _f[32]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[32], _f[33]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[33], _f[34]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[34], _f[35]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[35], _f[36]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[36], _f[37]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[37], _f[38]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[38], _f[39]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[39], _f[40]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[40], _f[41]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[41], _f[42]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[42], _f[43]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[43], _f[44]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[44], _f[45]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[45], _f[46]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[46], _f[47]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[47], _f[48]); \
+	 CHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[48], _f[49]); })
+
+#define CHECK_PACKED_FIELDS(fields) \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 1, CHECK_PACKED_FIELDS_1(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 2, CHECK_PACKED_FIELDS_2(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 3, CHECK_PACKED_FIELDS_3(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 4, CHECK_PACKED_FIELDS_4(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 5, CHECK_PACKED_FIELDS_5(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 6, CHECK_PACKED_FIELDS_6(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 7, CHECK_PACKED_FIELDS_7(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 8, CHECK_PACKED_FIELDS_8(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 9, CHECK_PACKED_FIELDS_9(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 10, CHECK_PACKED_FIELDS_10(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 11, CHECK_PACKED_FIELDS_11(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 12, CHECK_PACKED_FIELDS_12(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 13, CHECK_PACKED_FIELDS_13(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 14, CHECK_PACKED_FIELDS_14(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 15, CHECK_PACKED_FIELDS_15(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 16, CHECK_PACKED_FIELDS_16(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 17, CHECK_PACKED_FIELDS_17(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 18, CHECK_PACKED_FIELDS_18(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 19, CHECK_PACKED_FIELDS_19(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 20, CHECK_PACKED_FIELDS_20(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 21, CHECK_PACKED_FIELDS_21(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 22, CHECK_PACKED_FIELDS_22(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 23, CHECK_PACKED_FIELDS_23(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 24, CHECK_PACKED_FIELDS_24(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 25, CHECK_PACKED_FIELDS_25(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 26, CHECK_PACKED_FIELDS_26(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 27, CHECK_PACKED_FIELDS_27(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 28, CHECK_PACKED_FIELDS_28(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 29, CHECK_PACKED_FIELDS_29(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 30, CHECK_PACKED_FIELDS_30(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 31, CHECK_PACKED_FIELDS_31(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 32, CHECK_PACKED_FIELDS_32(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 33, CHECK_PACKED_FIELDS_33(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 34, CHECK_PACKED_FIELDS_34(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 35, CHECK_PACKED_FIELDS_35(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 36, CHECK_PACKED_FIELDS_36(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 37, CHECK_PACKED_FIELDS_37(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 38, CHECK_PACKED_FIELDS_38(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 39, CHECK_PACKED_FIELDS_39(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 40, CHECK_PACKED_FIELDS_40(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 41, CHECK_PACKED_FIELDS_41(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 42, CHECK_PACKED_FIELDS_42(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 43, CHECK_PACKED_FIELDS_43(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 44, CHECK_PACKED_FIELDS_44(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 45, CHECK_PACKED_FIELDS_45(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 46, CHECK_PACKED_FIELDS_46(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 47, CHECK_PACKED_FIELDS_47(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 48, CHECK_PACKED_FIELDS_48(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 49, CHECK_PACKED_FIELDS_49(fields), \
+	__builtin_choose_expr(ARRAY_SIZE(fields) == 50, CHECK_PACKED_FIELDS_50(fields), \
+	({ BUILD_BUG_ON_MSG(1, "CHECK_PACKED_FIELDS() must be regenerated to support array sizes larger than 50."); }) \
+	))))))))))))))))))))))))))))))))))))))))))))))))))
+
+/* End of generated content */
+
+#define pack_fields(pbuf, pbuflen, ustruct, fields, quirks) \
+	({ \
+		CHECK_PACKED_FIELDS(fields); \
+		CHECK_PACKED_FIELDS_SIZE((fields), (pbuflen)); \
+		_Generic((fields), \
+			 const struct packed_field_s * : pack_fields_s, \
+			 const struct packed_field_m * : pack_fields_m \
+			)((pbuf), (pbuflen), (ustruct), (fields), ARRAY_SIZE(fields), (quirks)); \
+	})
+
+#define unpack_fields(pbuf, pbuflen, ustruct, fields, quirks) \
+	({ \
+		CHECK_PACKED_FIELDS(fields); \
+		CHECK_PACKED_FIELDS_SIZE((fields), (pbuflen)); \
+		_Generic((fields), \
+			 const struct packed_field_s * : unpack_fields_s, \
+			 const struct packed_field_m * : unpack_fields_m \
+			)((pbuf), (pbuflen), (ustruct), (fields), ARRAY_SIZE(fields), (quirks)); \
+	})
+
 #endif
diff --git a/lib/packing.c b/lib/packing.c
index 09a2d195b9433b61c86f3b63ff019ab319c83e97..45164f73fe5bf9f2c547eb22016af7e44fed9eb0 100644
--- a/lib/packing.c
+++ b/lib/packing.c
@@ -5,10 +5,37 @@ 
 #include <linux/packing.h>
 #include <linux/module.h>
 #include <linux/bitops.h>
+#include <linux/bits.h>
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/bitrev.h>
 
+#define __pack_fields(pbuf, pbuflen, ustruct, fields, num_fields, quirks)	\
+	({									\
+		for (size_t i = 0; i < (num_fields); i++) {			\
+			typeof(&(fields)[0]) field = &(fields)[i];		\
+			u64 uval;						\
+										\
+			uval = ustruct_field_to_u64(ustruct, field->offset, field->size); \
+										\
+			__pack(pbuf, uval, field->startbit, field->endbit,	\
+			       pbuflen, quirks);				\
+		}								\
+	})
+
+#define __unpack_fields(pbuf, pbuflen, ustruct, fields, num_fields, quirks)	\
+	({									\
+		for (size_t i = 0; i < (num_fields); i++) {			\
+			typeof(&(fields)[0]) field = &fields[i];		\
+			u64 uval;						\
+										\
+			__unpack(pbuf, &uval, field->startbit, field->endbit,	\
+				 pbuflen, quirks);				\
+										\
+			u64_to_ustruct_field(ustruct, field->offset, field->size, uval); \
+		}								\
+	})
+
 /**
  * calculate_box_addr - Determine physical location of byte in buffer
  * @box: Index of byte within buffer seen as a logical big-endian big number
@@ -322,4 +349,122 @@  int packing(void *pbuf, u64 *uval, int startbit, int endbit, size_t pbuflen,
 }
 EXPORT_SYMBOL(packing);
 
+static u64 ustruct_field_to_u64(const void *ustruct, size_t field_offset,
+				size_t field_size)
+{
+	switch (field_size) {
+	case 1:
+		return *((u8 *)(ustruct + field_offset));
+	case 2:
+		return *((u16 *)(ustruct + field_offset));
+	case 4:
+		return *((u32 *)(ustruct + field_offset));
+	default:
+		return *((u64 *)(ustruct + field_offset));
+	}
+}
+
+static void u64_to_ustruct_field(void *ustruct, size_t field_offset,
+				 size_t field_size, u64 uval)
+{
+	switch (field_size) {
+	case 1:
+		*((u8 *)(ustruct + field_offset)) = uval;
+		break;
+	case 2:
+		*((u16 *)(ustruct + field_offset)) = uval;
+		break;
+	case 4:
+		*((u32 *)(ustruct + field_offset)) = uval;
+		break;
+	default:
+		*((u64 *)(ustruct + field_offset)) = uval;
+		break;
+	}
+}
+
+/**
+ * pack_fields_s - Pack array of small fields
+ *
+ * @pbuf: Pointer to a buffer holding the packed value.
+ * @pbuflen: The length in bytes of the packed buffer pointed to by @pbuf.
+ * @ustruct: Pointer to CPU-readable structure holding the unpacked value.
+ *	     It is expected (but not checked) that this has the same data type
+ *	     as all struct packed_field_s definitions.
+ * @fields: Array of small packed fields definition. They must not overlap.
+ * @num_fields: Length of @fields array.
+ * @quirks: A bit mask of QUIRK_LITTLE_ENDIAN, QUIRK_LSW32_IS_FIRST and
+ *	    QUIRK_MSB_ON_THE_RIGHT.
+ */
+void pack_fields_s(void *pbuf, size_t pbuflen, const void *ustruct,
+		   const struct packed_field_s *fields, size_t num_fields,
+		   u8 quirks)
+{
+	__pack_fields(pbuf, pbuflen, ustruct, fields, num_fields, quirks);
+}
+EXPORT_SYMBOL(pack_fields_s);
+
+/**
+ * pack_fields_m - Pack array of medium fields
+ *
+ * @pbuf: Pointer to a buffer holding the packed value.
+ * @pbuflen: The length in bytes of the packed buffer pointed to by @pbuf.
+ * @ustruct: Pointer to CPU-readable structure holding the unpacked value.
+ *	     It is expected (but not checked) that this has the same data type
+ *	     as all struct packed_field_s definitions.
+ * @fields: Array of medium packed fields definition. They must not overlap.
+ * @num_fields: Length of @fields array.
+ * @quirks: A bit mask of QUIRK_LITTLE_ENDIAN, QUIRK_LSW32_IS_FIRST and
+ *	    QUIRK_MSB_ON_THE_RIGHT.
+ */
+void pack_fields_m(void *pbuf, size_t pbuflen, const void *ustruct,
+		   const struct packed_field_m *fields, size_t num_fields,
+		   u8 quirks)
+{
+	__pack_fields(pbuf, pbuflen, ustruct, fields, num_fields, quirks);
+}
+EXPORT_SYMBOL(pack_fields_m);
+
+/**
+ * unpack_fields_s - Unpack array of small fields
+ *
+ * @pbuf: Pointer to a buffer holding the packed value.
+ * @pbuflen: The length in bytes of the packed buffer pointed to by @pbuf.
+ * @ustruct: Pointer to CPU-readable structure holding the unpacked value.
+ *	     It is expected (but not checked) that this has the same data type
+ *	     as all struct packed_field_s definitions.
+ * @fields: Array of small packed fields definition. They must not overlap.
+ * @num_fields: Length of @fields array.
+ * @quirks: A bit mask of QUIRK_LITTLE_ENDIAN, QUIRK_LSW32_IS_FIRST and
+ *	    QUIRK_MSB_ON_THE_RIGHT.
+ */
+void unpack_fields_s(const void *pbuf, size_t pbuflen, void *ustruct,
+		     const struct packed_field_s *fields, size_t num_fields,
+		     u8 quirks)
+{
+	__unpack_fields(pbuf, pbuflen, ustruct, fields, num_fields, quirks);
+}
+EXPORT_SYMBOL(unpack_fields_s);
+
+/**
+ * unpack_fields_m - Unpack array of medium fields
+ *
+ * @pbuf: Pointer to a buffer holding the packed value.
+ * @pbuflen: The length in bytes of the packed buffer pointed to by @pbuf.
+ * @ustruct: Pointer to CPU-readable structure holding the unpacked value.
+ *	     It is expected (but not checked) that this has the same data type
+ *	     as all struct packed_field_s definitions.
+ * @fields: Array of medium packed fields definition. They must not overlap.
+ * @num_fields: Length of @fields array.
+ * @quirks: A bit mask of QUIRK_LITTLE_ENDIAN, QUIRK_LSW32_IS_FIRST and
+ *	    QUIRK_MSB_ON_THE_RIGHT.
+ */
+void unpack_fields_m(const void *pbuf, size_t pbuflen, void *ustruct,
+		     const struct packed_field_m *fields, size_t num_fields,
+		     u8 quirks)
+{
+	__unpack_fields(pbuf, pbuflen, ustruct, fields, num_fields, quirks);
+}
+EXPORT_SYMBOL(unpack_fields_m);
+
 MODULE_DESCRIPTION("Generic bitfield packing and unpacking");
diff --git a/lib/packing_test.c b/lib/packing_test.c
index b38ea43c03fd83639f18a6f3e2a42eae36118c45..3b4167ce56bf65fa4d66cb55d3215aecc33f64c4 100644
--- a/lib/packing_test.c
+++ b/lib/packing_test.c
@@ -396,9 +396,70 @@  static void packing_test_unpack(struct kunit *test)
 	KUNIT_EXPECT_EQ(test, uval, params->uval);
 }
 
+#define PACKED_BUF_SIZE 8
+
+typedef struct __packed { u8 buf[PACKED_BUF_SIZE]; } packed_buf_t;
+
+struct test_data {
+	u32 field3;
+	u16 field2;
+	u16 field4;
+	u16 field6;
+	u8 field1;
+	u8 field5;
+};
+
+static const struct packed_field_s test_fields[] = {
+	PACKED_FIELD(63, 61, struct test_data, field1),
+	PACKED_FIELD(60, 52, struct test_data, field2),
+	PACKED_FIELD(51, 28, struct test_data, field3),
+	PACKED_FIELD(27, 14, struct test_data, field4),
+	PACKED_FIELD(13, 9, struct test_data, field5),
+	PACKED_FIELD(8, 0, struct test_data, field6),
+};
+
+static void packing_test_pack_fields(struct kunit *test)
+{
+	const struct test_data data = {
+		.field1 = 0x2,
+		.field2 = 0x100,
+		.field3 = 0xF00050,
+		.field4 = 0x7D3,
+		.field5 = 0x9,
+		.field6 = 0x10B,
+	};
+	packed_buf_t expect = {
+		.buf = { 0x50, 0x0F, 0x00, 0x05, 0x01, 0xF4, 0xD3, 0x0B },
+	};
+	packed_buf_t buf = {};
+
+	pack_fields(&buf, sizeof(buf), &data, test_fields, 0);
+
+	KUNIT_EXPECT_MEMEQ(test, &expect, &buf, sizeof(buf));
+}
+
+static void packing_test_unpack_fields(struct kunit *test)
+{
+	const packed_buf_t buf = {
+		.buf = { 0x17, 0x28, 0x10, 0x19, 0x3D, 0xA9, 0x07, 0x9C },
+	};
+	struct test_data data = {};
+
+	unpack_fields(&buf, sizeof(buf), &data, test_fields, 0);
+
+	KUNIT_EXPECT_EQ(test, 0, data.field1);
+	KUNIT_EXPECT_EQ(test, 0x172, data.field2);
+	KUNIT_EXPECT_EQ(test, 0x810193, data.field3);
+	KUNIT_EXPECT_EQ(test, 0x36A4, data.field4);
+	KUNIT_EXPECT_EQ(test, 0x3, data.field5);
+	KUNIT_EXPECT_EQ(test, 0x19C, data.field6);
+}
+
 static struct kunit_case packing_test_cases[] = {
 	KUNIT_CASE_PARAM(packing_test_pack, packing_gen_params),
 	KUNIT_CASE_PARAM(packing_test_unpack, packing_gen_params),
+	KUNIT_CASE(packing_test_pack_fields),
+	KUNIT_CASE(packing_test_unpack_fields),
 	{},
 };
 
diff --git a/scripts/gen_packed_field_checks.c b/scripts/gen_packed_field_checks.c
new file mode 100644
index 0000000000000000000000000000000000000000..09a21afd640bdf37ad5ee9f6cfa1d4b9113efbcd
--- /dev/null
+++ b/scripts/gen_packed_field_checks.c
@@ -0,0 +1,38 @@ 
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (c) 2024, Intel Corporation
+#include <stdbool.h>
+#include <stdio.h>
+
+#define MAX_PACKED_FIELD_SIZE 50
+
+int main(int argc, char **argv)
+{
+	for (int i = 1; i <= MAX_PACKED_FIELD_SIZE; i++) {
+		printf("#define CHECK_PACKED_FIELDS_%d(fields) ({ \\\n", i);
+		printf("\ttypeof(&(fields)[0]) _f = (fields); \\\n");
+		printf("\tBUILD_BUG_ON(ARRAY_SIZE(fields) != %d); \\\n", i);
+
+		for (int j = 0; j < i; j++)
+			printf("\tCHECK_PACKED_FIELD(_f[%d]); \\\n", j);
+
+		for (int j = 1; j < i; j++)
+			printf("\tCHECK_PACKED_FIELD_OVERLAP(_f[0].startbit < _f[1].startbit, _f[%d], _f[%d]); \\\n",
+			       j - 1, j);
+
+		printf("})\n\n");
+	}
+
+	printf("#define CHECK_PACKED_FIELDS(fields) \\\n");
+
+	for (int i = 1; i <= MAX_PACKED_FIELD_SIZE; i++)
+		printf("\t__builtin_choose_expr(ARRAY_SIZE(fields) == %d, CHECK_PACKED_FIELDS_%d(fields), \\\n",
+		       i, i);
+
+	printf("\t({ BUILD_BUG_ON_MSG(1, \"CHECK_PACKED_FIELDS() must be regenerated to support array sizes larger than %d.\"); }) \\\n",
+	       MAX_PACKED_FIELD_SIZE);
+
+	for (int i = 1; i <= MAX_PACKED_FIELD_SIZE; i++)
+		printf(")");
+
+	printf("\n");
+}
diff --git a/MAINTAINERS b/MAINTAINERS
index 0456a33ef65792bacb5d305a6384d245844fb743..397dfdab2d92a969d367dcf77207d387cda451e3 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -17561,6 +17561,7 @@  F:	Documentation/core-api/packing.rst
 F:	include/linux/packing.h
 F:	lib/packing.c
 F:	lib/packing_test.c
+F:	scripts/gen_packed_field_checks.c
 
 PADATA PARALLEL EXECUTION MECHANISM
 M:	Steffen Klassert <steffen.klassert@secunet.com>
diff --git a/scripts/Makefile b/scripts/Makefile
index 6bcda4b9d054021b185488841cd36c6e0fb86d0c..546e8175e1c4c8209e67a7f92f7d1e795a030988 100644
--- a/scripts/Makefile
+++ b/scripts/Makefile
@@ -47,7 +47,7 @@  HOSTCFLAGS_sorttable.o += -DMCOUNT_SORT_ENABLED
 endif
 
 # The following programs are only built on demand
-hostprogs += unifdef
+hostprogs += unifdef gen_packed_field_checks
 
 # The module linker script is preprocessed on demand
 targets += module.lds