Re: [PATCH -v2] x86: Add an archinfo dumper module

[Luck, Tony]

> What I was going to propose, though, was to simplify the parsing by
> doing this:
> 
> struct reg_range {
> 	const char * const names;
> 	unsigned flags;
> 	unsigned len;
> };
> 
> which describes a bit slice of the register and then do this:
> 
> const struct reg_range reg_descriptor[] = {
> 	{ TYPE_FLAG,	  1,		{ "VAL" } },
> 	{ TYPE_RSVD,	  62 - 11 + 1,	{"rsvd" } },
> 	{ TYPE_ALTERNATE, 2,		{ "nope", "low", "mid", high" } },
> 	{ TYPE_HEX,	  3,		{ "BAR" } },
> 	{ TYPE_DEC,	  2,		{ "FOO" } },
> };
> 
> Then, the parsing code would simply do:
> 
> 	for (i = ARRAY_SIZE(reg_descriptor) - 1; i >= 0; i--)
> 		dump_range(reg_descriptor[i]);
> 
> 
> with all the logic in dump_range().
> 
> The advantage is that you don't have to do any string parsing which
> might be problematic in some cases and when typing the register
> descriptor, you can be very easy exact on bit length and which bits by
> typing the values directly from the manuals. And you can do lazy stuff
> like "62-11+1" above in case you don't want to count reserved bits,
> especially if they're trailing nybbles and such fun...

There is a lot of bit counting and typing either way.  My string
format is visually compact, and looks quite similar to the eventual
output.

Your reg_range does allow you to pass counting to the compiler
in the case that the documentation gives you highbit/lowbit
ranges. But most fields are small enough that yuo don't even
need to take your socks off to count ... so I don't see it as
a huge deal.

Both formats allow for a sanity check that all the bitfields
add up to 64 ... which will detect single errors (which your
code for my example would fail because you missed the second
reserved field) and only have 60 bits described).

-Tony