Programmiersprachen Einführung in C

Transkript

1 Programmiersprachen Einführung in C Teil 1: Von der Maschinensprache zu C Prof. Dr. Maschinensprache: MIPS R2000 Was bewirkt folgendes Programm:

2 Maschinensprache: MIPS R2000 MIPS R2000 ist ein 32-Bit-Prozessor Alle Maschinenbefehle sind 32 Bit lang, verschiedene Formate 32-Bit-Worte, 32 Prozessorregister mit je 32 Bit Maschinenbefehle können direkt in Assemblerbefehle übersetzt werden Die ersten (und ggf. auch letzten) 6 Bits spezifizieren den Befehl Assemblerbefehle sind einfacher zu merken als Bitmuster Die restlichen Bits müssen je nach Befehl unterschiedlich interpretiert werden 3 Maschinensprache: MIPS R

3 Maschinensprache: MIPS R2000 Was bewirkt folgendes Programm: addiu sw sw sw sw sw lw lw addiu slti sw bne sw lui lw jal addiu lw addiu Maschinensprache: MIPS R2000 Was bewirkt folgendes Programm: addiu 11101,11101, sw 11101,11111, sw 11101,00100, sw 11101,00101, sw 11101,00000, sw 11101,00000, lw 11101,01110, lw 11101,11000, multu 01110,01110, addiu 01110,01000, slti 01000,00001, sw 11101,01000, mflo 00000,00000,01111,00000 addu 11000,01111,11001,00000,00000 bne 00001,00000, sw 11101,11001, lui 00000,00100, lw 11101,00101, jal addiu 00100,00100, lw 11101,11111, addiu 11101,11101, jr 11111, addu 00000,00000,00010,00000,

4 Maschinensprache: MIPS R2000 konturierte Bits haben keine Bedeutung (Füllung, da alle Befehle 32 Bit lang sein müssen) unterstrichene Bits sind feste Werte Fünfer-Gruppen von Bits (als Binärzahlen ohne Vorzeichen Werte zwischen 0 und 31) geben die Nummer eines Registers ($0 bis $31) an 7 Aufbau des MIPS R

5 Assembler: MIPS R2000 Was bewirkt folgendes Programm: addiu $29, $29, -32 sw $31, 20($29) sw $4, 32($29) sw $5, 36($29) sw $0, 24($29) sw $0, 28($29) lw $14, 28($29) lw $24, 24($29) multu $14, $14 addiu $8, $14, 1 slti $1, $8, 101 sw $8, 28($29) mflo $15 addu $25, $24, $15 bne $1, $0, -9 sw $25, 24($29) lui $4, 4096 lw $5, 24($29) jal addiu $4, $4, 1072 lw $31, 20($29) addiu $29, $29, 32 jr $31 move $2, $0 9 Einfacher Assembler: MIPS R2000 Maschinenbefehle sind direkt in eine lesbarere Form übersetzt worden: in addiu $29, $29, -32 Register werden noch durch ihre Nummer bezeichnet; die in ihnen gespeicherten Werte haben so noch keine Bedeutung: $29 ist eigentlich der Stapelzeiger 10 5

6 Einfacher Assembler: MIPS R2000 Kontrollstrukturen (if goto-schleifen) sind nur schwer zu erkennen, und goto ist relativ zur konkreten Position des Verzweigungsbefehls: slti $1, $8, 101 und bne $1, $0, -9 Speicheroperationen (load, store) werden relativ zu einem Pointer-Register durchgeführt: sw $31, 20($29) bedeutet, dass der Inhalt von Register Nummer 31 (die Rücksprungadresse als 32-Bit-Wort) im Hauptspeicher ab der Stelle (Inhalt von Register 29)+20 abgespeichert wird. 11 Einfacher Assembler: MIPS R2000 Funktionen werden durch Sprung an eine konkrete Stelle im Hauptspeicher aufgerufen: jal ruft die Funktion (welche?) auf, die mit der Speicheradresse (durch 4 teilbar) beginnt. Es gibt keine Variablen, nur im Hauptspeicher vorhandene Werte, auf die mit Hilfe von Pointern gezeigt werden kann: lw $24, 24($29) sw $25, 24($29) Jeder dieser einfachen Assembler-Befehle entspricht genau einem Maschinenbefehl 12 6

7 Assembler: Registerkonventionen 13 MIPS: Speicherorganisation 14 7

8 Assembler: MIPS R2000 Was bewirkt folgendes Programm:.data.align 0 str:.asciiz "The sum from is %d\n.text.align 2.globl main main: subu $sp, $sp, 32 sw $ra, 20($sp) sd $a0, 32($sp) sw $0, 24($sp) sw $0, 28($sp) loop: lw $t6, 28($sp) mul $t7, $t6, $t6 lw $t8, 24($sp) addu $t9, $t8, $t7 sw $t9, 24($sp) addu $t0, $t6, 1 sw $t0, 28($sp) ble $t0, 100, loop la $a0, str lw $a1, 24($sp) jal printf move $v0, $0 lw $ra, 20($sp) addu $sp, $sp, 32 jr $ra 15 Assembler: MIPS R2000 Neben echten Maschinenbefehlen stehen jetzt als Hilfe für den Programmierer: Direktiven an das Assemblerprogramm, kenntlich am., wie z.b..text und.data Labels, die als Variablennamen (str), abstrakte Sprungadressen (loop) oder Funktionsnamen (main, printf) dienen können. Dadurch wird es möglich, Programme übersichtlicher aufzuschreiben. Pseudobefehle, die mehrere Maschinenbefehle zusammenfassen, von der Hardware abstrahieren und den Code lesbarer machen: mul $t7, $t6, $t6 als Zusammenfassung von multu $14, $14 und mflo $

9 Assembler: Pointer.asciiz "The sum from is %d\n legt fest, dass die in Anführungszeichen stehende Zeichenfolge im ASCII-Code und nullterminiert im Speicher unter dem angegeben Label abzulegen ist (vgl. ASCII-Tabelle auf der nächsten Folie). la $a0, str lädt einen Pointer (Zeiger) auf die Variable str in das Register $a0 ( a für argument ); $a0 enthält also die Speicherstelle, in der das erste Zeichen des obigen Strings (also das T ) abgelegt ist. Auf das zweite Zeichen h kann man dann zugreifen, wenn man den Wert von $a0 um 1 erhöht und dann den Inhalt dieser Speicherstelle lädt. 17 ASCII-Zeichensatz 18 9

10 Unser erstes C-Programm #include <stdio.h> int main (int argc, char *argv[]) { int i; int sum = 0; for (i = 0; i <= 100; i = i + 1) sum = sum + i * i; printf ("The sum from is %d\n", sum); } 19 Unser erstes C-Programm #include <stdio.h> Die Sprache C enthält keine Konstrukte für Ein- oder Ausgabe, da diese jeweils stark vom Betriebssystem abhängen. Daher benötigt jedes C-Programm die jeweilige Standardbibliothek stdio.h int main (int argc, char *argv[]) Jedes C-Programm ist selbst eine Funktion, die von der Laufzeitumgebung (i.d.r dem Betriebssystem) aufgerufen wird. Als Ergebnis gibt diese Funktion eine ganze Zahl zurück, wobei negative Zahlen als Fehlercodes interpretiert werden

11 Unser erstes C-Programm Mit char *argv[] wird dem Hauptprogramm ein Array von char ( Characters ) übergeben (das main dann aber gar nicht nutzt). Arrays werden in C als Pointer auf einen nullterminierten String von Zeichen dargestellt. argv[] enthält also die Speicherstelle des ersten Zeichens dieses Strings, und der Dereferenzierungsoperator * bewirkt, dass der Inhalt dieser Speicherstelle betrachtet wird, und der ist vom Typ char. printf ist eine Funktion aus stdio.h; auf ihre Syntax gehen wir an geeigneter Stelle noch ein 21 Literatur Die auf dieser Seite enthaltenen Links Kernighan, Ritchie, Programmieren in C, 2. Auflage, Hanser