Aufruf mit/ohne Flash. Zwei identische Funktionen nötig?

[Pupsomat (Gast)]

Kann man in avr-gcc aus diesen beiden Funktionen eine machen?

void foo(const char *data) {
  // ...
}

void bar(const __flash char *data) {
  // ...
}

Inhaltlich machen die das gleiche, werden halt nur einmal mit einem im 
Speicher befindlichen String und einmal mit einem aus dem Flash 
aufgerufen... Es erscheint mir unsinnig, zwei Funktionen dafür bereit 
halten zu müssen.

[Markus (Gast)]

Hi,

den Zugriff über den Pointer kannst Du wegkapseln. Dazu brauchst Du 
einen Indicator, der Dir sagt, welchen Zugriff die Kapselung ausführen 
soll. Den Indicator gibst Du von dort rein, wo Du weißt, ob Ram oder 
Flash.

Grüße, Markus

[Stefan E. (sternst)]

Pupsomat schrieb:
> Kann man in avr-gcc aus diesen beiden Funktionen eine machen?

Ja:

void foo_bar (const __memx char *data) {
  // ...
}

[Pupsomat (Gast)]

Ok, das funktioniert. Vergrößert aber das Programm um 200 Bytes...

[Johann L. (gjlayde)]

Pupsomat schrieb:
> Ok, das funktioniert. Vergrößert aber das Programm um 200 Bytes...

__memx verwendet 24-Bit Zeuger anstatt der sonst üblichen 16 Bits. 
Zudem muß bei jedem Zugriff zur Laufzeit getestet werden, ob dieser 
vom Flash oder aus dem RAM lesen soll.

Evtl. ist man dann händisch besser dran:
 

int get_int (const int *p, bool from_flash)
{
    if (from_flash)
        return *(const __flash int*) p;
    else
        return *p;
}

Das testet zwar auch zur Laufzeit, aber vielleicht wird der Code so 
kleiner.  Falls die Funktion nicht allzu groß ist und der Aufrufer weiß, 
von wo er lesen will, kann es lohnen zu inlinen:
 

static inline int
get_int (const int *p, bool from_flash)
{
    if (from_flash)
        return *(const __flash int*) p;
    else
        return *p;
}

extern int a, b, val_b;
extern const __flash int val_a;

void set_ab (void)
{
    a = get_int (&val_a, true);
    b = get_int (&val_b, false);
}

gibt:
 

set_ab:
  ldi r30,lo8(val_a)
  ldi r31,hi8(val_a)
  lpm r24,Z+
  lpm r25,Z+
  sts a+1,r25
  sts a,r24
  lds r24,val_b
  lds r25,val_b+1
  sts b+1,r25
  sts b,r24
  ret

Versucht man das gleiche mit __memx:
 

static inline int
get_int (const __memx int *p)
{
    return *p;
}

void set_ab (void)
{
    a = get_int (&val_a);
    b = get_int (&val_b);
}

dann ist der Code größer; ohne die Bibliotheksfunktion __xload2:
 

set_ab:
  ldi r24,lo8(val_a)
  ldi r25,hi8(val_a)
  ldi r26,0
  movw r30,r24
  mov r21,r26
  call __xload_2
  sts a+1,r23
  sts a,r22
  ldi r24,lo8(val_b)
  ldi r25,hi8(val_b)
  ldi r26,lo8(-128)
  movw r30,r24
  mov r21,r26
  call __xload_2
  sts b+1,r23
  sts b,r22
  ret

Die Möglichkeiten für avr-gcc das zu optimieren sind beschränkt.  Grund 
sind Situationen wie diese:
 

#include <avr/pgmspace.h>

extern void foo_P (const __memx char *);

void hallo (void)
{
    foo_P (PSTR ("Hallo"));
}

Der Zeiger, den PSTR zurückliefert, liegt formal im Generic Address 
Space (RAM), enthält aber eine Flash-Adresse.  Für dieses Beispiel 
erzeugt der Compiler Code wie erwartet, d.h. übergibt an foo_P einen 
24-Bit Zeiger aufs Flash.

Dummerweise ist das, was PSTR macht, nicht auf Embedded-C abbildbar.