AVR-gcc. Optimierung ignoriert Vergleich mit volatile Variable

Und zusätzlich noch den Zugriff auf bt_rx_wrptr im Main atomar kapseln, 
da 2 Byte!


Peter

Peter Dannegger schrieb:
> Und zusätzlich noch den Zugriff auf bt_rx_wrptr im Main atomar kapseln,
> da 2 Byte!
Und wenn er den Zugriff atomar kapselt, dann braucht er auch das 
volatile nicht mehr, da die entsprechenden Macros aus der util/atomic.h 
schon eine memory barrier enthalten:

1

 __asm__ volatile ("" ::: "memory");

Burkhard schrieb:

> Ist das korrekt ? Oder ist es genau anders herum ?

Weder noch. Ob du
  volatile type * name;
oder
  type volatile * name;
schreibst ist egal. In beiden Fällen ist das worauf der Zeiger zeigt 
volatil. Wenn der Zeiger selbst volatil sein soll, dann heisst es
  type * volatile name;

Das sieht nicht wirklich elegant aus, aber als C nachträglich die 
const/volatile qualifier verpasst bekam war die Syntax nicht mehr zu 
retten.

Burkhard schrieb:

> Ist das korrekt ? Oder ist es genau anders herum ?

const und volatile beziehen sich immer auf das was links von ihnen 
steht. Es sei denn, diese Qualifier sind bereits ganz links, dann 
beziehen sie sich ausnahmsweise auf den Teil des Datentyps rechts von 
ihnen (was aber aufs gleiche rauskommt)

Also:

1

  char volatile i;

  i                    da ist ein i
  volatile i           dieses i ist volatile
  char volatile i      dieses i ist ein volatile char

(Und das ist identisch zu   volatile char i;
 i ist ein char. Und dieser char ist volatile)

1

  char volatile * i;

 i                      es gibt ein i
 * i                    dieses i ist ein Pointer.
 volatile * i           dieser Pointer zeigt auf etwas was volatile ist
 char volatile * i      Nämlich einen char

also ist i ein Pointer der auf einen volatile char zeigt

1

  char * volatile i;

 i                      es gibt ein i
 volatile i             dieses i ist volatile
 * volatile i           dieses i ist ein volatiler Pointer
 char * volatile i      und dieser volatile Pointer zeigt auf einen char
                        (der selbst aber nicht volatile ist)

1

  char volatile * volatile i

 i                             es gibt ein i
 volatile i                    dieses i ist volatile
 * volatile i                  und dieses i ist ein volatile Pointer
 volatile * volatile i         und dieser volatile Pointer zeigt auf 
etwas,
                               was selbst auch volatile ist
 char volatile * volatile i    nämlich einen char

i ist also ein volatiler Pointer, der auf einen volatilen char zeigt.

immer beim Variablennamen anfangen und sich nach aussen durcharbeiten!

Burkhard schrieb:

> Wenn ich Dich also richtig verstehe bezieht sich alles NACH dem '*' auf
> den Pointer selbst und das VOR dem '*' auf das Element, auf welches er
> zeigt ?!

  was ist ein

  int ** volatile * ptr;

:-)

Karl heinz Buchegger schrieb:

>   was ist ein
>   int ** volatile * ptr;

Und was ist (bzw war, anno DOS/Win16) ein

1

    int * far * volatile * ptr;

Burkhard schrieb:
> Da ich aber nur auf Gleichheit
> teste und nicht mit dem Wert rechne, spielt das in diesem Fall (denke
> ich) keine Rolle.

In diesem Fall könnte man es weglassen.
Es müßte grad das 256 Byte eintrudeln, damit eine falsche Gleichheit 
entsteht. Und dann verlierst Du auch nur 50µs bis zum nächsten richtigen 
Vergleich, ist also nicht tragisch.

Allerdings könnte es sich lohnen statt volatile atomic zu nehmen, 
immerhin macht der Interrupt 6 Zugriffe auf diese Variable.
Oder man nimmt eine Tempvariable im Interrupt.


Peter