Warum übersetzt GCC-Compiler so unterschiedlich?

[Maxim B. (max182)]

Guten Tag,
ich habe eine Frage:

Ich kenne C bestimmt noch nicht genug tief, aber ich habe geglaubt, daß 
diese zwei Zeilen äquivalent sind:

if(freq_zaehler & (1<<15)) phase_index |= (1<<0);

und

if(freq_zaehler & 0x00008000) phase_index |= (1<<0);

Trotzdem bekomme ich unterschiedliches Assembler-Ergebnis:

    if(freq_zaehler & (1<<15)) phase_index |= (1<<0);
 lds  r20, 0x04C6  ; 0x8004c6 <freq_zaehler>
 lds  r21, 0x04C7  ; 0x8004c7 <freq_zaehler+0x1>
 lds  r22, 0x04C8  ; 0x8004c8 <freq_zaehler+0x2>
 lds  r23, 0x04C9  ; 0x8004c9 <freq_zaehler+0x3>
 eor  r20, r20
 andi  r21, 0x80  ; 128
 or  r20, r21
 or  r20, r22
 or  r20, r23
 breq  .+2        
 ori  r24, 0x01

und

    if(freq_zaehler & 0x00008000) phase_index |= (1<<0);
 lds  r20, 0x04C6  ; 0x8004c6 <freq_zaehler>
 lds  r21, 0x04C7  ; 0x8004c7 <freq_zaehler+0x1>
 lds  r22, 0x04C8  ; 0x8004c8 <freq_zaehler+0x2>
 lds  r23, 0x04C9  ; 0x8004c9 <freq_zaehler+0x3>
 sbrc  r21, 7
 ori  r24, 0x01

Woran liegt das?
freq_zaehler ist unsigned long, phase_index ist unsigned int,
Atmel AVR 8-bit GNU Toolchain 3.6.0.1734 (avr-gcc-5.4.0.exe), AVR Studio 
4.19

Vielen Dank im voraus für eine Erklärung.

[Jim M. (turboj)]

Maxim B. schrieb:
> if(freq_zaehler & (1<<15)) phase_index |= (1<<0);

Vorsicht: Du schiebst hier die "1" ins Vorzeichenbit eines int. Das ist 
IIRC laut Standard undefiniertes Verhalten, Du wolltest hier eher sowas 
wie (1UL<<15) schreiben.

[Dr. Sommer (Gast)]

Maxim B. schrieb:
> 0x00008000
Das ist ein long (32bit)

(1<<15) ist ein int.

Optimierungen sind eingeschaltet?

[Patrick R. (ohmann)]

Maxim B. schrieb:
> Ich kenne C bestimmt noch nicht genug tief, aber ich habe geglaubt, daß
> diese zwei Zeilen äquivalent sind:if(freq_zaehler & (1<<15)) phase_index
> |= (1<<0);undif(freq_zaehler & 0x00008000) phase_index |= (1<<0);
> Trotzdem bekomme ich unterschiedliches Assembler-Ergebnis

Inhaltlich mögen die beiden Ausdrücke letztlich das gleiche Resultat 
bewirken, dennoch sind es ja verschiedene Ausdrücke und haben demnach 
einen verschiedenen Assembleroutput.

[Maxim B. (max182)]

Dr. Sommer schrieb:
> Optimierungen sind eingeschaltet?

Selbstverständlich.

Aber nun kapiere ich: alles, was nicht anders definiert ist, betrachtet 
Compieler als int. Das habe ich vergessen.
Vielen Dank!

aber auch so wird nicht besser, komischerweise:

    if(freq_zaehler & ((unsigned long)(1<<15))) phase_index |= (1<<0);
 lds  r20, 0x04C6  ; 0x8004c6 <freq_zaehler>
 lds  r21, 0x04C7  ; 0x8004c7 <freq_zaehler+0x1>
 lds  r22, 0x04C8  ; 0x8004c8 <freq_zaehler+0x2>
 lds  r23, 0x04C9  ; 0x8004c9 <freq_zaehler+0x3>
 eor  r20, r20
 andi  r21, 0x80  ; 128
 or  r20, r21
 or  r20, r22
 or  r20, r23
 breq  .+2      
 ori  r24, 0x01

[Steffen R. (steffen_rose)]

Maxim B. schrieb:
> (unsigned long)(1<<15)

Du shifftest noch immer den int und erweiterst das unsichere Ergebnis 
auf long.

Jim M. schrieb:
> Du wolltest hier eher sowas
> wie (1UL<<15) schreiben.

[Maxim B. (max182)]

Bisher hatte ich immer gleiche Ergebnis mit Varianten

#define bb 4
#define cc 3
a |= (1<<bb)|(1<<cc);

und

a |= 0x18;

Interessant... Nun weiß ich ein bißchen mehr über C.

[Maxim B. (max182)]

Jim M. schrieb:
> Du wolltest hier eher sowas
> wie (1UL<<15) schreiben.

Stimmt!

if(freq_zaehler & (1UL<<15)) phase_index |= (1<<0);
 lds  r20, 0x04C6  ; 0x8004c6 <freq_zaehler>
 lds  r21, 0x04C7  ; 0x8004c7 <freq_zaehler+0x1>
 lds  r22, 0x04C8  ; 0x8004c8 <freq_zaehler+0x2>
 lds  r23, 0x04C9  ; 0x8004c9 <freq_zaehler+0x3>
 sbrc  r21, 7
 ori  r24, 0x01

Nun alles wie erwünscht!
Vielen Dank!

[Dr. Sommer (Gast)]

Es ist sowieso deutlich besser es so zu machen:

static const uint32_t amask = (1UL << 4);
static const uint32_t bmask = (1UL << 3);
a |= (amask | bmask);

Man beachte dass der Typ von amask/bmask fix uint32_t ist; es kann hier 
keine Überraschungen geben. Noch besser ist:

static const uint32_t amask = (((uint32_t) 1) << 4);
static const uint32_t bmask = (((uint32_t) 1) << 3);

So hat der Integer immer die richtige Größe, und man muss nicht 
überlegen ob es jetzt ein (unsigned) int oder long sein muss. Portabel 
ist es so auch.

[Yalu X. (yalu) (Moderator)]

Der Ausdruck 1<<15 ist, wie von Jim bereits angemerkt, undefiniert. Der
GCC liefert dafür naheliegenderweise den signed-int-Wert 0x8000 = -32768
(was aber nicht garantiert ist). -32768 auf (unsigned) long erweitert
hat das Bitmuster 0xffff8000. Die if-Bedingung wird also immer dann
wahr, wenn in freq_zaehler mindestens eins der Bits 15 bis 31 gesetzt
ist. Das ist natürlich nicht das, was du erwartet hast.

[Maxim B. (max182)]

Vielen Dank für Ihre ausführliche Erklärungen!

Das ist ein Versuch, DDS mit einer 12 bit 480 Wort-Tabelle zu 
realisieren (480 kann man leicher als 512 auf 2,3,4,5,8,10,12,16 
dividieren, das macht Berechnungen für Tabelle leichter). Ich wollte 
wissen, ob das alles zeitlich mit akzeptabler Frequenz(z.B. 40 kHz) 
machbar ist. MK sollte noch ja etwas Zeit haben, um Befehle von außen zu 
nehmen.

Deshalb überprüfe ich das mit Simulator, um später keine bösen 
Überraschungen zu bekommen. Immerhin gibt es genug anderen 
Fehlerquellen.

Variablen für Frequenz werde ich als __uint24 benutzen, die können aber 
in Simulator nicht in Watch-Fenster gesehen werden, deshalb zuerst 
unsigned long.

Wahrscheinlich sollte ich für die Zukunft die Ausdrücke wie x & (1<<nn) 
nur für Register und Ports benutzen. Alles anderes mit direkten 
Konstanten.

[tictactoe (Gast)]

Weil klugsch... soviel Spass macht:

Yalu X. schrieb:
> Der Ausdruck 1<<15 ist, wie von Jim bereits angemerkt, undefiniert.

C++14 erklärt von allen zuvor undefinierten Fällen genau diesen als 
definiert (den, bei dem 1 in das Vorzeichenbit geschoben wird).

[mh (Gast)]

tictactoe schrieb:
> Weil klugsch... soviel Spass macht:
>
> Yalu X. schrieb:
>> Der Ausdruck 1<<15 ist, wie von Jim bereits angemerkt, undefiniert.
>
> C++14 erklärt von allen zuvor undefinierten Fällen genau diesen als
> definiert (den, bei dem 1 in das Vorzeichenbit geschoben wird).

Vielen dank fürs klugsch... (ernsthaft)! Kannst du angeben wo genau es 
im Standard definiert wird (bin zu faul zum Suchen ;-) )

[Kaj (Gast)]

tictactoe schrieb:
> C++14 erklärt
Hier geht es aber nicht um C++ sondernm laut TO, um C

[tictactoe (Gast)]

mh schrieb:
> tictactoe schrieb:
>> Weil klugsch... soviel Spass macht:
>>
>> Yalu X. schrieb:
>>> Der Ausdruck 1<<15 ist, wie von Jim bereits angemerkt, undefiniert.
>>
>> C++14 erklärt von allen zuvor undefinierten Fällen genau diesen als
>> definiert (den, bei dem 1 in das Vorzeichenbit geschoben wird).
>
> Vielen dank fürs klugsch... (ernsthaft)! Kannst du angeben wo genau es
> im Standard definiert wird (bin zu faul zum Suchen ;-) )

Hier: http://www.eel.is/c++draft/expr.shift#2.sentence-3 (aka 8.5.7p2) 
oder auch hier: 
http://en.cppreference.com/w/cpp/language/operator_arithmetic Abschnitt 
Bitwise shift operators.

[Maxim B. (max182)]

tictactoe schrieb:
> Hier: http://www.eel.is/c++draft/expr.shift#2.sentence-3 (aka 8.5.7p2)
> oder auch hier:
> http://en.cppreference.com/w/cpp/language/operator_arithmetic Abschnitt
> Bitwise shift operators.

Das ist aber kein C, sondern CPP.

Übrigens, ich habe nun Header für STM32 angekuckt: dort kann man 
Ausdruck (1UL<<n) treffen.