NOP in "C"

**Siro** · 06.12.2012, 07:56

Hallo zusammen,
ich wollte in meinen "C"-Code einen Assembler Befehl NOP einbauen.

MPLAB C-Compiler 8.87
------------------------------------
Das der C-Compiler mit dem Befehl NOP nichts anfangen kann leuchtet mir ein

NOP;

deshalb kam auch die Fehlermeldung:
410.1 undefined identifier "NOP"
------------------------------------
also habe ich es entsprechend declariert

#define NOP asm("NOP");

NOP;

Doch nun bekam ich folgende Meldung:

405.23 redefining preprocessor macro "NOP"

--------------------------------------------
Nach einigem Suchen habe ich dann die "Definierte Declaration"

von NOP gefunden.
Da hat man doch tatsächlich den NOP wie folgt declariert:

Code:

#pragma intrinsic(_nop)
extern void _nop(void);
#define NOP() _nop()

Warum macht man denn so etwas ? Was sollen da die Klammern, das ist doch keine Funktion, das sieht für mich aus wie ein CALL .....

Wenn ich also in meinem "C" Programm schreibe:
NOP();
dann funktioniert es nun auch. Aber wo liegt da der Sinn ?

mfg. Siro

**radbruch** · 06.12.2012, 08:16

Hallo

In der RP6-Library wird nop() so definiert:

Code:

// Assembly and system macros:
#define nop(); {__asm__ volatile("nop\n\t");}

(Aus RP6M256.h)

Was das aber bedeutet weiß ich auch nicht. Vermutlich wird so in den Programmablauf eine Zeile Assembler eingefügt bevor die Hex-Datei erzeugt wird.

Gruß

mic

**Siro** · 06.12.2012, 09:38

Hallo mic, also dort auch mit den Klammern, so muss man also in "C" nun auch
nop();
schreiben, was aussieht wie ein Unterprogramm Aufruf ohne Parameter.

man hätte doch auch:
#define nop; {__asm__ volatile("nop\n\t");}
declarieren können, dann würde man in "C" nur
nop;
schreiben müssen, was meiner Meinung nach wesentlich sinnvoller bzw. übersichtlicher ist, da ja hier direkt, wie Du schon richtig sagtest, eine Assemblerzeile eingefügt wird und nix aufgerufen wird.
Das ist für eine Vortäuschung falscher Tatsachen, weil ich würde im Assemblelisting einen "CALL" suchen und durch die Schreibweise eine zusätzliche Stackbelastung vermuten.
Ist ja kein Weltuntergang, aber ich find das eher verwirrend und der Sinn ist mir bisher verborgen geblieben.

Siro

**radbruch** · 06.12.2012, 10:10

Hallo

cli() und sei() sind auch keine Funktionen.

Das sind die Folgen der großen Freiheiten die man bei C hat.

mic

**Klebwax** · 06.12.2012, 19:07

Wie man sieht, kommt das mit dem nop() öfter vor. Bei den PICs kenne ich das von HI-TECH und vom GCC. Beim RP6 schein das ja so zu sein. Eine wirklich Erklärung habe ich nicht, ich vermute, das man den Namespace der Variablen nicht mit prozessorspezifischen Namen füllen will.

Zitat von Siro

Das ist für eine Vortäuschung falscher Tatsachen, weil ich würde im Assemblelisting einen "CALL" suchen und durch die Schreibweise eine zusätzliche Stackbelastung vermuten.

Auch wenn ab und an das Gegenteil behauptet wird, C ist eine Hochsprache. Eine C-Funktion ist einen Funktion in C und gehorcht den Regeln von C. Ob daraus ein CALL in Assembler wird, ist nicht gesagt und wird auch in der C-Definition nicht gefordert. Diese zu erwarten ist schlichtweg Unsinn. Der Compiler kann jede Funktion inlinen und es gibt keinen CALL. Er kann umgekehrt bei einem Ausdruck wie float x * float y eine interne "Assemblerfunktion" aufrufen. Gleiches gilt natürlich auch für komplexere Konstrukte wie switches.

Die meissten C-Programmierer haben noch nie in ihrem Leben ein Assemblerlisting ihres C Codes gesehen. Ob mit ihrem Code ein ARM, MIPS, SPARC PowerPC oder x86 läuft, ist und soll ihnen auch egal sein. Und bei der heutigen Leistungsfähigkeit der µC kann man die dort auch einreihen. So ein klassischer APPLE ][ hatte einen 1 MHz Prozessor und 32 bis 64 kB Speicher für Code und Daten. Auf diesem wurde unter anderem das erste Spreadsheet entwickelt, mit Sicherheit nicht, mit dem Assemblerlisting in der Hand.

Seitdem ich die PIC16 in C programmiere, hab ich mir die Listings immer seltener angeschaut. Jetzt benutze ich die PIC24, ich hab erst einmal ins Listing geschaut, ich kenne den Assembler garnicht. Den x86 Assembler kenne ich auch nur im 16 Bit Mode, welche Register und welche Befehle er im protected oder 64 Bit mode hat weiß ich nicht. Trotzdem programmiere ich da in jeder Sprache, die mein Problem löst, C eingeschlossen. Und die Vorstellung eines Assemblerlistings eines einige 10 MB großen Programms ...

Wer in C (C++, C#, Java, PASCAL, PERL, PHP ...) programmiert, muß auch in dieser Sprache sein Problem formulieren, analysieren und lösen. Und ob der Rechner daraus Assemblercode macht oder sich Hilfe aus der Cloud holt, spielt keine Rolle, solange er die Sprachdefinition erfüllt.

MfG Klebwax

**Siro** · 07.12.2012, 11:59

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** · 08.12.2012, 15:42

Zitat von Siro

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** · 08.12.2012, 17:09

Zitat von Klebwax

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:

Code:

;------------------------------------------------------
; 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

**oberallgeier** · 02.10.2013, 14:08

Zitat von Siro

... so muss man also in "C" nun auch
nop();
schreiben ...

Funktioniert bei Euch dieses

Code:

nop();

in C? Bei mir wird ein Fehler ausgegeben - egal ob Groß- (wie SEI oder CLI) oder Kleinschreibung. Nur das Format

Code:

__asm__ volatile("nop\n\t");

funktioniert; bei mir aktuell ohne define, da ich es nur einmal benötig(t)e.

Anmerkung: A.VR Studio 4, Version 4.18, Build 700, mit GCC/WinAVR-20100110; WinXPpro 2002 SP3

**Siro** · 02.10.2013, 14:49

ich vermute, daß in deinem Programmcode

#include <intrinsics.h>

fehlt, könnte das sein ?

Siro

wenn nicht: welche Fehlermeldung bekommst du genau ?