Frage Bitoperation

[Noob (Gast)]

Hallo liebe Leute,

habe eine Frage, wo ich nicht so recht weiterkomme. Es sind zwei uint8_t 
Variablen vorhanden, nennen wir var_new und var_old. Nun will ich ein 
bestimmtes Bit (sagen wir Bit 0) von var_new nach var_old kopieren.

Aktueller Versuch sieht so aus:

var_old |= var_new&(1<<0);

Nur ist die Operation allerdings falsch, da es schlichtweg nicht 
funktioniert. Ich behelfe mir aktuell mit einer einfache if-Abfrage

if (var_new&(1<<0))
   { var_old |= (1<<0);}
else 
   { var_old &= ~(1<<0);}

Aber das muss doch irgendwie in einem Schritt gehen! Wahrscheinlich sehe 
ich den Wald vor lauter Bäume nicht...

[Daniel A. (daniel-a)]

var_old = (var_new & (1<<0)) | (var_old & ~(1<<0));

[asdfasd (Gast)]

var_old ^= (var_old ^ var_new) & (1<<0);

[c-hater (Gast)]

Noob schrieb:

> Aber das muss doch irgendwie in einem Schritt gehen!

Nein. Auch wenn du einen komplexen Ausdruck in C in einer Zeile 
schreiben kannst, werden es dadurch nicht weniger "Schritte". Die 
if-Konstruktion ist schon garnicht schlecht, der Compiler kann die recht 
gut optimieren.

Wenn du die unbedingt in eine Zeile quetschen willst, wazu auch immer 
das gut sein soll, kannst du sie ja auch so schreiben:

(var_new&(1<<0))? var_old |= (1<<0): var_old &= ~(1<<0);

Auf'm AVR8 kommt dann vermutlich sowas raus:

sbrc reg_new,0
ori reg_old,1
sbrs reg_new,0
andi reg_old,~1

was mit vier Takten schon nicht schlecht ist. Vielleicht schafft der 
Compiler aber sogar das Optimimum

bst reg_new,0
bld reg_old,0

Aber auch das sind immer noch ZWEI Schritte, also zwei Takte. In einem 
Schritt ist das Problem schlicht nicht lösbar. Jedenfalls nicht auf 
einem AVR8.

Bei den anderen Vorschlägen im Thread wird mit einiger 
Wahrscheinlichkeit etwas herauskommen, was weniger effizienten Code 
erzeugt. Irgendwas in der Art:

andi reg_old,~1
andi reg_new,1
or reg_old,reg_new

Merke: Was du in C hinschreibst, interessiert den Gasmann. Wichtig ist 
letztlich, was der Compiler draus macht. Auf C-Ebene sollte es vor allem 
eins sein: gut lesbar. Und dafür ist es NICHT hilfreich, soviel wie 
möglich in eine Zeile zu quetschen. Und davon wird der erzeugte Code 
typischerweise auch weder schneller noch kleiner. Also: kompletter 
Unsinn, hier zu "optimieren".

[Leo C. (rapid)]

Auf AVR (avr-gcc 5.4.0) liefert die Variante
Daniel A. schrieb:
> var_old = (var_new & (1<<0)) | (var_old & ~(1<<0));

diesen Assembler-Code:

bc_andor:
  lds r25,var_new
  lds r24,var_old
  bst r25,0
  bld r24,0
  sts var_old,r24
  ret

Andere Varianten schneiden schlechter ab.

[Wilhelm M. (wimalopaan)]

Diese Optimierung zu bst/bld wird aber auch nur für Bit 0 gemacht ...

zumindest bei avr-g++ 7.2.0 und 8.0.0

[Noch einer (Gast)]

> Aber das muss doch irgendwie in einem Schritt gehen!

Da haben wohl die Konstrukteure des ENIAC eine falsche Entscheidung 
getroffen. Und danach hat 80 Jahre lang kein Prozessorentwickler mehr 
darüber nachgedacht.

[Jim M. (turboj)]

Noch einer schrieb:
> Und danach hat 80 Jahre lang kein Prozessorentwickler mehr
> darüber nachgedacht.

Falsch. Intel hat in den 80gern beim 8051 µC Bit-addressierbaren 
Speicher vorgesehen.

Bei Cortex-M3 könnte man was ähnlich über Bitband Addressen tricksen, 
aber da findet dann ein read-modify-write Zyklus innerhalb des 
Prozessors statt.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

c-hater schrieb:
> Wenn du die unbedingt in eine Zeile quetschen willst, wazu auch immer
> das gut sein soll, kannst du sie ja auch so schreiben:
Da fehlen noch Klammern:
http://codepad.org/t3NSZth8

Noob schrieb:
> Aktueller Versuch sieht so aus:
> var_old |= var_new&(1<<0);
> Nur ist die Operation allerdings falsch, da es schlichtweg nicht
> funktioniert.
Oh doch, aber funktioniert nur zur Hälfte.
Also nur, wenn ein Bit zu setzen ist. Denn nur das kann das '|' 
bewirken.

Du müsstest also noch eine zweite Zeile hinzufügen, die das Bit vorher 
löscht:

    var_old &= ~(1<<0);         // erst löschen
    var_old |= var_new&(1<<0);  // ggfs wieder setzen

http://codepad.org/Y8hbvebb

[Wilhelm M. (wimalopaan)]

Anbei ein Testprogramm, um es mit avr-g++ und allen Bits 0...7 und 
Algorithmen zu testen. Es fällt auf, dass die beste Optimierung nur bei 
Bit 0 gemacht wird.

Mir ist nicht klar warum?

[Noob (Gast)]

Wow, danke euch für die echt lehrreiche Gesprächsrunde :)