Subtraktion von Float Inlineprogrammierung

[Christian M. (feaser)]

Hallo,

ich versuche verzweifelt eine Floatzahl von einer anderen zu 
subtrahieren.
Ich arbeite mit einem Atmega2561 und in C bzw. mit Assember inline.

float asmsub(float x,float y){ // x - y
  
   asm ("FSUB  %[x], %[y]"   "\n\t"

                : [x] "+a" (x) 
                : [y] "a"  (y) 
         );
}

Da bekomme ich folgende Fehlermeldung:

Error  11  can't find a register in class 'SIMPLE_LD_REGS' while 
reloading 'asm'

Error  12  'asm' operand has impossible constraints



Unter http://www.mikrocontroller.net/articles/AVR_Arithmetik/Saturierung 
der letzte Quellcode ist genau das, was ich machen will. Aber ich weiß 
nicht wie ich es übersetzen soll.

Hier kommt bei

asm ("subi R16, 0x80  "   "\n\t"

die gleiche Fehlermeldung wie oben.

Kann mir jmd helfen?
Vielen Dank im Voraus.

[Jörg G. (joergderxte)]

Schau dir den asm-Code an, den der Compiler da für generiert:

float fsub_sat(float a, float b, float min)
{
    float tmp  = a-b;
    if(tmp > min)
        return tmp;
    return min;
}

Und denk noch mal scharf nach, ob du wirklich floats brauchst (oder 
inline-asm)

hth, Jörg

ps.: der gcc-inline-assembler ist kompliziert
pps.: der AVR hat keine float-Befehle

[Klaus W. (mfgkw)]

... und schon gar kein FSUB
Ein FMUL gibt es, aber das ist auch nicht für float.

[Karl H. (kbuchegg)]

Es erhebt sich ausserdem die Frage, was du dir davon versprichst, wenn 
du

   float a = b - c;

in Assembler ausformulierst. Schneller als der Compiler kriegst du das 
auch nicht hin.

[Christian M. (feaser)]

Danke für die Antworten. Ich wollte nur ein Stück Quelltext als 
Assembler programmieren, nur zu Demonstrationszecken.

Also heißt das, sowas zu programmieren würde viel Arbeit kosten?

[holger (Gast)]

>Ich wollte nur ein Stück Quelltext als
>Assembler programmieren, nur zu Demonstrationszecken.
>Also heißt das, sowas zu programmieren würde viel Arbeit kosten?

Nein.

#define NOP   asm volatile ("nop" ::)

SCNR;)

[Johann L. (gjlayde)]

Ja. float-Arithmetik in Software zu Klöppeln ist aufwändig.

Wozu brauchst du denn überhaupt Constraint "a"?

Als Workaround, wenn du wirklich diese Constraint für float brauchst 
(Wahrscheinlichkeit = 0%), geht das:

float asmsub (float x, float y)
{
   register float rx asm ("r16") = x;
   register float ry asm ("r20") = y;

   asm ("FSUB %[x], %[y]"
                : [x] "+a" (rx)
                : [y] "a"  (ry)
        );

   return rx;
}

[Rolf Magnus (Gast)]

Christian Micro schrieb:
> Also heißt das, sowas zu programmieren würde viel Arbeit kosten?

Ja. Da die AVRs keinen Gleitkomma-Koprozessor besitzen, kennen sie keine 
entsprechenden Befehle. Du mußt die Gleitkomma-Unterstützung dann in 
deinem Assembler-Code selbst "von Hand" machen, und das ist aufwendig.