X-Pointer mit Speicheradresse füllen (inline)

[Rita (Gast)]

Hallo,

ich habe eine beliebige Variable z.b. ein unsigned char oder unsigned 
short x und möchte per inline Assembler dessen Adresse in den X-Pointer 
laden.

Nun stehe ich auf dem Schlauch:
Die Adresse ist ein 16Bit Wert, ich kann aber nur XL oder XH mit ldi 
beladen. Muss ich die Adresse meiner Variablen &x noch irgendwie 
bearbeiten? Wie kriege ich den 16Bit wert in den Pointer? :)

Folgendes funktioniert bei mir leider nicht:

asm(
"ldi XH, %[VARH] \n\t"
"ldi XL, %[VARL] \n\t"
:
:[VARH] "i" (&x >> 8), [VARL] "i" (&x &0xFF)
);

Danke euch allen

[Peter D. (peda)]

Am einfachsten wäre es, wenn Du die Aufgabe in einen sinnvollen Kontext 
stellen würdest (komplette Funktion).

Oftmals braucht man den Compiler nicht zu vergewaltigen, er findet 
selber eine Lösung. Man muß ihm nur ein reales Problem zu lösen geben.

[Stefan E. (sternst)]

"ldi XH, hi8(%[VAR]) \n\t"
"ldi XL, lo8(%[VAR]) \n\t"

[Rita (Gast)]

Die Aufgabe ist es, folgende Funktion in Assembler zu übersetzen, weil 
diese Zeitkritisch ist. Es ist die Berechnung einer Audioausgabe nach 
einem Sample (zwei Signale gleichzeitig) zur Audioausgabe:

inline void calcBuffer(WORD * DMA_Buffer){                      //Enen DMA Buffer neu füllen
  for(WORD j = 0; j < DMA_BUFFER_SIZE; j++){                    //Jede Buffer Position füllen
    g_asToene[0].wCounter += g_asToene[0].wStepSize;              //Schrittgröße addieren
    g_asToene[0].cPos += g_asToene[0].wCounter >> 10;              //Geteilt durch 1024 und Vorkommastelle addieren
    g_asToene[0].wCounter &= 0x3FF;                        //Modulo 1024; Rest merken
    g_asToene[1].wCounter += g_asToene[1].wStepSize;
    g_asToene[1].cPos += g_asToene[1].wCounter >> 10;
    g_asToene[1].wCounter &= 0x3FF;
    DMA_Buffer[j] = 
      ((((DWORD)g_awSample[g_asToene[0].cPos]*g_asToene[0].wVol)>>8) + 
      (((DWORD)g_awSample[g_asToene[1].cPos]*g_asToene[1].wVol)>>8));
  }
}

So weit bin ich bis jetzt. Es fehlt jetzt noch folgende Zeile im Code:

DMA_Buffer[j] = 
      ((((DWORD)g_awSample[g_asToene[0].cPos]*g_asToene[0].wVol)>>8) + 
      (((DWORD)g_awSample[g_asToene[1].cPos]*g_asToene[1].wVol)>>8));

WORD wCounter0, wCounter1;
  WORD wStepsize0, wStepsize1;
  BYTE cPos0, cPos1;
  WORD i = DMA_BUFFER_SIZE;
  
  asm (
  /*variablen laden*/
  "lds %A[C0], %[AC0]      \n\t"          //Counter 0 laden
  "lds %B[C0], %[AC0]+1    \n\t"          //..
  "lds %A[C1], %[AC1]      \n\t"          //Counter 1 laden
  "lds %B[C1], %[AC1]+1    \n\t"          //..
  "lds %A[S0], %[AS0]      \n\t"          //Stepsize 0 laden
  "lds %B[S0], %[AS0]+1    \n\t"          //..
  "lds %A[S1], %[AS1]      \n\t"          //Stepsize 1 laden
  "lds %B[S1], %[AS1]+1    \n\t"          //..
  "lds %[P0], %[AP0]      \n\t"          //Position 0 laden
  "lds %[P1], %[AP1]      \n\t"          //Position 1 laden
  
  /*Vorberechnung ausführen*/
  "REPEAT:          \n\t"
  "add %B[C0], %B[S0]      \n\t"          //Stepsize addieren
  "adc %A[C0], %A[S0]      \n\t"          //... hier mit carry
  "mov __tmp_reg__, %A[C0]  \n\t"          //Counter high temporär kopieren
  "andi %A[C0], 0x03      \n\t"          //Module 1024 auf Counter
  "lsr __tmp_reg__      \n\t"          //Kopie /2 (eigentlich durch 1024, aber die unteren 8 Byte sind ja schon gelöscht)
  "lsr __tmp_reg__      \n\t"          //kopie /2 
  "add %[P0], __tmp_reg__    \n\t"          //Addition zur Position
  "add %B[C1], %B[S1]      \n\t"          //Stepsize addieren
  "adc %A[C1], %A[S1]      \n\t"          //... hier mit carry
  "mov __tmp_reg__, %A[C1]  \n\t"          //Counter high temporär kopieren
  "andi %A[C1], 0x03      \n\t"          //Module 1024 auf Counter
  "lsr __tmp_reg__      \n\t"          //Kopie /2 (eigentlich durch 1024, aber die unteren 8 Byte sind ja schon gelöscht)
  "lsr __tmp_reg__      \n\t"          //kopie /2
  "add %[P1], __tmp_reg__    \n\t"          //Addition zur Position
  
  "st X+, __tmp_reg__      \n\t"          //Highbyte speichern
  "st X+, __tmp_reg__      \n\t"          //Lowbyte speichern
  
  "sbiw %[I], 1        \n\t"          //Schelife - 1
  "brne REPEAT        \n\t"
  
  /*variablen speichern*/
  "sts %[AC0],%A[C0]      \n\t"          //Counter 0 speichern
  "sts %[AC0]+1,%B[C0]    \n\t"          //..
  "sts %[AC1],%A[C1]      \n\t"          //Counter 1 speichern
  "sts %[AC1]+1,%B[C1]    \n\t"          //..
  "sts %[AP0],%[P0]      \n\t"          //Position 0 speichern
  "sts %[AP1],%[P1]      \n\t"          //Position 1 speichern
  
  : [C0] "=r" (wCounter0)
    , [C1] "=r" (wCounter1)
    , [S0] "=r" (wStepsize0)
    , [S1] "=r" (wStepsize1)
    , [P0] "=r" (cPos0)
    , [P1] "=r" (cPos1)
    , [I] "=r" (i)
  : [AC0] "i" (&g_asToene[0].wCounter)
    , [AC1] "i" (&g_asToene[1].wCounter)
    , [AS0] "i" (&g_asToene[0].wStepSize)
    , [AS1] "i" (&g_asToene[1].wStepSize)
    , [AP0] "i" (&g_asToene[0].cPos)
    , [AP1] "i" (&g_asToene[1].cPos)
    , [DM] "i" (&g_DmaBuffer2[0])
    , [SAMPLE] "i" (&g_awSample[0])
  : "memory"
  );

[Rita (Gast)]

Danke Stefan! Das scheint zu klappen!