NOP in "C"

[Siro]

Ich denke einfach generell in Assembler und schaue mir selbst bei Kleinigkeiten an, was der Compiler draus macht.
Aber Du hast natürlich recht, der Compiler darf anscheinend Unterprogamme als Inline codieren.
Da war ich ebenso erstaunt, dass der Compiler mal eben meinen Ablaufplan selbst geändert hat. Denn der Code entsprach oftmals nicht mehr meinem Flussdiagramm.
Das Resultat blieb jedoch erhalten.
Für mich ist eine Funktion generell ein Stückchen Programmcode welcher mittels call aufgerufen wird. Weil sonst ist das ja keine Funktion mehr.

Bei cli() und sti() finde ich die "Funktionsklammern" (nennt man die nicht so ?) schon mehr als unnütz.
Aber das ist sicher Geschmackssache. Ich habe jetzt meine eigenen Assemblerbefehle declariert, das erlaubt ja die Freiheit von "C".

[Klebwax]

Ich denke einfach generell in Assembler und schaue mir selbst bei Kleinigkeiten an, was der Compiler draus macht.

Dann solltest du konsequenterweise auch in Assembler programmieren.

Der Compiler macht genau das, was du ihm sagst. Wie er das macht, mußt du ihm überlassen. Wenn du in den Flieger von Frankfurt nach New York steigst, wird er dich (meist) auch dahin bringen. Welchen genauen Kurs er nimt, wieviel Gas er gibt etc. liegt beim Piloten, nicht bei dir. Und wenn du pünktlich in New York bist, hat er seine Aufgabe zur vollsten Zufriedenheit ausgeführt.

Wenn du in C scheibst:

a = b + c;

ist die Aufgabe, in die Variable a die Summe von b und c zu speichern, und nicht den Prozessor eine Addition ausführen zu lassen.

Findet der Compiler heraus, daß b und c Konstante sind, dann erfüllt er die Aufgabe auch (und sogar effektiver) wenn er Summe gleich selbst berechnet und sie in a speichert. Änliches gilt auch, wenn in a schon die Summe steht.

Und in C ist es nun einmal so, daß am Anfang einer Anweisung entweder ein reseviertes Wort wie if, while, etc., oder ein Symbol steht. Ist diese Symbol eine Varible, dann muß darauf eine direkte oder indirekte Zuweisung, also ein = oder += oder ein ++ folgen. Folgt das nicht, ist es eine Funktion und da sind Klammern erforderlich.

Sieht das mal nicht so aus, verbirgt sich dahinter Preprozessor Magic, die je nachdem den Code leichter lesbar macht, oder den Anwender so in die Irre führt, daß er ihn garnicht mehr versteht. Der Compiler selbst sieht das aber nicht.

MfG Klebwax

[Siro]

Dann solltest du konsequenterweise auch in Assembler programmieren.

Auch wenn ich eingefleischter Assemblerfreak bin, so manches sieht in einer Hochsprache "geringfügig" eleganter aus:

if (a > b)

oder:

;------------------------------------------------------
; if A > B             ; 32 Bit Signed Compare
IF_INT32_G_VAR MACRO VarA,VarB,ElseAddress
  Local not_equal
    BANKSEL VarB
    movf    VarB+3,W    ;
    BANKSEL VarA
    subwf    VarA+3,W    ;
    btfss    STATUS,Z    ; scip if  zero, is equal
    BRA    not_equal    ; else goto not equal
    BANKSEL VarB
    movf    VarB+2,W    ; W = Low Byte VarB
    BANKSEL VarA
    subwf    VarA+2,W    ; W = VarA-VarB
    btfss    STATUS,Z    ; scip if zero, is equal
    BRA    not_equal    ; else goto not equal
    BANKSEL VarB
    movf    VarB+1,W
    BANKSEL VarA
    subwf    VarA+1,W
    btfss    STATUS,Z    ; scip if zero, is equal
    BRA    not_equal    ; else goto not equal
    BANKSEL VarB
    movf    VarB+0,W
    BANKSEL VarA
    subwf    VarA+0,W    ; low byte variable A
    btfsc    STATUS,Z    ; scip if not equal
    goto    ElseAddress    ; else is equal
not_equal:    
    rrcf    STATUS,W    ; signed carry correction
    xorwf    VarA+3,W
    BANKSEL VarB
    xorwf    VarB+3,W
    addlw    0x80
    btfss    STATUS,C    ; scip if greater
    goto    ElseAddress    ; else is below
    endm
;------------------------------------------------------

.... Spass muss sein....

Siro