Bug im avr-gcc bei Behandlung von SFRs als Bitfields?

von Frank M. (ukw) (Moderator)

01.08.2014 01:06

Lesenswert?

•

Hallo zusammen,

Ich behandele gerade im Thread

  Beitrag "AVR-Register als Bitfields"

die "registersichere" Manipulation von Bits bzw. Bitfeldern in 
AVR-µC-Registern.

Registersicher heißt, dass automatisch vom Compiler verhindert wird, 
wenn man versucht, ein Bit, was nicht zum verwendeten Register gehört, 
in diesem zu setzen bzw. zu löschen.

Beispiel für so einen Fehler:

  TCCR0A |= (1<<COM2A0) | (1<<COM2A1)

Hier werden also Bits, die zum Timer2 gehören, in dem Register gesetzt, 
welches zu Timer0 gehört.

Mittels Makros, Structs und Unions die ab

  Beitrag "Re: AVR-Register als Bitfields"

behandelt werden, wird dieses verhindert, denn man kann dann einfach 
schreiben:

  BFM_COM0A = 0b11;

oder auch für die Einzel-Bits COM0A0 und COM0A1:

  BFM_COM0A0 = 1;

bzw.

  BFM_COM0A1 = 0;

Die Makros sorgen dafür, dass immer das korrekte Register verwendet wird 
und der Assembler-Output absolut gleich zur "klassischen" Variante 
mittels Shift-Operator ist.

Dabei ist mir aufgefallen, dass der avr-gcc einen kleinen Bug hat, der 
den Code in einem speziellen Fall ineffizient macht, nämlich bei den 
Operatoren | und &.

Ich versuche mal, dieses hier in Kürze zusammenzufassen:

   BFM_COM0A |= 0b11;

wird übersetzt mit:

   BFM_COM0A |= 0b11;
  5a:  84 b5         in  r24, 0x24  ; 36
  5c:  84 b5         in  r24, 0x24  ; 36
  5e:  80 6c         ori  r24, 0xC0  ; 192
  60:  84 bd         out  0x24, r24  ; 36

Hier wird der in-Befehl vom TCCR0A-Register überflüssigerweise 2x 
gemacht.

Ein wesentlich umständlicher erscheinendes Makro

   BF_OR(BFM_COM0A, 0b11);

jedoch erzeugt den optimalen Code.

   BF_OR(BFM_COM0A, 0b11);
  66:  84 b5         in  r24, 0x24  ; 36
  68:  80 6c         ori  r24, 0xC0  ; 192
  6a:  84 bd         out  0x24, r24  ; 36

Dasselbe gilt für

   BFM_COM0A &= ~0b11;

versus

   BF_AND(BFM_COM0A, ~0b11);

Hier der für ATmega88 o.ä. vollständig compilierbare Code:

#include <stdint.h>
#include <avr/io.h>
#include <util/delay.h>
struct TCCR0A_bits
    uint8_t wgm00:1;
    uint8_t wgm01:1;
    uint8_t :1;
    uint8_t :1;
    uint8_t com0b0:1;
    uint8_t com0b1:1;
    uint8_t com0a0:1;
    uint8_t com0a1:1;
} __attribute__((__packed__));
struct TCCR0A_grouped_bits
    uint8_t wgm0:2;     // WGM00 und WGM01
    uint8_t :2;
    uint8_t com0b:2;    // COM0B0 und COM0B1
    uint8_t com0a:2;    // COM0A0 und COM0A1
} __attribute__((__packed__));
union TCCR0A_union
   struct TCCR0A_bits           b;
   struct TCCR0A_grouped_bits   g;
   uint8_t                      v;
#define BF_TCCR0A               (*(volatile union TCCR0A_union *)&TCCR0A)
#define BFM_WGM0                BF_TCCR0A.g.wgm0
#define BFM_WGM00               BF_TCCR0A.b.wgm00
#define BFM_WGM01               BF_TCCR0A.b.wgm01
#define BFM_COM0B               BF_TCCR0A.g.com0b
#define BFM_COM0B0              BF_TCCR0A.b.com0b0
#define BFM_COM0B1              BF_TCCR0A.b.com0b1
#define BFM_COM0A               BF_TCCR0A.g.com0a
#define BFM_COM0A0              BF_TCCR0A.b.com0a0
#define BFM_COM0A1              BF_TCCR0A.b.com0a1
#define BFM_COM0A_R             TCCR0A
#define BFM_COM0A_U             union TCCR0A_union
#define BFM_COM0A_M             g.com0a
#define BFM_COM0A0_R            TCCR0A
#define BFM_COM0A0_U            union TCCR0A_union
#define BFM_COM0A0_M            b.com0a0
#define BFM_COM0A1_R            TCCR0A
#define BFM_COM0A1_U            union TCCR0A_union
#define BFM_COM0A1_M            b.com0a1
#define BF_SET(rbf, b)          rbf = (b);
#define BF_OR(rbf, b)           do { rbf##_U _x; _x.v = 0; _x.rbf##_M = (b); rbf##_R |= _x.v; } while(0)
#define BF_AND(rbf, b)          do { rbf##_U _x; _x.v = 0xFF; _x.rbf##_M = (b); rbf##_R &= _x.v; } while(0)
int main ()
    BFM_COM0A |= 0b11;          // erzeugt überflüssigen in-Befehl
    BF_OR(BFM_COM0A, 0b11);     // effizienter
    BFM_COM0A &= ~0b11;
    BF_AND(BFM_COM0A, ~0b11);


Bitte nicht erschrecken, ich habe die defines aus dem automatisch 
erzeugten bf_atmeg88a.h hier einfach mal reinkopiert, um es einfach 
übersetzbar zu halten.

Erzeugter Output ab main: