Forcing Ada to use minimum spec size for enumerated types with gnat 4.4 - size

Question

I have an enumerated type that needs to be 4 bits but when I declare a variable of that type the compiler assigns that variable 8 bits.
Below is a simplified version of the code.
subtype ab_range_index is word range 0..3;
type ab_buffer_type is array(ab_range_index) of bit;
type Buffer is record
...
var1 : some_buffer_type;
Orig_AB_var : ab_buffer_type;
...
end record;
for Buffer use record
...
var1 at 16 range 0..5;
Orig_AB_var at 16 range 6..9;
...
end record;
...
type AB_type is (A,B);
for AB_type use (A => 0, B => 5);
for AB_type'Size use 4;
...
procedure Proc(AB_buff : ab_buffer_type) is
AB_var : AB_type; -- AB_var'Size returns 8 in debugger.
for AB_var use at AB_buff'Address;
begin
data_valid = AB_var'valid; -- returns false since the variable
-- contains extra bits
...
This all worked under previous gnat versions but not under gnat 4.4.6. I understand that gnat is in compliance with the Ada spec.
Is there a way to force the compiler to make the AB_var in the above example to be 4 bits?
I've tried 'Object_Size but it needs to be a multiple of 8 bits.

Answer 1

I don't know of any modern computer hardware that can allocate just 4 bits for a variable. The minimum would be an 8-bit byte.
And no offense, but I'm skeptical that any previous version of GNAT would have been able to do it either.
Now within a record that has an associated rep spec or suitable convention pragma, an individual field of type AB_Type could be allocated just 4 bits.
But not as a discrete variable.

Answer 2

Add Pragma Pack( [type_name] ); to the types, especially to the record. I recently had a case where even a record-specification clause would not work unless pack was attached to the type. (The aspect form can be used as well.)

Answer 3

There's almost always something to be said for posting a compilable reproducer. I'm not sure what your code is really like, but this works just fine with GCC 4.8.0:
with Ada.Text_IO; use Ada.Text_IO;
procedure Small_Parameter_Conversion is
type M_N_Type is (M, N);
for M_N_Type use (M => 0, N => 5);
for M_N_Type'Size use 4;
type Fill is array (Positive range <>) of Boolean;
for Fill'Component_Size use 1;
type Import is record
M_N : M_N_Type;
Filler : Fill (1 .. 4);
end record;
for Import use record
M_N at 0 range 0 .. 3;
Filler at 0 range 4 .. 7;
end record;
type A_B_Type is (A, B);
for A_B_Type use (A => 0, B => 5);
for A_B_Type'Size use 4;
procedure Proc (Input : M_N_Type) is
A_B : A_B_Type;
for A_B'Address use Input'Address;
begin
if not A_B'Valid then
Put_Line ("invalid.");
else
Put_Line (A_B'Img);
end if;
end Proc;
V : Import;
begin
V := (M_N => M, Filler => (others => True));
Proc (V.M_N);
V := (M_N => N, Filler => (others => True));
Proc (V.M_N);
end Small_Parameter_Conversion;
That said, Unchecked_Conversion is the better way to go. The last paragraph but two of the GNAT Reference Manual section on Address Clauses points out that using overlays is implementation-dependent (though I couldn't find where it says this in the RM).
One possible route to error would be if M_N_Type was in fact defined as
type M_N_Type is (M, N, O);
for M_N_Type use (M => 0, N => 5, O => 6);
and Proc is called as
V := (M_N => O, Filler => (others => True));
Proc (V.M_N);
Then, sure enough, it prints invalid..