Probleme mit -O2

[Fritz G. (fritzg)]

Bin ich doof, oder der Compiler?

Folgender Code:

  beflen = 0;
  pos = 0;
  waitstart = 1;
  ccount = 0;
  parity = 0;
  beftype = 255;
  // 1 heisst warten auf 0 0 Startfolge, erste 0
  // 2 warten auf zweite 0
  // 3 warten auf Befehlstyp, Länge
  do      //mainloop
  {
    while (!(usart_unread_data ()))
    {
      c = usart_getc ();

      if (waitstart != 0)
      {
        if (waitstart == 1)
        {
          if (c == 0)
            waitstart = 2;
        }
        else
        {
          if (waitstart == 2)
          {
            if (c == 0)
            {
              waitstart = 3;
              ccount = 1;
            }
            else
              waitstart = 1;
          }
          else  // muss wohl waitstart 3 sein
          {
            parity += c;
            ccount++;
            switch (ccount)
            {
            case 2:
              beftype = c;
              break;
            case 3:
              shipadr = c << 8;
              break;
            case 4:
              shipadr += c;
              break;
            case 5:
              if ((beftype == 1) || (beftype == 2))
              {
                beflen = c * 2;
                waitstart = 0;
                pos = 0;
              }
            }

            data[beflen] = c;

          }
        }

      }
      else
      {
        data[beflen] = c;
        parity += c;
        if (pos < beflen) ;
      }
    }


  }
  while (1);

Mit -O2 optimiert er alles nach
c = usart_getc ();
weg.
Ersetze ich das
    while (!(usart_unread_data ()))
durch ein if ... dann tut es.

Hier das Assemblerlisting:

406:zentrale.c    ****   beflen = 0;
 407:zentrale.c    ****   pos = 0;
 408:zentrale.c    ****   waitstart = 1;
 409:zentrale.c    ****   ccount = 0;
 410:zentrale.c    ****   parity = 0;
 411:zentrale.c    ****   beftype = 255;
 412:zentrale.c    ****   // 1 heisst warten auf 0 0 Startfolge, erste
0
 413:zentrale.c    ****   // 2 warten auf zweite 0
 414:zentrale.c    ****   // 3 warten auf Befehlstyp, Länge
 415:zentrale.c    ****   do      //mainloop
 416:zentrale.c    ****   {
 417:zentrale.c    ****     while (!(usart_unread_data ()))
 549                 .LM62:
 550                 /*DEBUG: 0x7    2  16 */
 551 012a 0E94 0000     call usart_unread_data
 552                 /*DEBUG: 0x9    2  8 */
 553 012e 8823          tst r24
 554                 /*DEBUG: 0xa    1  24 */
 555 0130 E1F7          brne .L76
 418:zentrale.c    ****     {
 419:zentrale.c    ****       c = usart_getc ();
 557                 .LM63:
 558                 /*DEBUG: 0xb    1  16 */
 559 0132 0E94 0000     call usart_getc
 560                 /*DEBUG: 0xd    2  8 */
 561 0136 F9CF          rjmp .L76
 562                 /* epilogue: frame size=0 */
 563                 /* epilogue: noreturn */
 564                 /* epilogue end (size=0) */
 565                 /* function main size 18 (14) */

Weiss da jemand Rat?

[Fritz G. (fritzg)]

Im Asseblerlistung fehlt oben noch die Zeile

547                 .L76:

und im C File oben:
  do      //mainloop
  {

[Unbekannter (Gast)]

Der Compiler hat immer recht. Offensichtlich ist Dein hier geposteter
Code nicht vollständig.

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

Guck dir vor allem das tatsächliche Assemblerlisting an,
nicht den Disassembler-Krempel.

[Fritz G. (fritzg)]

@Unbekannter:
Der Code ist vollständig genug, glaub mir!

Habs schon gefunden, ein printf() oder sonstwas am Ende reicht, dann
tuts wieder.

War ein typischer Fall von: Schön was er da macht, aber irgendwie
braucht er die Ergebnisse eh nicht, also schmeiss ich alles weg.

[Rufus Τ. F. (rufus)]

Der Code ist mit Sicherheit nicht vollständig genug - wie sind denn
beispielsweise die Variablen deklariert? War da nicht was mit
"volatile" oder so?

[Fritz G. (fritzg)]

Der Rest vom Code:

  uint8_t beflen, pos, waitstart, c, ccount, parity, beftype;
  uint8_t data[256];
  uint16_t shipadr;

Da gibts nix mit volatile, weil da noch keine Variblen mit Interrupt
verändert werden.

In dem Code tut die Art und Größe der Variblen übrigens nichts zur
Sache.

Ich hab mir lediglich das Assemblerlistung zu früh angesehen.