was genau bedeutet assembler und was daran ist so gut ?

[ich123abc]

was genau bedeutet assembler und was daran ist so gut ?

[Himmerlarschundzwirn]

Assembler ist reine Maschinensprache.

Direkter kannst du mit einem Computer nicht reden, außer mit 1 und 0 aber wer spricht das schon fließend? :-D

Und je direkter du mit dem Computer redest, umso kürzer sind Zeiten, die das System braucht, um das, was du von ihm willst in seine Sprache zu übersetzen.

War das jetzt gut erklärt? o.O

[ich123abc]

ich habs verstanden, danke ;-)

wie ist das bei videospielekonsolen, die werden ja gebaut und die spiele dann nur fuer das system geschrieben, bedeutet das das da die spiele auch immer in assembler geschrieben werden ?

[Himmerlarschundzwirn]

Naja soweit ich weiß (bitte korrigieren, wenn ich falsch liege) bieten die Konsolen eine Art Betriebssystem an, welches eine API (also eine Schnittstelle) enthält, auf deren Basis dann die Software (Spiele) programmiert werden.

Ich glaube NeedforSpeed wöllte ich nicht in Assembler programmieren :-)

[snils]

Assembler ist Assembler und steht über der Maschinensprache, welche diejenige ist, die wirklich von der Hardware an sich interpretiert und verarbeitet wird. 0101010010. jmp und eqn sind bereits "Abstraktionen". Gingen wir eine Stufe höher, kämen wir bei der Programmiersprache für Betriebssysteme schlechthin, C.

[Trinova]

ähm Assembler sind doch 1 und 0 bzw halt als Hexzahlen oder deren Mnemonics die ja aber eins zu eins übersetzt werden da "ADD" einfacher zu merken ist als der Hexcode. Also man programmiert schon nur Zahlen (Hex werden da nur benutzt weil man dann anstelle von 1101 D schreiben kann^^). Evtl entrollt der Assemblierer noch Schleifen um die Performance zu erhöhen wenn der Platz dafür reicht aber da höhrts dann auch schon auf.

[Himmerlarschundzwirn]

Joa, ist mir klar.

Hab ich das falsch erklärt oder wolltest nur nochmal zusammenfassen.

So, jetzt warte ich auf ein OS aus Nullen und Einsen :-D

[BOFH]

Konsolen brauchen normalerweise kein eigenes Betriebsystem, da die Zielplatform für die Entwickelt wird immer die gleiche ist. Multitasking ist in der Regel nicht notwendig, so das direkt gegen die Hardware programmiert werden kann. Bei alten Konsolen gab es definitiv kein Betriebsystem. Heute mit Xbox360, PS3 und Wii sieht das schon wieder ein bischen anderst aus, da die Konsolen immer mehr zusätzliche Mediacenterfunktionen übernehmen.

[Himmerlarschundzwirn]

Mist, ich wollte doch extra "aktuelle Konsolen" schreiben.

Dass ein NES kein OS hat, war mir schon irgendwie klar :-)

[sssssssssssss]

> verarbeitet wird. 0101010010. jmp und eqn sind bereits "Abstraktionen".

hm ich dachte assembler wäre im groben nur ne 1:1 übersetzung

bsp. jmp wird zu 010101001 wobei jmp assembler ist und 010101001 dann die maschinensprache?

also vonwegen, der assembler geht hin und macht einfach nur suchen->ersetzen bei allen wörtern die er kennt.

[mischen impossible]

Es sei denn, du programmierst OPT-Codes.

[Assemblerking]

aehmmm nein! xD

Und du kannst Befehlssetze die MMX, SSE,... direkt verwenden

zb.:

Hello World in Assemblersprache (MASM für MS-DOS)

DATA SEGMENT ;- Beginn des Datensegments
Meldung db "Hello World" ;- Die Zeichenkette "Hello World"
db "$" ;- Endzeichen der Zeichenkette
DATA ENDS ;- Ende des Datensegment
CODE SEGMENT ;- Beginn des Codesegements
ASSUME CS:CODE,DS:DATA ;- Dem Assembler die Segmente mitteilen
Anfang: ;- Label für den Anfang des Programms
mov ax, DATA ;- das Daten...
mov ds, ax ; ...segment festlegen
mov dx, offset Meldung ;- den Text in das auf DS bezogene Datenregister laden
mov ah, 09h ;- Die Unterfunktion 9 des Betriebssysteminterrupts 21h auswählen
int 21h ;- den Betriebssysteminterrupt 21h (hier erfolgt Ausgabe des Texts) aufrufen
mov ax, 4C00h ;- Die Unterfunktion 4Ch (Programmbeendigung) des Betriebssysteminterrupts 21h festlegen
int 21h ;- diesen Befehl wiederum ausführen
CODE ENDS ;- Ende des Codesegments
END Anfang ;- dem Assembler das Ende des Labels Anfang mitteilen

[McHack]

Assembler != Machinencode

Maschinencode = reiner Zahlenhaufen
Assemlber = Menmonic und Zahlen, sowie Sprungmarken (Lables) usw.

Mnemonic = z.B. MOV, der je nach Parameter in den entsprechendn OPCode umgewandelt wird.

Der OPCode für mov ax, DATA und mov ds, ax bzw. mov ah, 09h ist verschieden.

Assemlber ist mehr oder weniger Prozessor unabhängig. Maschinen-Code nicht.

[dermichael]

Ich versuchs auch mal

Das Herzstück eines jeden Controllers/ Prozessors ist die ALU
(arithmetic logic unit)

Diese verarbeitet den Wert zweier Register und legt das Ergebnis in einem dritten ab.

Die ALU kann arithmetische (zb addieren)
und logische (zb negieren) Operationen ausführen

[Nur am Rande: ja nachdem wie viele Stellen diese Register haben, spricht man beispielsweise von einem 6, 16, 32, oder 64 bit Controller]


Assembler(sprache)
Jeder Controller besitzt eine Sammlung von Befehlen, welche die ALU mit Werten füttert.

Da jeder Controller anders aufgebaut ist (Anzahl GP Register, Wortbreite ...) besitzt auch jeder Controller einen für ihn einzigartigen Satz an Assemblerbefehlen.

Der letzte Satz ist nur bedingt richtig, da viele Controller/Prozessoren auf der gleichen Grundarchitektur beruhen (Beispielsweise die x86 Architektur, die es bis in die 32 bit PC CPUs geschafft hat).

Normalerweise, würde man ein Programm in einer Hochsprache verfassen, da diese leichter zu lesen und zu programmieren sind.
Vor allem sind Programme in dieser Form aber portabel.

Wird ein solches Programm compiliert, übersetzt der Arbeitsrechner diese Hochsprache in die für den jeweiligen Zielcontroller gültigen Assemblerbefehle.

Programmiert man dagegen direkt in Assembler, dann gezielt mit einem Satz an Assemblerbefehlen -> das Programm ist auf einem anderen Controller nicht lauffähig.


Die Vorteile von Assemblerprogrammierung sind:
Durch das direkte ansprechen genau dieses einen Controllers können Befehle eingespart und oder effizienter angeordnet werden, was um einen Geschwindigkeitsvorteile bringt und zum anderen Speicherplatz spart.
Beides ist vor allem bei Embedded Systems Mangelware, weshalb auf diesen gelegentlich in Assembler Programmiert wird.

Natürlich kann man Assembler auch noch in wirklich Controllerspezifische Maschinensprache herunterbrechen, aber wer das tut, der wird entweder gut dafür bezahlt oder er braucht dringend ne Freundin.

[Sogehtsauch]

Wenigstens einer der weiß, was Assembler ist. Gut, aus der Sicht des "Webprogrammierers" haben die anderen auch recht :-D.

[ProgMonkey]

McHack schrieb:
--------------------------------------------------------------------------------
> Assembler != Machinencode
>
> Maschinencode = reiner Zahlenhaufen
> Assemlber = Menmonic und Zahlen, sowie Sprungmarken (Lables) usw.
>
> Mnemonic = z.B. MOV, der je nach Parameter in den entsprechendn OPCode
> umgewandelt wird.
>
> Der OPCode für mov ax, DATA und mov ds, ax bzw. mov ah, 09h ist
> verschieden.

Bis hier hin (fast) richtig.

> Assemlber ist mehr oder weniger Prozessor unabhängig. Maschinen-Code nicht.

Nö: Assembler ist genauso maschinenspezifisch wie Maschinensprache. Assembler hat man entwickelt, weil es für den Menschen erheblich einfacher ist Kürzel (also Menomics) zu verwenden, als irgendwelche Zahlenkolonnen einzutippen. Dann gibt es noch so etwas wie Makros und Labels, die einem das Programmieren in Assembler etwas erleichtern. Das war's dann aber schon.
Wenn man beispielsweise ein Programm für einen Intel-Prozessor in Assembler schreibt, muß man die entsprechenden Opcodes (=Maschinenbefehle) verwenden, die dieser Prozessor versteht. Dieses Assemblerprogramm lässt sich dann nicht einfach auf einen Sparc-Prozessor übertragen, weil dieser einen vollkommen anderen Instruktionssatz hat.
Erst mit der Einführung "höherer" Programmiersprachen (und entsprechender Compiler) wie z.B. Cobol, Pascal, Fortran, C, C++ usf. hat man einen Abstraktionsgrad erreicht, der es einen ermöglicht ein Programm auch auf einer anderen Zielplattform zum Laufen zu bekommen (man muß zwar oft noch ein bisschen was anpassen), da es solche Compiler für die verschiedenen Rechnerarchitekturen gibt, die den Quellcode in mehreren Stufen in den entsprechenden Maschinencode übersetzt.

[Ass-Masch]

sssssssssssss schrieb:
--------------------------------------------------------------------------------
> > verarbeitet wird. 0101010010. jmp und eqn sind bereits "Abstraktionen".
>
> hm ich dachte assembler wäre im groben nur ne 1:1 übersetzung
>
> bsp. jmp wird zu 010101001 wobei jmp assembler ist und 010101001 dann die
> maschinensprache?
>
> also vonwegen, der assembler geht hin und macht einfach nur
> suchen->ersetzen bei allen wörtern die er kennt.

Nein. Nehmen wir an es gäbe relative und absolute Sprünge, als z.B. "jmp +23" und "jmp 0x01234567". Dann wird aus dem "jmp +23" z.B. 01011010 00010111, aus "jmp 0x01234567" würde aber "01011011 01234567".

Also zwei verschiedene jmp für die Maschine, aber nur ein jmp mit zwei verschiedenartigen Parametern für den Programmierer. Dadurch kriegt man auch eine gewisse, geringe plattformunabhängigkeit - der Assembler könnte den relativen jmp auch selbst berechnen und einen absoluten jmp einsetzen, falls die Maschinen keinen relativen jmp hat.

[Johnny Cache]

Assemblerking schrieb:
--------------------------------------------------------------------------------
> aehmmm nein! xD
>
> Und du kannst Befehlssetze die MMX, SSE,... direkt verwenden
>
> zb.:
>
> Hello World in Assemblersprache (MASM für MS-DOS)
>
> DATA SEGMENT ;- Beginn des Datensegments
> Meldung db "Hello World" ;- Die Zeichenkette "Hello World"
> db "$" ;- Endzeichen der Zeichenkette
> [...]

Uiii... lang, lang isses her. Müssen locker 15 Jahre sein.

Ich hab damals mit programmieren aufgehört als alle Welt meinte daß OOP das schönste auf der Welt sei. Ich schätze das erklärt auch meinen überaus mäßigen Erfolg in meinem Studium. ;)
Schneller und direkter geht als ASM geht es eben nicht und warum man davon immer weiter Abstand nimmt werde ich wohl nie verstehen.

Aber wie sagte einer meiner Lehrer damals so schön? "Hey, ihr solltet das doch alleine erarbeiten und ihr habt genau das gleiche geschrieben."
Worauf ich nur sagen konnte: "Nein, mein code ist zwei Takte schneller." ;)

[Nuhr]

BOFH schrieb:
--------------------------------------------------------------------------------
> Konsolen brauchen normalerweise kein eigenes Betriebsystem, da die
> Zielplatform für die Entwickelt wird immer die gleiche ist. Multitasking
> ist in der Regel nicht notwendig, so das direkt gegen die Hardware
> programmiert werden kann.

Ach ja, der Spieleprogrammierer will das alles wieder selber programmierern, macht ja viel mehr Spaß, oder?


>Bei alten Konsolen gab es definitiv kein Betriebsystem.

ROTFL!

PS: "Wenn man keine Ahnung hat, einfach mal Klappe halten!"

[Assemblerprogrammierer]

ProgMonkey schrieb:
--------------------------------------------------------------------------------

> > Assemlber ist mehr oder weniger Prozessor unabhängig. Maschinen-Code nicht.
>
> Nö: Assembler ist genauso maschinenspezifisch wie Maschinensprache.

Assembler sitzt genau eine Schicht höher als Maschinensprache und stellt damit eine gewisse Prozessorunabhängigkeit her. Es gibt kein 1:1-Mapping zwischen Assembler-Mnemonics und Maschinen-Opcodes. Ein Portabilität zwischen verschiedenen Prozessorfamilien ist mir nicht bekannt, innerhalb einer Prozessorfamilie ist sie mit Assembler aber i.d.R. größtenteils gegeben.