0
void save_context(uint8_t index) {
    context *this_context = contextArray + index;
    uint8_t *this_stack = this_context->stack;


    asm volatile("st %0 r0":  "r"(this_stack));
}

I have something like this.

!!! I would like to store the registers r0 r1 r2... into my stack[] array.

What I am programming is the context switch. The context has the structure like this:

typedef struct context_t {
   uint8_t stack[THREAD_STACK_SIZE];
   void *pstack;
   struct context_t *next;
}context;

My problem is that I am not able to pass the c variable "this_stack" to inline assembly. My aim is to store all the registers, stack pointer and SREG on my stack.

After compiling, it gives error: Description Resource Path Location Type

`,' required    5_multitasking      line 754, external location: C:\Users\Jiadong\AppData\Local\Temp\ccDo7xn3.s C/C++ Problem

I looked up the avr inline assembly tutorial. But I don't quite get a lot. Could anyone help me?

jiadong
  • 135
  • 7
  • `"label"` makes no sense, that should be a constraint. It also makes no sense trying to save the stack pointer into an array. It might make sense to load the stack pointer with the address of that array, but that's not the `save_context`. – Jester Jun 02 '16 at 18:27
  • @Jester if you look at the constraints for lds, it is r,label. please have a look at the link http://www.atmel.com/webdoc/AVRLibcReferenceManual/inline_asm_1io_ops.html – jiadong Jun 02 '16 at 18:35
  • `label` is not a gcc constraint. See the [manual](https://gcc.gnu.org/onlinedocs/gcc/Constraints.html). – Jester Jun 02 '16 at 18:36
  • @jester actually I am doing is to save the stack pointer in the struct. but there are many tasks, let's say 3 tasks. Each task has a stack, that is why I created an array for the context. – jiadong Jun 02 '16 at 18:37
  • But I assume each task has its own context, no? So each context only needs to store 1 stack pointer, not an array of them. – Jester Jun 02 '16 at 18:38
  • yes, each task has 1 stack pointer. And now I have many tasks, for example, I have 3 tasks. It is easy to create an array to store them. Isn't it – jiadong Jun 02 '16 at 18:42
  • Your edit to the question which replaced `asm volatile("lds r26 %0": : "label"(this_stack));` with `asm volatile("st %0 r0": "r"(this_stack));` is still invalid. That's an input constraint. Maybe you meant `"=m"(*this_stack)` to have the compiler pick an addressing mode. Passing it a pointer in a register does *not* tell it that the pointed-to memory is assumed to be written. – Peter Cordes Jan 16 '19 at 05:57
  • You also seem to have too many dereferences. If `this_context->stack` is a `uint8_t*` pointer you want to modify, you need to take its address, like `uint8_t **this_stack = &this_context->stack;`. Otherwise you're just setting a local variable, or dereferencing a pointer you loaded from a global struct. This might be what you want: https://godbolt.org/z/_Ra5_M – Peter Cordes Jan 16 '19 at 06:04

3 Answers3

1

asm volatile ("st %0 r0": "r"(this_stack));

There are several problems in that line: Wrong % print-modifier, missing , between the operands, incorrect constraint and missing description of side effects.

The memory access is supposed to use indirect addressing, so one way is to use indirect+displacement with "b"ase register Y or Z:

    asm volatile ("std %a1+0, r0" "\n\t"
                  "std %a1+1, r1" "\n\t"
                  "..."
                  : "+m" (this_context->stack)
                  : "b" (this_stack));

Notice print modifier %a which prints R30 as Z and not as r30. Operand 0 is just used to express that this_context->stack is being changed if you don't want the all-memory-clobber "memory". Moreover, there's no need for an intermediate variable for operand 1 because it's not altered: you can use just as well "b" (this_context->stack) for operand 1.

Alternatively, post-increment addressing on "e"xtended (pointer) registers X, Y or Z can be used:

    asm volatile ("st %a1+, r0" "\n\t"
                  "st %a1+, r1" "\n\t"
                  "..."
                  : "=m" (this_context->stack), "+e" (this_stack));
emacs drives me nuts
  • 2,785
  • 13
  • 23
0

"label" makes no sense, that should be a constraint. It also makes no sense trying to save the stack pointer into an array. It might make sense to load the stack pointer with the address of that array, but that's not the save_context.

Anyway, to get the value of SPL which is the stack pointer you can do something like this:

asm volatile("in %0, %1": "=r" (*this_stack) : "I" (_SFR_IO_ADDR(SPL)));

(There is a q constraint but at least my gcc version doesn't like it.)

To get true registers, for example r26 you can do:

register uint8_t r26_value __asm__("r26");
asm volatile("": "=r" (r26_value));
Jester
  • 56,577
  • 4
  • 81
  • 125
  • well, this_stack is a uint8_t *, not uint8_t – jiadong Jun 02 '16 at 18:40
  • yes, i know the label is not the correct constraint. but did you look at the link above? How do you explain this "label" – jiadong Jun 02 '16 at 18:41
  • no, i did not want to get the value of r26. I want to store all the register values into the this_stack. – jiadong Jun 02 '16 at 18:46
  • They were drunk. The first table clearly lists the available constraints so the second table had better use those :) And they even mention "constraint characters" which `label` clearly isn't. – Jester Jun 02 '16 at 18:47
  • I have updated my question. Please look at the code again. thanks – jiadong Jun 02 '16 at 18:53
-1

There is a constraint, "m", documented in the GCC manual, but it doesn't always work on AVR. Here is an example of how it should work from sanguino/bootloaders/atmega644p/ATmegaBOOT

asm volatile("...
    ...
    "sts    %0,r16      \n\t"
    ...
    : "=m" (SPMCSR) : ... );

I have found "m" to be fragile though. If a function uses a variable in C code, outside of the inline assembly, the compiler may choose to place it in the Z register and it will try to use Z in assembler too. This causes an assembler error when used with the sts instruction. Looking at the assembler output from the C compiler is the best way to debug this kind of problem.

Rather than using an "m" constraint, you can just put the literal address you want into your assembler code. For an example, see pins_teensy.c, where timer_0_fract_count is not included in the :

asm volatile(
    ...
    "sts    timer0_fract_count, r24"    "\n\t"
Alan Green
  • 124
  • 5
  • 1
    `"m"` is a memory operand, common to all architectures. https://gcc.gnu.org/onlinedocs/gcc/Simple-Constraints.html. The machine-constraints docs don't duplicate those in each section. (And https://gcc.gnu.org/onlinedocs/gcc/Machine-Constraints.html does document `"M"`for AVR, so that's not what you mean.) – Peter Cordes Jan 16 '19 at 06:06
  • 1
    A problem with putting the literal address into the asm is that gcc's optimizers won't be able to see it. Conceivably the allocation could be discarded as unused if it is only used in asm blocks. – David Wohlferd Jan 17 '19 at 05:16