expected an asm string

[andi (Gast)]

moin,

msp430, ok C wissen, kleines bis keines assembler wissen.

  int s_s_ctr;
  reg_buff = 0x0000;
  for (s_s_ctr = 0; s_s_ctr < CPU_REGISTERS; s_s_ctr++)
  {
    sprintf (buff1, "mov.w r");
    sprintf (buff2, "%d, reg_buff\n", s_s_ctr);
    strcat  (buff1, buff2);
    asm    (buff1);              
    stack[stack_nr].reg[s_s_ctr] = reg_buff;  
  }

der String in buff 1 lautet nach strcat "mov.w r0, reg_buff" (ohne das 
/n)
aber der compiler meckert "expected asm string"?

[Timmo H. (masterfx)]

Dein Inline-Assembler Code muss bereits beim Kompilieren bekannt sein. 
Du kannst nicht einen String zur Laufzeit erzeugen und dann an die 
asm-Derektive weitergeben.

[andi (Gast)]

also geht nur

  asm(" mov.w r0, reg_buff\n");
  stack[stc_ctr].reg[0] = reg_buff;
  asm(" mov.w r1, reg_buff\n");
  stack[stc_ctr].reg[1] = reg_buff;
  asm(" mov.w r2, reg_buff\n");
  stack[stc_ctr].reg[2] = reg_buff;
  asm(" mov.w r3, reg_buff\n");
  stack[stc_ctr].reg[3] = reg_buff;
  asm(" mov.w r4, reg_buff\n");
  stack[stc_ctr].reg[4] = reg_buff;
  asm(" mov.w r5, reg_buff\n");
  stack[stc_ctr].reg[5] = reg_buff;
  asm(" mov.w r6, reg_buff\n");
  stack[stc_ctr].reg[6] = reg_buff;
  asm(" mov.w r7, reg_buff\n");
  stack[stc_ctr].reg[7] = reg_buff;
  asm(" mov.w r8, reg_buff\n");
  stack[stc_ctr].reg[8] = reg_buff;
  asm(" mov.w r9, reg_buff\n");
  stack[stc_ctr].reg[9] = reg_buff;
  asm(" mov.w r10, reg_buff\n");
  stack[stc_ctr].reg[10] = reg_buff;
  asm(" mov.w r11, reg_buff\n");
  stack[stc_ctr].reg[11] = reg_buff;
  asm(" mov.w r12, reg_buff\n");
  stack[stc_ctr].reg[12] = reg_buff;
  asm(" mov.w r13, reg_buff\n");
  stack[stc_ctr].reg[13] = reg_buff;
  asm(" mov.w r14, reg_buff\n");
  stack[stc_ctr].reg[14] = reg_buff;
  asm(" mov.w r15, reg_buff\n");
  stack[stc_ctr].reg[15] = reg_buff;

?

[Karl H. (kbuchegg)]

Ich würd mir an deiner Stelle auch mal ansehen, was der Compiler aus

  stack[stc_ctr].reg[0] = reg_buff;

macht.
Ich würde das nämlich als recht unwahrscheinlich ansehen, wenn der 
Compiler die anweisung ohne die Verwendung von Registern hinkriegt. 
Wodurch du nicht die Registerinhalte sicherst, die du denkst.