Große bitfelder

[Leif U. (boing)]

Hallo,

Ich verwende den AVR-GCC Compiler programiere für für einen ATMega128.

Ich habe einen 160 Bit Integer den ich beim Lesen gern bitweise 
"durchlaufen" würde.
Das Schreiben dieser Zahl würde ich gern byteweise erledingen.
Ich habe ein wenig das Forum durchsucht und meine bisherige 
(funktionierende) Löung sieht folgendermssen aus:

/* ********************* Code ******************* */
union thek {
  uint8_t byte;
  struct {
    uint8_t b0: 1;
    uint8_t b1: 1;
    uint8_t b2: 1;
    uint8_t b3: 1;
    uint8_t b4: 1;
    uint8_t b5: 1;
    uint8_t b6: 1;
    uint8_t b7: 1;
  } bits;
};

union thek k[20];
/* ********************* Code ******************* */

Was mich an dieser Lösung stört ist, daß man nicht wirkich jedes Bit 
einzeln indexieren kann. Das dürfte allerdings auch schwer Möglich sein, 
da in meinem Fall die kleinste adressierbare Einheit ein byte ist.
Oder gibt's da einen Zaubertrick?

Bedenken, was dies Lösung mit dem Union und dem Struct angeht habe auch. 
Korrigiert mich bitte wenn ich falsch liege..
1) Der Compiler garantier nicht daß, das was ich (beispielsweise) in
k[0].byte schreibe auch in k[0].bits... wiederfinde
2) Der Compiler garantiert  das bits b0 .. b7 aus dem Struct in einem 
byte gespeichert werden, aber nicht in welcher reihenfolge.
Z.B.: k[0].byte = 0x01; setzt das niederwertigste bit auf Null. In dem 
Struct kann das niederwertigste bit aber auch b5 sein, je nach dem wie 
der Compiler die Zuordnung macht.

Wie Eingangs erwähnt (zumindes im Simulator) funktioniert's ohne 
Probleme. Aber die Spezifikation verbietet es.
Wie kann man es anders machen ohne speicher zu verscwenden und jedes bit 
einzeln zu maskieren?



Cheers,
Leif

[Jörg W. (dl8dtl) (Moderator)]

Leif U. wrote:

> ... Das dürfte allerdings auch schwer Möglich sein,
> da in meinem Fall die kleinste adressierbare Einheit ein byte ist.

Richtig.

> 1) Der Compiler garantier nicht daß, das was ich (beispielsweise) in
> k[0].byte schreibe auch in k[0].bits... wiederfinde

Doch.  Er garantiert dir aber nicht, wenn du eine 1 in k[0].byte
schreibst, ob du danach k[0].bits.b0 oder k[0].bits.b7 dadurch
gesetzt hast.  Allerdings ist es "implementation-defined", d. h.
er sollte es immer gleich machen, nicht heute so und morgen so.

> 2) Der Compiler garantiert  das bits b0 .. b7 aus dem Struct in einem
> byte gespeichert werden, aber nicht in welcher reihenfolge.

Doch, die Aufeinanderfolge der Bits ist garantiert, nur nicht die
Richtung, in der die Bits gezählt werden.

> Wie kann man es anders machen ohne speicher zu verscwenden und jedes bit
> einzeln zu maskieren?

Ich wuerde mir Zugriffsmakros fuer die bitweise Adressierung
schreiben, etwa so:

#define GETBIT(ary, bitno) \
  (((ary)[(bitno) / 8] & (1 << (bitno) % 8)) != 0)