Assembler in C/C++ Programmen

Transkript

1 HTI Burgdorf 1 Assembler in C/C++ Programmen Der Einsatz von Assembler kann bei speziellen Aufgaben durchaus sinnvoll sein. Auf einer PC- Plattform ist eine gemischtsprachliche Programmierung eher nicht mehr angebracht, weil die C- Compiler heute einen sehr effizienten Code erzeugen. Die Hardwarenähe, die klassische Domäne von Assembler, bringt in Win32-Systemen wenig, da in der Anwenderebene (Ring 3) keine Vorteile, wie I/O-Privileg, existieren. Zusammengefasst kann mit Assembler auf einer PC-Plattform normalerweise nicht mehr erreicht werden, als mit einem normalen C-Compiler. In Mikrocontroller- oder Signalprozessoranwendungen ist der Einsatz von Assembler verbunden mit einer Hochsprache jedoch keine Frage. Manches kann in Assembler wesentlich einfacher und/ oder laufzeiteffizienter realisiert werden. In solchen Systemen werden die zeitkritischen Teile in Assembler codiert, der Rest in der Hochsprache. Eine besondere Bedeutung hat aber die gemischtsprachliche Programmierung bei der Module in C/C++, Fortran, Visual Basic, u.a in einem Programmierprojekt verwendet werden. Dies wird unter dem Begriff Mixed Language Programming zusammengefasst und ist in den Dokumentationen zu den Sprachen und Programmierplattformen zu entnehmen. Die Prinzipien, Vorgehen und Möglichkeiten sind für alle Produkte und Plattformen etwa gleich. Deshalb wird in den nachfolgenden Kapiteln die Arbeit auf der Basis Microsoft Visual Studio 2003 VC7 gezeigt. Bei diesem Produkt sind alle benötigten Programmier- und Testkomponenten direkt verfügbar. Gründe, Assembler in einer PC-Umgebung einzusetzen Assembler wird in PC- und leistungsfähigen Mikrocontrollerumgebungen immer weniger eingesetzt. Die Gründe liegen in der schlechten Portierbarkeit auf andere Plattformen und dem enorm grossen Entwicklungs- und Dokumentationsaufwand. Dennoch sind verschiedene Gründe für den Einsatz von Assembler denkbar. Aber selbst dann werden keine grossen Assemblerprogramme codiert, sondern nur das minimal Notwendige. 1. Grund: Bereits vorliegendes Material soll (weiter-) verwendet werden. Dies, weil z. B. für eine Hardware vom Hersteller nur ein Objektmodul geliefert wird. Im Idealfall kann dieses Material direkt in das eigene Projekt eingebunden werden. Bei älteren Objektmodulen wird das Objektfileformat eventuell nicht kompatibel zum verwendeten Linker sein. Alte 16-Bit Module lassen sich im Prinzip mit etwas Aufwand auch in eine 32-Bit Anwendung integrieren. Bei solchen Fragestellungen sollte man aber immer prüfen, ob ein Neudesign nicht sinnvoller wäre. Der Einsatz solcher Module ist unter Win32 (Win2K, WinXP) im Regelfall problemlos, solange im Modul kein direkter Zugriff auf die Peripherie erfolgt. Ist im Modul I/O notwendig, muss ein Neudesign mit einem WDM-Treiber erfolgen. (Vgl. auch [MSQ-1].) Assemblerprogramme im Quellcode können direkt migriert werden. Bei 16-Bit Programmen sollte aber eine Erweiterung auf 32-Bit erfolgen. 2. Grund: Nutzung spezieller Prozessorbefehle Compiler benutzen für die Codegenerierung einen Instruktionssatz, der auf allen Maschinen zur Verfügung steht. Dies sind die Befehle, die der i386 mit dem Gleitkommaprozessor i387 zur Verfügung stellt. Zahlreiche spätere Erweiterungen, wie z. B. MMX-Befehle werden nicht benutzt. 3. Grund: Effizienzverbesserung Manche rechenzeitintensive Verfahren wie Verschlüsselung oder Datenkompression können durch Einsatz von Assembler etwas beschleunigt werden. Moderne Compiler erzeugen jedoch einen besseren Maschinecode als ein durchschnittlicher Assemblerprogrammierer. Deshalb ist dieser Grund nur eingeschränkt gültig.

2 HTI Burgdorf 2 Zu erwartende Probleme Neben der schlechten Portierbarkeit der Programme und dem hohen Dokumentationsaufwand sind Probleme immer an den Schnittstellen zu erwarten. Dies sind Parameter und Resultate bei den Funktionen sowie beim Zugriff im Assemblercode auf in der Hochsprache definierte Daten und Symbole. Stichworte, die bei der Verwendung von Funktionen in Assembler oder ganzen Assemblermodulen beachtet werden sollen sind: extern C { } CDECL, PASCAL C++ Name-Mangling für exportierte Symbole deaktivieren Parameterreihenfolge, Stackbereinigung Am Besten erstellt man zuerst eine Minimalfunktion und prüft, ob die Parameter korrekt übergeben werden und das Resultat wie gefordert, retourniert wird. Das Debugging kann bei _asm-sequenzen noch direkt im integrierten Debugger auf Quellcodeebene erfolgen. Bei externen Modulen wird dies schwieriger. Dasselbe gilt, wenn Module aus einer anderen Sprache wie FORTRAN oder Visual-Basic integriert werden. Bei schwierigen Fällen kann ein sog. Kernel-Debugger eingesetzt werden (z. B. SoftICE von Compuware). Er erlaubt das symbolische Debugging auf Systemebene. Solche Werkzeuge sind teuer und setzen tief gehende Systemkenntnisse voraus. Integrierte Assembler-Anweisungen im C/C++ Code Maschinencode Statements mit _asm _emit Microsoft- und Intel-Compiler, wie andere Produkte, unterstützen das direkte Einbringen von Maschinencode in Byteform mittels _asm _emit. Die _asm _emit Anweisung ist in ihrer Wirkung wie ein DB (Define Byte) in Assembler zu verstehen. Sie definiert an der aktuellen Stelle im Codesegment ein einzelnes Byte. Sollen mehrere Bytes definiert werden, muss dies mit aufeinander folgenden _asm _emit Anweisungen erfolgen. _asm _emit 0x90 _asm _emit 0x90 _asm _emit 0x90 Die _asm-anweisung ist selbstterminierend, d. h. sie benötigt kein Semikolon. Deshalb können auch mehrere _asm-anweisungen direkt aufeinander folgen. Das Einbinden von Maschinencode hat keine Bedeutung in der praktischen Programmierung, weil mit _asm auch direkt Assemblercode eingebunden werden kann. Dies ist in jedem Fall zu bevorzugen.

3 HTI Burgdorf 3 Beispiel 1: Einbinden von Maschinencode-Bytes mit _asm _emit. Bei Microsoft und Intel können einzelne Bytes mit _asm _emit direkt im Code platziert werden. Das nachfolgende Beispiel zeigt wie drei NOP-Befehle (Code 0x90) an der aktuellen Stelle definiert werden und wie die Umsetzung im Compiler erfolgt. Bild 1: Disassemblierte Darstellung des Programms mit _asm _emit-anweisungen nach Beispiel 1. Plattform: Visual C++ V7.0 von VS.NET 2003.

4 HTI Burgdorf 4 Assemblercode mit _asm-anweisungen Durch das reservierte Wort _asm kann ein Assemblercodeblock direkt in den C/C++ Quelltext eingefügt werden. Innerhalb des Assemblerblockes gelten auch hier die Syntaxregeln des Assemblers, der zum Compiler gehört. Ein Zugriff auf C-Symbole ist auf einfache Weise möglich wie auch Funktionsaufrufe der C-Laufzeitbibliothek. Das reservierte Wort _asm aktiviert den Inline-Assembler. Es muss immer in Verbindung mit einer einzelnen Assembler-Anweisung oder einem Block von Assembleranweisungen stehen. _asm nop Die _asm-anweisung ist selbstterminierend, d. h. sie benötigt kein Semikolon. Deshalb können auch mehrere _asm-anweisungen direkt aufeinander folgen. _asm nop _asm nop _asm nop Ein Semikolon nach der letzten Anweisung zu setzen ist aber kein Fehler. Zu beachten ist, dass das Semikolon die Zeile terminiert. Nachfolgende _asm-anweisungen werden in dieser Zeile nicht mehr erkannt. Beispiel 2: Einfache _asm-anweisungen in C/C++ Code. Das folgende Beispiel zeigt das Einbringen dreier NOP-Befehle in den C/C++ Quellcode: #include <stdio.h> int main(void) { printf("beispiel: Inline Assemblercode mit_asm\n"); _asm nop _asm nop _asm nop } return 0; Eine alternative Lösung mit einem Block: #include <stdio.h> int main(void) { printf("beispiel: Inline Assemblercode mit_asm\n"); _asm { } nop ; Klassischer Assembler-Kommentar ist erlaubt nop /* Klassischer C-Kommentar ist erlaubt */ nop // C++-Kommentar ist erlaubt } return 0; Kommentare können als normale C/C++ Kommentare eingebracht werden. Der klassische Assembler-Kommentar mit Semikolon ist ebenfalls zulässig.

5 HTI Burgdorf 5 Namen und Aufrufkonventionen Sollen auf Daten oder Funktionen aus einem anderen Modul zugegriffen werden sind die Schnittstellen für den Aufruf zu berücksichtigen. Sie sind grundsätzlich sprach- und einstellungsabhängig. Klassisch kennt man die Konventionen: Namenkonvention Sie besagt, wie der Compiler den Namen verändert bevor er in das Objektmodul exportiert wird. Am Beispiel des Symbols gettime wird dies: SYSCALL Der Symbolname wird unverändert in das Objektmodul übernommen. Der Linker referenziert die Variable als gettime. C, STDCALL Der Symbolname wird mit einem führenden Underscore ergänzt in das Objektmodul übernommen. Der Linker referenziert die Variable als _gettime. FORTRAN, PASCAL, Basic Der Symbolname wird in Grossbuchstaben in das Objektmodul übernommen. Der Linker referenziert die Variable als GETTIME. Name Mangling Bei C++ erfolgt für jede Funktion eine codierte Erweiterung, die die Anzahl Typ der Argumente beinhaltet. Für extern codierte Funktionen in einer anderen Sprache ist es daher notwendig die Funktionen als extern C { } zu deklarieren. Aufrufkonvention Sie besagt, wie der Compiler beim Aufruf einer Funktion oder Prozedur die Parameter ablegt und wie die Prozedur zu Aufrufer zurückkehrt. Bei VS.NET 2003 VC7 sind dies: fastcall Die Argumente werden nach Möglichkeit in den Prozessorregistern der aufgerufenen Einheit übergeben. Die ersten beiden DWORD oder kleiner Argumente werden in ECX and EDX übergeben. Alle anderen Argumente über den Stack Argumente von rechts nach links thiscall In C++ erfolgen standardmässig alle Funktionsaufrufe in dieser Konvention. Die Argumente werden in cdecl Form auf den Stack gelegt und der this-zeiger wird in ECX übergeben. thiscall ist kein Keyword. Deshalb kann eine Funktion nicht explizit als thiscall definiert werden und ist nur für C++ Programme relevant. stdcall Sie löst die _pascal-aufrufkonvention ab. Praktisch alle Windows-Systemfunktionen arbeiten mit dieser Aufrufkonvention, da sie etwas laufzeit- und speicherlatzeffizienter ist als cdecl. cdecl Ist bei C Programmen Standard. Sie wird zwingend benötigt wenn mit Funktionen mit variabler Anzahl Argumenten gearbeitet wird, da nur der Aufrufer die tatsächliche Anzahl übergebener Argumente kennt und die Stackbereinigung durchführen kann.

6 HTI Burgdorf 6 Die Gross-/Kleinschrift der Symbole bleibt bei allen Verfahren unverändert. Konvention fastcall stdcall thiscall cdecl _+@+Anzahl _ Zeichen Bytes für Bytes für Argumente über Register übergeben Argumente von rechts nach links auf den Stack Stackbereinigung durch Aufrufer Parameter ECX, EDX _+@+Anzahl Bytes für Parameter Parameter this in ECX (X) X X X Die nachfolgenden Betrachtungen beschränken sich auf Assembler x86 und ANSI-C/C++. X Alle Aufrufkonventionen erzeugen einen Prozedurrahmen, der die Register ESI, EDI, EBX und EBP sichert und wiederherstellt und wo notwendig die Stackbereinigung durchführt. Aufrufe ohne Prozedurrahmen sind mit Naked Function Calls möglich. Die Konventionen _pascal, _fortran und _syscall werden von der Seite der Hochsprache nicht mehr unterstützt. Ihre Funktionalität kann mit den bestehenden Methoden und entsprechenden Linkereinstellungen erreicht werden. X Beispiele von Parameterübergaben bei Funktionsaufrufen Der Ablauf der Parameterübergaben bei den verschiedenen Aufrufkonventionen wird am nachfolgenden Beispiel gezeigt. Beim Funktionsaufruf in der Hochsprache wird calltype jeweils durch das entsprechende Aufrufprefix ersetzt. void calltype MyFunc( char c, short s, int i, double f );. void MyFunc( char c, short s, int i, double f ) {. } MyFunc ('x', 12, 8192, );

7 HTI Burgdorf 7 cdecl Der Compiler exportiert den Funktionsnamen für den Linker als _MyFunc.Die Register ECX und EDX werden nicht benutzt. Die Parameterreihenfolge im Stack wird: Bild 2: Stack und Register beim Funktionsaufruf mit cdecl Konvention. Bildreferenz: MSDN Developer Library CD 2005 stdcall und thiscall Bei stdcall der Compiler exportiert den C-Funktionsamen für den Linker als _MyFunc@20. Der C++ Name ist proprietär und sollte in Assemblermodulen nicht referenziert werden. Der this- Zeiger wird bei C++ in ECX übergeben, EDX wird nicht benutzt. Die restlichen Argumente werden im Stack in der Reihenfolge übergeben: Bild 3: Stack und Register beim Funktionsaufruf mit stdcall oder thiscall Konvention. Bildreferenz: MSDN Developer Library CD 2005 fastcall Der Compiler exportiert den Funktionsnamen die fastcall für den Linker Der C++ Name ist proprietär und sollte in Assemblermodulen nicht referenziert werden. Bild 4: Stack und Register beim Funktionsaufruf mit fastcall Konvention. Bildreferenz: MSDN Developer Library CD 2005

8 HTI Burgdorf 8 Zugriff auf C-Symbole Innerhalb der _asm-anweisung kann auf C-Symbole (Variablen, Konstanten und Funktionen) zugegriffen werden. Der Programmierer ist selbst dafür verantwortlich, dass dies richtig geschieht. Fehler werden normalerweise nicht erkannt und führen meist zu einem Hänger oder zum sofortigen Programmabsturz. Ein Zugriff auf C-Symbole ist direkt über den Namen möglich. Ein Zeiger auf eine Variable sollte mittels LEA-Prozessorbefehl gebildet werden (vgl. Beispiel 4). Bedingung für den möglichen Zugriff ist, dass das Symbol im aktuellen Gültigkeitsbereich (Scope) liegt. Beispiel 3: _asm Anweisungen in C-Code. Das folgende Beispiel zeigt die Berechnung der Fakultät einer eingelesenen Ganzzahl. Die Rechnung erfolgt iterativ mit einer einfachen Schleife. /* Beispiel zum Einbetten von Assemblercode in C-Programme x86 Inline Assemblercode und MS Visual Studio 2003.NET. Autor: Gerhard Krucker Zaunackerstrasse Rubigen Datum: Plattform: MS Visual Studio 2003.NET (Win32 Console Application) */ #include <stdio.h> #include <conio.h> int main() { int eingabewert; int fakwert; printf("eingabewert n fuer Fakultaetsberechnung n!:") ; scanf("%d",&eingabewert); _asm{ mov eax,1 // 0! = Initialwert mov ecx,eingabewert // Zugriff auf C++ Variable cmp ecx,2 // Trivialfall n < 2 jl end $loop: imul ecx // n = n * (n-1)! dec ecx // n = n -1 cmp ecx,2 // Ende wenn n < 2 jnl $loop end: mov fakwert,eax // In C++ Variable speichern } printf("resultat: %d!=%d\n", eingabewert,fakwert); while (!kbhit()); return 0; } Die Umsetzung des gesamten Programms erfolgt bei VS.NET 2003 VC7:

9 HTI Burgdorf 9 Bild 5: Mixed Language Darstellung im Debugger des Codes nach Beispiel 3. Bild 6: Ablauf und Ausgabe des Programmes nach Beispiel 3.

10 HTI Burgdorf 10 Zugriff auf C/C++ Runtime Library Funktionen Im integrierten Assembler können auch C/C++ Funktionen der Runtime-Library verwendet werden. Ebenso sind auch Aufrufe der Win32-API möglich. Leider sind die RTL-Funktionen nicht sehr detailliert dokumentiert. Am besten benutzt man die Funktion zuerst einmal in der Hochsprache. Dann schaut man im disassemblierten Code nach wie die Funktion auf Assemblerebene genau heisst und wie die Parametrisierung erfolgt. Ein Zugriff auf inline-definierte -Funktionen ist aus nahe liegenden Gründen nicht möglich. Beispiel 4: C-Funktionsaufruf in _asm Anweisungen. Das folgende Beispiel zeigt den Zugriff auf C-Variablen und den Aufruf der printf(..)-funktion. Die Ausgabe erfolgt einmal direkt in der Hochsprache und ein weiteres mal auf Stufe Assembler: /* Beispiel zum Aufruf von C-Libraryfunktionen und Zugriff auf C-Variablen aus dem Inline-Assemblerblock. Autor: Gerhard Krucker Datum: Plattform: MS Visual Studio 2003.NET (Win32 Console Application) */ #include <conio.h> // Fuer kbhit() #include <stdio.h> int main() { int a=1,b=2; const char fmtstr[]="werte nach _asm-sequenz:\na=%d, b=%d\n"; const char *f=fmtstr; _asm{ mov eax, a // Zugriffe auf die C-Variablen Werte vertauschen mov ebx, b mov b,eax mov a,ebx }; printf(fmtstr,a,b); // Direkte Ausgabe // Ausgabe in Assembler mit der printf-library-funktion _asm{ push b push a lea eax,fmtstr push eax call printf // Aufruf der printf-libraryfunktion add esp,0ch // Stackbereinigung (Parameter wieder entfernen) } while (!kbhit()); return 0; } Bemerkung: Beim Aufruf der printf-rtl-funktion im _asm-block muss ein Zeiger auf den Formatstring fmtstr übergeben werden. Dies erfolgt hier mit LEA/PUSH. Ein direktes PUSH OFFSET funktioniert (eigenartigerweise) nicht. Der gezeigte Code wird durch MS VC umgesetzt:

11 HTI Burgdorf 11 Bild 7: Disassemblierte Darstellung des Programms nach Beispiel 4 mit Aufruf einer Funktion der C- Runtime Library. Plattform:MS Visual Studio.NET 2003 VC7. Bild 8: Ablauf und Ausgabe des Programms nach Beispiel 4.

12 HTI Burgdorf 12 VC7 kann beim Kompilieren ein kommentiertes Assemblerlisting als *.cod-file erzeugen. Es enthält den vom Compiler erzeugten Zwischencode aus der Hochsprache für den Assembler. Dieses File kann zur Lokalisierung von Fehlern in den _asm-anweisungen nützlich sein. ; Listing generated by Microsoft (R) Optimizing Compiler Version TITLE.\InlineAsmCFunction.c.386P include listing.inc gt 510.model FLAT else _TEXT SEGMENT PARA USE32 PUBLIC 'CODE' _TEXT ENDS _DATA SEGMENT DWORD USE32 PUBLIC 'DATA' _DATA ENDS CONST SEGMENT DWORD USE32 PUBLIC 'CONST' CONST ENDS _BSS SEGMENT DWORD USE32 PUBLIC 'BSS' _BSS ENDS $$SYMBOLS SEGMENT BYTE USE32 'DEBSYM' $$SYMBOLS ENDS $$TYPES SEGMENT BYTE USE32 'DEBTYP' $$TYPES ENDS _TLS SEGMENT DWORD USE32 PUBLIC 'TLS' _TLS ENDS ; COMDAT??_C@_0CF@FDELPAMO@Werte?5nach?5_asm?9Sequenz?3?6a?$DN?$CFd?0?5b@ CONST SEGMENT DWORD USE32 PUBLIC 'CONST' CONST ENDS ; COMDAT _main _TEXT SEGMENT PARA USE32 PUBLIC 'CODE' _TEXT ENDS sxdata SEGMENT DWORD USE32 'SXDATA' sxdata ENDS FLAT GROUP _DATA, CONST, _BSS ASSUME CS: FLAT, DS: FLAT, SS: FLAT endif INCLUDELIB LIBCD INCLUDELIB OLDNAMES PUBLIC _main PUBLIC??_C@_0CF@FDELPAMO@Werte?5nach?5_asm?9Sequenz?3?6a?$DN?$CFd?0?5b@ ; `string' EXTRN _kbhit:near EXTRN _printf:near EXTRN RTC_InitBase:NEAR EXTRN RTC_Shutdown:NEAR EXTRN RTC_CheckEsp:NEAR ; COMDAT rtc$imz ; File s:\e3p \inf3 spezial\inf3 uebungen\inlineasmcfunction\inlineasmcfunction.c rtc$imz SEGMENT RTC_InitBase.rtc$IMZ DD FLAT: RTC_InitBase rtc$imz ENDS ; COMDAT rtc$tmz rtc$tmz SEGMENT RTC_Shutdown.rtc$TMZ DD FLAT: RTC_Shutdown rtc$tmz ENDS ; COMDAT??_C@_0CF@FDELPAMO@Werte?5nach?5_asm?9Sequenz?3?6a?$DN?$CFd?0?5b@ CONST SEGMENT??_C@_0CF@FDELPAMO@Werte?5nach?5_asm?9Sequenz?3?6a?$DN?$CFd?0?5b@ DB 'Wer' DB 'te nach _asm-sequenz:', 0aH, 'a=%d, b=%d', 0aH, 00H ; `string' ; Function compile flags: /Odt /RTCsu /ZI CONST ENDS ; COMDAT _main _TEXT SEGMENT _f$ = -80 ; size = 4 _fmtstr$ = -68 ; size = 37 _b$ = -20 ; size = 4 _a$ = -8 ; size = 4 _main PROC NEAR ; COMDAT ; 11 : { int a=1,b=2; push ebp b ec mov ebp, esp ec sub esp, 276 ; H push ebx 0000a 56 push esi 0000b 57 push edi 0000c 8d bd ec fe ff ff lea edi, DWORD PTR [ebp-276] b mov ecx, 69 ; H b8 cc cc cc cc mov eax, ; cccccccch 0001c f3 ab rep stosd 0001e c7 45 f mov DWORD PTR _a$[ebp], c7 45 ec mov DWORD PTR _b$[ebp], 2 ; 12 : const char fmtstr[]="werte nach _asm-sequenz:\na=%d, b=%d\n"; 0002c b mov ecx, be mov esi, OFFSET FLAT:??_C@_0CF@FDELPAMO@Werte?5nach?5_asm?9Sequenz?3?6a?$DN?$CFd?0?5b@ d 7d bc lea edi, DWORD PTR _fmtstr$[ebp] f3 a5 rep movsd 0003b a4 movsb ; 13 : ; 14 : const char *f=fmtstr; 0003c 8d 45 bc lea eax, DWORD PTR _fmtstr$[ebp] 0003f b0 mov DWORD PTR _f$[ebp], eax ; 15 : _asm{ mov eax, a // Zugriffe auf die C-Variablen Werte vertauschen b 45 f8 mov eax, DWORD PTR _a$[ebp]

13 HTI Burgdorf 13 ; 16 : mov ebx, b b 5d ec mov ebx, DWORD PTR _b$[ebp] ; 17 : mov b,eax ec mov DWORD PTR _b$[ebp], eax ; 18 : mov a,ebx 0004b 89 5d f8 mov DWORD PTR _a$[ebp], ebx ; 19 : }; ; 20 : printf(fmtstr,a,b); // Direkte Ausgabe 0004e 8b 45 ec mov eax, DWORD PTR _b$[ebp] push eax b 4d f8 mov ecx, DWORD PTR _a$[ebp] push ecx d 55 bc lea edx, DWORD PTR _fmtstr$[ebp] push edx 0005a e call _printf 0005f 83 c4 0c add esp, 12 ; cH ; 21 : // Ausgabe in Assembler mit der printf-library-funktion ; 22 : _asm{ push b ff 75 ec push DWORD PTR _b$[ebp] ; 23 : push a ff 75 f8 push DWORD PTR _a$[ebp] ; 24 : lea eax,fmtstr d 45 bc lea eax, DWORD PTR _fmtstr$[ebp] ; 25 : push eax 0006b 50 push eax ; 26 : call printf // Aufruf der print-libraryfunktion 0006c e call _printf ; 27 : add esp,0ch // Stackbereinigung (Parameter wieder entfernen) c4 0c add esp, 12 ; cH $L876: ; 28 : } ; 29 : while (!kbhit()); e call _kbhit c0 test eax, eax 0007b jne SHORT $L d eb f5 jmp SHORT $L876 $L877: ; 30 : return 0; 0007f 33 c0 xor eax, eax ; 31 : } push edx b cd mov ecx, ebp push eax d lea edx, DWORD PTR $L b e pop eax a pop edx f pop edi e pop esi b pop ebx c add esp, 276 ; H 0009b 3b ec cmp ebp, esp 0009d e call RTC_CheckEsp 000a2 8b e5 mov esp, ebp 000a4 5d pop ebp 000a5 c3 ret 0 $L894: 000a DD 1 000aa DD $L893 $L893: 000ae bc ff ff ff DD -68 ; ffffffbch 000b DD 37 ; H 000b DD $L892 $L892: 000ba 66 DB 102 ; H 000bb 6d DB 109 ; dH 000bc 74 DB 116 ; H 000bd 53 DB 83 ; H 000be 74 DB 116 ; H 000bf 72 DB 114 ; H 000c0 00 DB 0 _main ENDP _TEXT ENDS END

14 HTI Burgdorf 14 Beispiel 5: String-Funktionsaufruf in _asm Anweisung. Das folgende Beispiel zeigt die Benutzung einer C-Stringfunktion aus C++. Dazu muss im C/C++ Teil ein #include <string.h> erfolgen, auch wenn die Funktion erst auf Assemblerebene verwendet wird. Dies gilt auch für andere Funktionen der Runtime Library. Bild 9, Bild 10,: Programm und Ablauf mit Ausgabe des Programms nach Beispiel 5.

15 HTI Burgdorf 15 Zugriff auf in Assemblermodulen definierte Symbole Umgekehrt ist prinzipiell auch aus der Hochsprache ein Zugriff auf Assemblersymbole möglich. Dazu muss bei Datensymbolen (Variablen, Konstanten) eine extern-deklaration erfolgen. Die Referenzen werden dann über den Linker aufgelöst. Bei Funktion muss im Hochsprachenteil ein Funktionsprototyp definiert werden. Bei den Parametern und Resultatrückgaben ist besondere Vorsicht walten zu lassen, da verschiedene Konfigurationsmöglichkeiten bestehen und Fehler sich meist sofort verheerend auswirken. In _asm-blöcken definierte Daten liegen grundsätzlich im Codesegment. Daher ist eine Definition von Daten und Datenbereichen in einem _asm-block nicht sinnvoll. Externe Assemblermodule Externe Assemblermodule können mit Microsoft Visual Studio einfach erzeugt und in ein C/C++ Projekt eingebunden werden. Dazu wird zuerst das Projekt mit der main()-funktion in der Hochsprache aufgesetzt. Das Assemblermodul wird als Textdatei mit *.asm-erweiterung dem Projekt zugefügt. Das Assemblermodul hat in 32-Bit PC-Plattformen immer denselben schematischen Aufbau:.386 ; 32 Bit Bit Register.model flat, c ; 32-Bit Adressbereich, C-Konventionen fuer Namenregeln.code.data end ; Assembler codierte Funktionen ; Assembler Daten Im Gegensatz zu C/C++ Quelltexten müssen *.asm-quelletexte vor dem Kompilieren (Assemblieren) immer explizit gespeichert werden, sonst werden die Änderungen nicht übernommen. Es empfiehlt sich im Modul immer die benutzten Register zu sichern, insbesondere EBP. Sie beinhalten eventuell Werte, die später wieder verwendet werden. Für das Erstellen von Assemblermodulen muss sichergestellt sein dass der MASM Assembler (ML.EXE) im Compilerverzeichnis installiert ist. Er kann von der Setup-CD einfach in das \bin- Verzeichnis kopiert werden. Soll alles aus der IDE bearbeitet und kompiliert werden können, wird das Assembler-Sourcfile mit der Extension.asm versehen und Kompilervorschrift von Hand im Property-Sheet des Assembler- Files eingetragen: (Vgl. auch Übungsbeispiel am Ende des Kapitels) Bild 11: Einzutragende Kommandozeile für den Assembleraufruf beim Kompilieren des Files. Der Ausgabefilename muss ebenfalls angegeben werden. Hierzu wird zweckmässigerweise das $(InputName) benutzt.

16 HTI Burgdorf 16 Parameterübergaben Eine nicht zu unterschätzende Fehlerquelle stellen die Datenübergabeschnittstellen dar. Bei den Parameter, die an eine Assemblerfunktion übergeben werden können, muss zwischen folgenden Prinzipien unterschieden werden: _cdecl Das ist das Standardübergabeprinzip in C/C++. Die Parameter werden in der umgekehrten Reihenfolge der Definition auf den Stack gelegt und die Stackbereinigung, d.h. das Entfernen der Parameter vom Stack erfolgt durch den Aufrufer. Der folgende Code void func(int var1, char var2, int var3); legt Parameter in der Reihenfolge (var3,var2,var1) auf den Stack. Dies sei an einem Minimalbeispiel gezeigt. C-Hauptmodul: Im Hauptmodul wird der Funktionsprototyp definiert. Normalerweise gilt für C-Compiler die Einstellung cdecl als Standard, dann kann diese Angabe entfallen. Bild 12: In C standarmässige Parameterübergabe in _cedcl Konvention nach C. Im Hochsprachenteil wird die externe Funktion über den Prototyp definiert. In einem C++ Programm muss der Funktionsprototyp mit extern C definiert werden damit keine C++ Typinformation an den Funktionsnamen angehängt wird. Dies würde zu einem Linker-Fehler führen.

17 HTI Burgdorf 17 Assemblermodul: Im Assemblermodul wird die Funktion in proc endp codiert. Der Funktionsname wird mit public c exportiert, d. h. für die anderen Module sichtbar gemacht. Der Hinweis c bei proc und public bewirkt, dass die Namen automatisch mit einem Underscore (als _func) exportiert werden, weil der C- Compiler alle Namen mit einem Underscore verwaltet. Ferner werden c-exportierte Namen casesensitive behandelt. Bild 13: Assemblermodul zur Parameterübergabe nach C. Die Funktion wird mit proc c definiert. Der Funktionsname wird mit public c exportiert. Das Programm wird gestartet und bis zur ret-anweisung im Assemblermodul mit dem Debugger ausgeführt. Wir sehen nachher wie die Parameter im Stack liegen (Fenster unten rechts). Ebenso sieht man im disassemblierten Code von main(), dass nach dem Funktionsaufruf call func(int signed char,int) die Stackbereinigung mit add esp,0x0c erfolgt.

18 HTI Burgdorf 18 Bild 14: Programmablauf im Debugger mit Parameterübergabe nach C. Plattform: MS Visual Studio.NET 2003 VC7.

19 HTI Burgdorf 19 _stdcall Bei der _stdcall Konvention erfolgt die Stackbereinigung durch die aufgerufene Einheit selbst. Praktisch alle Betriebssystemfunktionen von Windows arbeiten mit _stdcall-übergaben, weil dies eine kleine Einsparung an Code bringt. _stdcall löst die _pascal Aufrufkonvention ab. Bei der erfolgt ebenfalls die Stackbereinigung durch den Aufgerufenen, die Parameter werden aber in umgekehrter Reihenfolge auf den Stack gebracht. Weiter wurden bei _pascal alle Symbole nur in Grossschrift behandelt. Die Parameterübergabereihenfolge ist genau gleich wie bei _cdecl. Für das vorherige Beispiel mit _stdcall void _stdcall func(int var1, char var2, int var3); werden die Parameter in der Reihenfolge (var3,var2,var1) auf den Stack gelegt. Dies sei auch an folgendem Minimalbeispiel gezeigt. C-Hauptmodul: Der Funktionsprototyp wird mit Namen-Prefix _stdcall versehen. Bild 15: Parameterübergabe mit _stdcall Konvention. Im Hochsprachenteil wird die externe Funktion mit dem Prefix _stdcall über den Prototyp definiert. Assemblermodul: Die Funktion wird hier als proc ohne zusätzliche Erweiterungen definiert. Die Publikation verlangt aber nach dem Funktionsnamen gefolgt von der Anzahl Bytes, die auf dem Stack übergeben werden. Für dieses Beispiel wird public eingesetzt. Der Assembler exportiert das Symbol automatisch mit einem führenden Underscore als Wenn man nicht genau weiss, wie viele Bytes über den Stack übergeben werden, kann man anhand des Linker-Fehlers beim nicht aufgelösten Symbol die Anzahl herauslesen. Bild 16: Assemblermodul zur Parameterübergabe mit _stdcall. Die Funktion wird mit proc definiert. Der Funktionsname wird mit public exportiert. Der Funktionsname muss und der Anzahl im Stack übergebener Bytes erweitert werden.

20 HTI Burgdorf 20 Das Programm wird gestartet und bis zur ret 0x0c-Anweisung im Assemblermodul mit dem Debugger ausgeführt. Wir sehen nachher wie die Parameter im Stack liegen (Fenster unten rechts). Bild 17: Programmablauf im Debugger mit Parameterübergabe mit _stdcall. Plattform: MS Visual Studio.NET 2003 VC7. Im disassemblierten Code von main() sieht man, dass nach dem Funktionsaufruf call func(int signed char,int) keine Stackbereinigung erfolgt. Diese wird in der aufgerufenen Funktion mit ret 0Ch erledigt. Die Angabe 0Ch besagt, dass beim Rücksprung 0Ch=12=3 Parameter à 4Bytes vom Stack gelöscht werden.

21 HTI Burgdorf 21 Andere Parameterübergabetechniken Die Übergabemethoden _stdcall und _cdecl sind sicherlich die beiden wichtigsten Verfahren. Bei C++ wird standardmässig thiscall verwendet. Da aber in C++ sowieso externe Funktionsaufrufe nur im C-Namespace erfolgen sollen, ist diese Form weniger von Bedeutung. Bei _fastcall werden Parameer in Prozessorregistern und über den Stack übergeben. Das bringt eine kleine Laufzeitverbesserung. Weitere Informationen zu diesen Techniken werden am besten in der MSDN Library nachgelesen. Aus Gründen der Kompatibilität zu anderen Programmiersprachen existierten früher noch andere Verfahren. SYSCALL, STDCALL, BASIC, FORTRAN Auch sie unterscheiden sich in der Art und Reihenfolge wie die Argumente übergeben werden und wie die Stackbereinigung erfolgt. Sie werden heute aber von Microsoft nicht mehr unterstützt. Detaillierte Informationen sind in den produktespezifischen Programmierhandbüchern zu finden. [MASMPG-92],[BORASMBH-92],[BORASMRH-92]. Funktionswertrückgaben Grundsätzlich werden Funktionswerte im EAX Register zurückgegeben, ausser bei 8-Byte Strukturen, die im EDX:EAX Registerpaar zurückgeben werden. Für verschiedene C-Datentypen wird die im Speziellen: C-Datentyp Register Wortbreite char al 8 Bit short ax 16 Bit long eax 32 Bit Zeiger eax 32 Bit Struct Bis 4 Bytes: eax >4 Bytes über Variablenreferenz Array Zeiger in eax 32 Bit Werden Strukturvariablen >4 Bytes retourniert, werden diese automatisch mit einer MOVS- Anweisung übergeben. In 16-Bit Modulen werden 32-Bit Werte über DX:AX zurück gegeben, wobei DX das höherwertige Wort ist. Gleitkommawerte des Typs double oder float werden in st(0) der FPU retourniert. [MSDN]

22 HTI Burgdorf 22 Beispiel 6: Fakultätsberechnung mit externem Assemblermodul und Funktionswertrückgabe. In einem C++ Programm soll mit einem externen Assemblermodul eine Funktion fak zur Verfügung gestellt werden. Das Argument wird in C-Standardnotation über Parameter übergeben, das Resultat über Funktionswertrückgabe. Mit einem Hauptprogramm wird die Anwendung der Funktion gezeigt. Lösung: Da es sich um ein C++ Programm handelt (File-Extension des aufrufenden Moduls ist *.cpp), muss der Funktionsprototyp als extern C definiert werden. Das Assemblermodul wird mit der Funktionalität analog Beispiel 3 erstellt. Der Funktionsname wird über fak proc c fak endp definiert und mit public c fak exportiert: Bild 18, Bild 19: Parameterübergabe und Funktionswertrückgabe bei einer extern C definierten Funktion nach Beispiel 6. Plattform: MS Visual Studio.NET 2003 VC7.

23 HTI Burgdorf 23 Bild 20: Debuggerfenster der CPU mit Darstellung des erzeugten Codes nach Beispiel 6. Plattform: MS Visual Studio.NET 2003 VC7.

24 HTI Burgdorf 24 Alternative Lösung: Man kann die Direktive extern C weglassen, wenn die C++ Namenerweiterung für die extern definierte Funktion bekannt ist. Die Namenerweiterung wurde notwendig, weil in C++ Funktionen denselben Namen haben dürfen, sofern sie sich in den Parametern unterscheiden. Die Unterscheidung erfolgt in Typ und Anzahl. Für dieses Beispiel wäre der erweiterte Funktionsname?fak@@YAHH@Z. Dieser Name wird am einfachsten aus der Fehlermeldung beim Linken bestimmt. Die Funktion muss auf Stufe Assembler als syscall definiert werden. syscall bewirkt, dass der Name case-sensitive behandelt wird, aber ohne Underscore exportiert wird. Die Stackbereinigung erfolgt bei syscall wie bei c durch den Aufrufer. (Vgl. auch [MSAMPG-92], S.309) Bild 21, Bild 22: Parameterübergabe und Funktionswertrückgabe bei einer C++ definierten Funktion nach Beispiel 6 Der Funktionsname in Assembler trägt die Namenerweiterung?..@@YAHH@Z. Plattform: MS Visual Studio.NET 2003 VC7.

25 HTI Burgdorf 25 Bild 23: Debuggerfenster der CPU mit Darstellung des erzeugten Codes für die alternative Lösung nach Beispiel 6. Aus Platzgründen wurde auf die Darstellung der main-funktion verzichtet. Plattform: MS Visual Studio.NET 2003 VC7. Auf das Fenster der C++.-Rahmenprogrammes wurde verzichtet, da Microsoft Visual C++ für kleine Anwendungen extrem viel Code erzeugt. Borland C++ Builder der Code deutlich kompakter. Bild 24: Ablauf des Programmes mit der alternativen Lösung nach Beispiel 6. Plattform: MS Windows XPSP2

26 HTI Burgdorf 26 Naked Functions Naked Functions sind Funktionsaufrufe bei denen der Compiler keinen Prolog/ Epilog für das Sichern der Registerinhalte und Stackbereinigung erzeugt. Diese Funktionen werden mit dem Prefix declspec(naked)definiert. Dadurch kann innerhalb eines C/C++ Programmes mit inline-assembler eine Funktion definiert werden, die ihren eigenen, nicht standardmässigen Prozedurrahmen haben kann. Die wird benötigt wenn man beispielsweise extern aus einem anderen Sprachkontext als C/C++ auf die Funktion zugreifen will. Als Beispiele wären ein VxD oder ein MS-DOS Device Handler denkbar. Einschränkungen für Naked Functions Folgende Aktionen sind in Naked Functions nicht zulässig: Die Anweisung return C++ Exception Handling Alle Formen von setjmp _alloca Wegen des fehlenden Prozedur-Prologs sind auch initialisierte Lokalvariablen nicht erlaubt. Dies gilt auch für lokale C++ Objekte. Definition von Naked Functions Eine Naked Funktion wird durch die erweiterte Attribut-Syntax declspec(naked) gekennzeichnet. Diese Definition erfolgt ausschliesslich bei der Implementierung der Funktion, nie beim Prototyp (Deklaration). Die Grobstruktur der Funktion ist typischerweise: declspec( naked ) int func( formale_parameter ) { // Funktionskoerper } Oder unter Verwendung eines Makros: #define Naked declspec( naked ) Naked int func( formale_parameter ) { // Funktionskoerper } Das naked-attribut steuert nur die Codeerzeugung der nachfolgenden codierten Funktion. Sie ist nicht Bestandteil des Funktionstyps. Aus diesem Grund können auch keine naked-funktionszeiger definiert werden. Ebenso ist naked beim Funktionsprototyp nicht erlaubt und kann nicht auf andere Daten angewandt werden. declspec( naked ) int func(); // Fehler: naked ist beim Funktionsprototyp nicht erlaubt // nur bei der Implementierung. declspec( naked ) int i; // Fehler: naked Attribute ist bei Daten nicht zulaessig.

27 HTI Burgdorf 27 Da kein Prozedurprolog mit Stackmanagement erzeugt wird, kann weder formale Parameter, noch auf herkömmliche Lokalvariablen direkt Bezug genommen werden. Um dennoch in Naked Functions mit stackbasierten Lokalvariablen arbeiten zu können, wurde neu das Assemblersymbol LOCAL_SIZE eingeführt. Es wird benutzt, um Speicherplatz für Lokalvariablen in einer Naked Funktion auf dem Stack bereitzustellen. Es beinhaltet den Platzbedarf aller in der Funktion benutzten Lokalvariablen. Die Bereitstellung des Speicherplatzes auf dem Stack erfolgt nicht automatisch, sondern muss explizit codiert werden. Das Vorgehen ist dabei genau gleich wie beim automatisch erzeugten Prozedur Epilog mit Lokalvariablen. Von der Benutzung her kann LOCAL_SIZE kann als Operand oder in einem Ausdruck verwendet werden. Beispiele: mov eax, LOCAL_SIZE /* Immediate Operand */ mov eax, LOCAL_SIZE + 4 /* Ausdruck */ mov eax, [ebp - LOCAL_SIZE] /* Ausdruck */ Formale Parameter müssen selbst vom Stack gelesen und verwaltet werden. Die Angabe im Funktionskopf ist nur eine Information für die Stackbereinigung. Der Zugriff auf den letztgepushten Parameter wäre [esp+4], vgl. auch Beispiel 7. Beispiel 7: Fakultätsberechnung mit Naked Funktion. Analog Beispiel 3 soll mit einer Assemblersequenz die Fakultät einer Ganzzahl berechnet werden. Die Naked-Funktion wird mit dem Prefix declspec(naked) versehen. In der Funktion kann aber nicht direkt auf den formalen Parameter zugegriffen werden. Er muss selbst mit mov..,[esp+4] vom Stack gelesen werden. Sonst gelten dieselben Regeln wie für normale Inline- Assemblersequenzen. Bild 25: Programm mit einer Naked Function nach Beispiel 7 analog Beispiel 3.

28 HTI Burgdorf 28 Für eine Eingabe von n=6 wird der Ablauf im Debugger: Bild 26: Ablauf des Programmes mit einer Naked Function nach Beispiel 7.

29 HTI Burgdorf 29 Beispiel 8: Naked Funktion mit Lokalvariablen. Analog Beispiel 3 soll mit einer Assemblersequenz die Fakultät einer Ganzzahl berechnet werden. Die Naked-Funktion wird mit dem Prefix declspec(naked) versehen. In der Funktion kann aber nicht direkt auf den formalen Parameter zugegriffen werden. Er muss selbst mit mov..,[esp+4] vom Stack gelesen werden. Sonst gelten dieselben Regeln wie für normale Inline- Assemblersequenzen. Bild 27: Programme mit einer Naked Function und Lokalvariablen in der Naked Function nach Beispiel 8. Plattform: MS Windows XPSP2 Ein Ablauf für eine Eingabe von n=6 wird mit dem Debugger:

30 HTI Burgdorf 30 Bild 28: Ablauf des Programmes mit der Eingabe n=6 unter dem Debugger in der Naked Function mit Lokalvariablen nach Beispiel 8. Bild 29: Hauptprogramm mit der Naked Function mit Lokalvariable nach Beispiel 8.

31 HTI Burgdorf 31 Literaturhinweise: [MSQ-1] Microsoft Knowlwedge Base Q HOWTO: Call 16-bit Code from 32-bit Code Under Windows 95, Windows 98, and Windows Me. [MSAMPG-92] Microsoft MASM 6.1 Programmer s Guide, Microsoft Corporation 1992, Originaldokumentation zu MASM 6.1. [BORASMBH-92] Borland Turbo Assembler Benutzerhandbuch, Borland GmbH 1992, Originaldokumentation zu TASM, Bestandteil von Turbo Pascal für Windows 1.0 [BORASMRH-92] Borland Turbo Assembler Referenzhandbuch, Borland GmbH 1992, Originaldokumentation zu TASM, Bestandteil von Turbo Pascal für Windows 1.0 Ergänzend oder produkteorientiert: [RHO01] Assembler Ge-Packt, Joachim Rhode, mitp-verlag 2001, ISBN (Taschenbuch) [ROM03] Assembler - Grundlagen der Programmierung, Marcus Roming/ Joachim Rhode, mitp-verlag 2003, ISBN X [MÜL02] Assembler - Die Profireferenz, Oliver Müller Franzis Verlag 2002, 3. Auflage, ISBN [POD95] Das Assemblerbuch, Trutz Eyke Podschun, Addison Wesley 1995, 2. Auflage, ISBN [BAC02] [RUS82] Programmiersprache Assembler Eine strukturierte Einführung, Rainer Backer, rororo Rowohlt 9.Auflage 2002, ISBN (Taschenbuch) Das 8086/8088 Buch Programmieren in Assembler und Systemarchitektur, Russel Rector/ George Alexy, tewi Verlag 1982, ISBN X [BRA86] Programmieren in Assembler für die IBM Personalcomputer, David H. Bradley, Verlag Carl Hanser 1986, ISBN Mikrocontroller: [MAN00] C für Mikrocontroller, Burkhard Mann, Franzis Verlag 2000, (Schwerpunkt IAR-C Compiler mit AVR- und 51er-Mikrocontroller) [BAL92] MC Tools 7 Der Keil C-Compiler ab V3.0 Einführung und Praxis, Michael Baldischweiler, Verlag Feger & Co 1992, ISBN (Nur Keil C-51) Online: [MSDN]

32 HTI Burgdorf 1 Informatik 3 Übung Assemblermodule in MS VC7 Die nachfolgenden Ausführen zeigen die Schritte zum Erstellen eines C Programmes mit einem externen Assemblermodul mit der Programmierplattform MS Visual Studio 2003.NET. Das Programm ruft aus der Hochsprache eine in Assembler codierte Funktion zur Ausgabe eines String auf. Im Assemblermodul wird dann für die Ausgabe wiederum seinerseits wieder auf eine Bibliotheksfunktion von C Bezug genommen. Vorgehen 1. Visual C++ starten. Neues Projekt, ev. neue Solution (Arbeitsmappe) erzeugen. Geben Sie der Solution den Namen Mixed Language Programs, dem Projekt den Namen SimpleAsm. Ausgabe: , G. Krucker File: Assembler in C-CPP Programmen.doc

33 HTI Burgdorf 2 Informatik 3 Übung 2. Nun C Quelltextfile nach bekanntem Vorgehen erstellen. Wichtig ist, dass das File mit der Extension *.C gespeichert wird, sonst werden die Symbole als dekorierte C++Symbole exportiert. Ausgabe: , G. Krucker File: Assembler in C-CPP Programmen.doc

34 HTI Burgdorf 3 Informatik 3 Übung und codieren: 3. Nun das Assemblerquelltextfile erstellen. Es wird wie ein C-File erstellt, nur das man hier Als Typvorgabe Text File wählt und die Extension.asm benutzt: Ausgabe: , G. Krucker File: Assembler in C-CPP Programmen.doc

35 HTI Burgdorf 4 Informatik 3 Übung Damit das File im Projekt automatisch assembliert wird, müssen dem File im Solution Explorer die Eigenschaften eingestellt werden. Hierzu bei SimpleAsm.asm mit der rechten Maustaste die Properties öffnen und im Eintrag General die Kommandozeile und das Objektverzeichnis genauso eingeben wie nachfolgend gezeigt. Dieser Eintrag ist für alle Assemblerfiles genauso vorzunehmen. 4. Nun den Assemblercode eingeben. Hier retourniert die aus C aufgerufene Funktion den Wert 0x1234 im Register EAX. Dann das Modul mit Compile assemblieren. Es sollte ohne Fehlermeldung erstellt ein Objektmodul SimpleAsm.obj werden Ausgabe: , G. Krucker File: Assembler in C-CPP Programmen.doc

36 HTI Burgdorf 5 Informatik 3 Übung 5. Nun auch das C-File kompilieren und die gesamte Anwendung builden. Ein Linkerfehler deutet auf eine Fehler in der Namenschreibung der Funktion hin. Die kann im C- Modul oder im Assemblermodul liegen. 6. Dann das Programm mit einem Breakpoint am Ende starten. Im Disassembly-Window kann der Code des Assemblermoduls und der Hochsprache direkt angeschaut werden. Ebenso können auch im Assemblermodul Haltepunkte gesetzt werden. Ausgabe: , G. Krucker File: Assembler in C-CPP Programmen.doc

37 HTI Burgdorf 6 Informatik 3 Übung Ausgabe: , G. Krucker File: Assembler in C-CPP Programmen.doc

38 HTI Burgdorf 7 Informatik 3 Übung 7. Über den Knopf New Project wird ein neues Programmierprojekt eröffnet. Das Projekt verwaltet alle zugehörigen Files und Einstellungen. Die Programmerstellung erfolgt immer projektorientiert. Im Dialogfenster Visual C++ Projects und das Win32 Project Icon anklicken, den Namen für das Projekt eingeben und den Speicherpfad wählen. Mit OK das Dialogfenster schliessen. 8. Im folgenden Wizard-Dialog Application Settings anklicken: Ausgabe: , G. Krucker File: Assembler in C-CPP Programmen.doc

39 HTI Burgdorf 8 Informatik 3 Übung Ausgabe: , G. Krucker File: Assembler in C-CPP Programmen.doc