Compiler Warnung

[Rene Z. (renezimmermann)]

Hallo,

ich will gerade den TCP/IP Stack von Ulrich Radig kompilieren. Dabei 
erhalte ich mehrere Warnungen und weiss nicht so recht was das Problem 
ist.

Für Zeile:

(*((unsigned long*) &myip[0])) = get_eeprom_value(IP_EEPROM_STORE,MYIP);

erhalte ich die Warnung:

dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]

extern unsigned char myip[4];
#define IP(a,b,c,d) ((unsigned long)(d)<<24)+((unsigned long)(c)<<16)+((unsigned long)(b)<<8)+a
#define MYIP    IP(192,168,1,88)
#define IP_EEPROM_STORE 30

unsigned long get_eeprom_value (unsigned int eeprom_adresse,unsigned long default_value)
{
  unsigned char value[4];
  
  for (unsigned char count = 0; count<4;count++)
  {
    eeprom_busy_wait ();  
    value[count] = eeprom_read_byte((unsigned char *)(eeprom_adresse + count));
  }

  //Ist der EEPROM Inhalt leer?
  if ((*((unsigned long*)&value[0])) == 0xFFFFFFFF)
  {
    return(default_value);
  }
  return((*((unsigned long*)&value[0])));
}

Ich verstehe das so:

Die Funktion "get_eeprom_value" holt die IP aus dem EEprom wenn dieser 
nicht leer ist. Ansonsten wird das Default Value zurückgegeben. Der 
Rückgabewert ist vom Typ unsigned long. Diese 4 Bytes sollen an die 
Adresse von myip[0] geschrieben werden. Es erfolgt ein Cast des unsigned 
char Zeigers auf einen unsigned long Zeiger. Mit dem ersten * soll dann 
der Wert dort gespeichert werden.

Aber was möchte mir der Compiler jetzt mitteilen und wie bekomme ich die 
Warnung weg?

Gruß Rene

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

Rene Zimmermann schrieb:
> Aber was möchte mir der Compiler jetzt mitteilen

Dass das wilde hin und her gecaste eines Zeigertyps ziemlicher
Pfusch ist.

> und wie bekomme ich die
> Warnung weg?

Indem man die vier Oktetts sauber einzeln aufbaut und
dann an myip[] zuweist.  Da sie aus dem EEPROM schon byteweise
gelesen werden, kann man natürlich einfach damit weiterarbeiten.
Man muss dann lediglich die vier Bytes einzeln gegen 0xFF vergleichen,
statt daraus fiktiv einen 32-bit-Integer zu fummeln, den man dann
der Faulheit halber gegen 0xFFFFFFFF vergleicht.

Der "unsigned long" darin hat ansonsten keinerlei Bedeutung, da
die vier gelesenen Bytes sowieso nicht zusammenhängend als eine
Zahl betrachtbar sind.  Schließlich stellt sich keiner hin
und sagt "meine IP-Adresse ist die 3232236289", sondern man sagt
stattdessen "meine IP-Adresse ist die 192.168.3.1".

[Rene Z. (renezimmermann)]

Aha, also so.

    //(*((unsigned long*)&myip[0])) = get_eeprom_value(IP_EEPROM_STORE,MYIP);
  
  unsigned long temp = get_eeprom_value(IP_EEPROM_STORE,MYIP);
  myip[0] = (unsigned char) ((temp) >> 24);
  myip[1] = (unsigned char) ((temp) >> 16);
  myip[2] = (unsigned char) ((temp) >> 8);
  myip[3] = (unsigned char) (temp);

Gruß und Danke Rene

[Rene Z. (renezimmermann)]

Und was vergessen:

unsigned long get_eeprom_value (unsigned int eeprom_adresse,unsigned long default_value)
{
  unsigned char value[4];
  
  for (unsigned char count = 0; count<4;count++)
  {
    eeprom_busy_wait ();  
    value[count] = eeprom_read_byte((unsigned char *)(eeprom_adresse + count));
  }

  //Ist der EEPROM Inhalt leer?
  if ((value[0] == 0xFF) && (value[1] == 0xFF) && (value[2] == 0xFF) && (value[3] == 0xFF)){
    return(default_value);
  }
  
  unsigned long temp = value[3];
  temp <<= 8;
  temp |= value[2];
  temp <<= 8;
  temp |= value[1];
  temp <<= 8;
  temp |= value[0];
  return temp;
}

Gruß

[Stefan E. (sternst)]

unsigned long get_eeprom_value (unsigned int eeprom_adresse,unsigned long default_value)
{
  unsigned long value;
  
  value = eeprom_read_dword((unsigned long *)eeprom_adresse);

  //Ist der EEPROM Inhalt leer?
  if (value == 0xFFFFFFFF){
    return default_value;
  }
  
  return value;
}

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

Rene Zimmermann schrieb:
> Aha, also so.
>
>

    //(*((unsigned long*)&myip[0])) =
> get_eeprom_value(IP_EEPROM_STORE,MYIP);
> 
>   unsigned long temp = get_eeprom_value(IP_EEPROM_STORE,MYIP);

Nein.  Schmeiß das ganze "unsigned long"-Geraffel da raus.  Das hat
da nichts zu suchen.

extern unsigned char myip[4];

bool get_eeprom_ipaddr(unsigned int eeprom_adresse, unsigned char *addr)
{
  bool is_valid = true;

  for (unsigned char count = 0; count<4;count++)
  {
    eeprom_busy_wait ();
    unsigned char b = eeprom_read_byte((unsigned char *)(eeprom_adresse + count));
    if (is_valid && b == 0xff)
      is_valid = false;
    addr[count] = b;
  }

  return is_valid;
}

...
  if (!get_eeprom_ipaddr(IP_EEPROM_STORE, myip))
  {
    myip[0] = 192;
    myip[1] = 168;
    myip[2] = 1;
    myip[3] = 188;
  }

(Das mit der Default-Adresse kann man noch schöner schreiben, mir
ging's ums Prinzip mit dem get_eeprom_value().)

[Rufus Τ. F. (rufus)]

  for (unsigned char count = 0; count<4;count++)
  {
    eeprom_busy_wait ();
    unsigned char b = eeprom_read_byte((unsigned char *)(eeprom_adresse + count));
    if (is_valid && b == 0xff)
      is_valid = false;
    addr[count] = b;
  }

Das ist aber problematisch, wenn eine IP-Adresse eine 255 enthält, was 
sie durchaus darf.
Einerseits, wenn diese "IP-Adresse" genutzt wird, um eine Subnet Mask zu 
speichern, andererseits aber auch direkt; 192.168.255.1 ist eine völlig 
legale Adresse.

[Johann L. (gjlayde)]

Wenn es nur darum geht, das Zeug irgendwie ohne Warnungen zu übersetzen 
und zum Laufen zu bekommen, geht -fno-strict-aliasing.

Das bedeutet dann, daß jeder Typ jeden anderen aliasen kann — entgegen 
den Aliasing-Regeln des C-Standards.

Damit muss man dann nicht (fremde) Quellen debuggen und von Hacks 
(zumindest nicht von diesem) säubern.

[Yalu X. (yalu) (Moderator)]

Hier ist ein guter Artikel zu dem Thema:

  http://cellperformance.beyond3d.com/articles/2006/06/understanding-strict-aliasing.html

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

Rufus Τ. Firefly schrieb:
> Das ist aber problematisch, wenn eine IP-Adresse eine 255 enthält, was
> sie durchaus darf.

Hast natürlich recht, die Logik muss man ändern.

  uint8_t ff_seen = 0;

  ...
    if (b == 0xff) ff_seen++;

  ...
  return ff_seen < 4;

[Karl H. (kbuchegg)]

Jörg Wunsch schrieb:
> Rufus Τ. Firefly schrieb:
>> Das ist aber problematisch, wenn eine IP-Adresse eine 255 enthält, was
>> sie durchaus darf.
>
> Hast natürlich recht, die Logik muss man ändern.
>
>

>   uint8_t ff_seen = 0;
> 
>   ...
>     if (b == 0xff) ff_seen++;
> 
>   ...
>   return ff_seen < 4;
>

Entweder so, oder ganz einfach den Spiess umdrehen:
Sobald was anderes als 0xFF kommt, ist die IP gültig

bool get_eeprom_ipaddr(unsigned int eeprom_adresse, unsigned char *addr)
{
  bool is_valid = false;

  for (unsigned char count = 0; count<4;count++)
  {
    eeprom_busy_wait ();
    unsigned char b = eeprom_read_byte((unsigned char *)(eeprom_adresse + count));
    if (b != 0xff)
      is_valid = true;
    addr[count] = b;
  }

  return is_valid;
}

[Johann L. (gjlayde)]

Warum denn nicht ein eeprom_read_dword?