dialects: (builtin) add CompileTimeFixedBitwidthType

[jorendumoulin]

This PR adds the CompileTimeFixedBitwidthType to represent values that have a fixed bitwidth and are thus packable, but the bitwidth may not be known until compile time.

The new dependency graph now looks like the following: https://is.gd/q5N7Dx

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 90.41%. Comparing base (4bbeecb) to head (5df2d50).
Report is 20 commits behind head on main.

Additional details and impacted files

@@            Coverage Diff             @@
##             main    #3599      +/-   ##
==========================================
+ Coverage   90.38%   90.41%   +0.02%     
==========================================
  Files         469      471       +2     
  Lines       59075    59151      +76     
  Branches     5615     5611       -4     
==========================================
+ Hits        53397    53482      +85     
+ Misses       4232     4225       -7     
+ Partials     1446     1444       -2     

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[superlopuh]

IndexType is not FixedBitwidth, since its bitwidth is target-dependent

[superlopuh]

We need an adjustment to the hierarchy, where we need to distinguish between packability, and bitwidth fixed at compile-time vs runtime

[superlopuh]

Probably worth checking with @math-fehr on this also, but my understanding is that we're missing a type that says that the bitwidth is fixed during compilation time but it may differ from the bitwidth at runtime until lowered to target-dependent code.

[jorendumoulin]

IndexType is not FixedBitwidth, since its bitwidth is target-dependent

I had considered it to be because even if it is target-dependent, it will always have a fixed bitwidth. The fact that we don't know the actual bitwidth seems like a separate problem. I'm not too sure about this though.

Just a bit confused as how to proceed because I want to pack indextype variables, and in #3581 we decided to combine the fixedbitwidth and structpackable type.

I think @math-fehr mentioned somewhere that even though indextype is not known, it is assured to be <= int64 and thus always packable as a double

[superlopuh]

I propose going from left to right here: https://dreampuf.github.io/GraphvizOnline/?engine=dot#digraph%20G%20%7B%0A%0A%20%20FixedBitwidthType%20-%3E%20PackableType%3B%0A%20%20PackableType%20-%3E%20StructPackable%3B%0A%20%20StructPackable%20-%3E%20IntegerType%3B%0A%20%20StructPackable%20-%3E%20FPType%3B%0A%20%20%0A%20%20_CompileTimeFixedBitwidthType%20-%3E%20_FixedBitwidthType%3B%0A%20%20_CompileTimeFixedBitwidthType%20-%3E%20_PackableType%3B%0A%20%20%0A%20%20_PackableType%20-%3E%20_StructPackable%3B%0A%20%20_StructPackable%20-%3E%20_IntegerType%3B%0A%20%20_StructPackable%20-%3E%20_FPType%3B%0A%20%20_FixedBitwidthType%20-%3E%20_IntegerType%3B%0A%20%20_FixedBitwidthType%20-%3E%20_FPType%3B%0A%20%20_StructPackable%20%20-%3E%20_IndexType%3B%0A%7D

[jorendumoulin]

I propose going from left to right here: ...

Looks good to me, but what is the practical use of the _CompileTimeFixedBitwidthType class? The world seems a bit simpler by just separating Packable and FixedBitwidth, as I personally tend to steer away from boilerplate code without a clear usage. I am fine either way though.

[superlopuh]

Because we need to distinguish between things that can go in DenseArrayBase and DenseIntOrFPElementsAttr, and in general for bitwidth computation of things that reside in memory on the target

[jorendumoulin]

I updated things to your suggestions, let me know what you think!

[superlopuh]

How do you feel about putting an abstract property here?

Maybe actually not packed-dependent name, like compile_time_size?

Suggested change

	class CompileTimeFixedBitwidthType(TypeAttribute, ABC):
	"""
	A type attribute whose runtime bitwidth is fixed, but may be target-dependent.
	"""
	name = "abstract.compile_time_fixed_bitwidth_type"
	class FixedBitwidthType(CompileTimeFixedBitwidthType, ABC):
	class CompileTimeFixedBitwidthType(TypeAttribute, ABC):
	"""
	A type attribute whose runtime bitwidth is fixed, but may be target-dependent.
	"""
	name = "abstract.compile_time_fixed_bitwidth_type"
	@property
	@abstractmethod
	def packed_size(self) -> int:
	"""
	Contiguous memory footprint of packed value in bytes.
	"""
	raise NotImplementedError()
	class FixedBitwidthType(CompileTimeFixedBitwidthType, ABC):

[jorendumoulin]

yep, this makes sense!

[math-fehr]

Yeah, you should always be able to pack an index into an i64, but you don't know its size at compile-time (only when you do target-dependent lowerings)

[superlopuh]

Thank you!