pushen und popen (msp430)

das da ziemlich viel unterschied besteht ist doch garkeine frage! aber
wenn man sich schön strikt an ansi-c hält ( iar wirbt nunmal damit das
sie iso/ansi konform sind), dann kann man durchaus portabel schreiben!
(nur z.b. solche sachen wie inline asm sind extrem verschieden!)

falls es interessiert, es soll eine art scheduler für den msp430
werden. es sind eigentlich verkettete listen (einfacher ansi code). nur
um diese zu füllen brauche ich compilerabhängigen code (eben das pushen
und popen)...

asm ist eine Directive und kann damit weder einen Wert einlesen noch
zurückgeben.

Wenn Du in Assembler auf Variablen (SRAM-Adressen) zugreifen willst,
mußt Du das über Load (LD)* oder Store (ST)* Befehle tun.

Push, Pop greifen immer nur auf den Stack zu.


Peter


* wie die beim MSP430 heißen weiß ich nicht.

"...wenn man sich schön strikt an ansi-c hält..."

Assembler und ANSI-C schließen sich gegenseitig aus !!!

Es geht nur entweder oder !


Was versprichst Du Dir überhaupt vom Einsatz von Assembler ?

Ich würde überhaupt auch nur jenem zu Assembler unter C raten, der
schonmal mindestens ein funktionierendes Programm komplett in Assembler
geschrieben hat und auch ein Compiler Listing versteht.


Peter

> Was versprichst Du Dir überhaupt vom Einsatz von Assembler ?

Da KoF von einem Scheduler sprach, hört sich das sehr nach einem RTOS
an ;-).

genau... ein rtos soll es werden.
(jetzt bitte nicht davon reden, warum man das rad neu erfinden soll /
es schon eine halbe mil. von ihnen gibt.)

ich mache es, um es gemacht zu haben/um daraus zu lernen. mir ist schon
klar, das es eine unzahl von ihnen gibt, doch das interessiert mich aus
eben diesen gründen nicht!

aja... den gcc teil habe ich (glaube ich) geknackt ;-)

1

//save the registers

2

#define OS_Push_GCC()        \

3

  asm volatile (  "push  r4  \n\t"  \

4

          "push  r5  \n\t"  \

5

          "push  r6  \n\t"  \

6

          "push  r7  \n\t"  \

7

          "push  r8  \n\t"  \

8

          "push  r9  \n\t"  \

9

          "push  r10  \n\t"  \

10

          "push  r11  \n\t"  \

11

          "push  r12  \n\t"  \

12

          "push  r13  \n\t"  \

13

          "push  r14  \n\t"  \

14

          "push  r15  \n\t"  \

15

         );

16

// restore the registers

17

#define OS_Pop_GCC()        \

18

  asm volatile (  "pop  r15  \n\t"  \

19

          "pop  r15  \n\t"  \

20

          "pop  r14 \n\t"  \

21

          "pop  r13  \n\t"  \

22

          "pop  r12  \n\t"  \

23

          "pop  r11  \n\t"  \

24

          "pop  r10  \n\t"  \

25

          "pop  r9  \n\t"  \

26

          "pop  r8  \n\t"  \

27

          "pop  r7  \n\t"  \

28

          "pop  r6  \n\t"  \

29

          "pop  r5  \n\t"  \

30

          "pop  r4  \n\t"  \

31

          "reti    \n\t"  \

32

        );

iar, wie auch mspgcc verwenden zur erkennung beide asm("<todo>") als
syntax. aber wie das mit der aufteilung von mehreren befehlen jetzt im
iar aussieht, darum kümmere ich mich jetzt ;-)

> Assembler und ANSI-C schließen sich gegenseitig aus !!!

Eigentlich nicht. asm ist sogar ein Schlüsselwort in ANSI/ISO-C.
Natürlich ist die Syntax dort nicht definiert und damit das Programm
auch nicht portabel.

Ok, aber es wird zumindest erwähnt ;-)
Hab's wohl mit C++ verwechselt. Dort ist es so wie ich sagte.
Mea culpa

arg... mistmadiger iar...
kann mir jemand sagen, wie ich das vom gcc auf iar portieren soll???

1

__asm__ __volatile__("mov.w SP, %0" : "=r" (CurrentTask->stack));

2

...

3

__asm__ __volatile__("mov.w %0, SP" : : "m" (CurrentTask->stack));