3. Maschinensprache

Maschinensprache

  • P

    "Maschinensprache" ist der Bytecode, der vom Prozessor verarbeitet wird. Auf vielen Plattformen besteht ein Befehl aus mehreren Bytes, und die Länge hängt vom jeweiligen Befehl ab.

    Mit einem Disassembler (bzw. einem vom Compiler/Compilertool generierten ASM-Listing) kannst du dir die Assembler-Repräsentation der Machinensprachebefehle ansehen. Das ist (von Kleinigkeiten und Bekloppten abgesehen) der unterste "sinnvolle" Level: Jeder Assemblerbefehl entspricht einem Maschinenspracbefehl.

    0
  • ?

    http://www.c-plusplus.net/forum/viewtopic.php?t=81641&highlight=

    int main ()
{
    int variable = 42;
}

Code:
    .file    "test.cpp"
    .def    ___main;    .scl    2;    .type    32;    .endef
    .text
    .align 2
.globl _main
    .def    _main;    .scl    2;    .type    32;    .endef
_main:
LFB1:
    pushl    %ebp
LCFI0:
    movl    %esp, %ebp
LCFI1:
    subl    $8, %esp
LCFI2:
    andl    $-16, %esp
    movl    $0, %eax
    movl    %eax, -8(%ebp)
    movl    -8(%ebp), %eax
    call    __alloca
    call    ___main
    movl    $42, -4(%ebp)
    movl    $0, %eax
    leave
    ret
LFE1:
Code:
.file "test.cpp"
.def ___main; .scl 2; .type 32; .endef
.text
.align 2
.globl _main
.def _main; .scl 2; .type 32; .endef
_main:
LFB1:
pushl %ebp
LCFI0:
movl %esp, %ebp
LCFI1:
subl $8, %esp
LCFI2:
andl $-16, %esp
movl $0, %eax
movl %eax, -8(%ebp)
movl -8(%ebp), %eax
call __alloca
call ___main
movl $42, -4(%ebp)
movl $0, %eax
leave
ret
LFE1:
Code:
    .file    "test.cpp"
    .def    ___main;    .scl    2;    .type    32;    .endef
    .text
    .align 2
.globl _main
    .def    _main;    .scl    2;    .type    32;    .endef
_main:
LFB1:
    pushl    %ebp
LCFI0:
    movl    %esp, %ebp
LCFI1:
    subl    $8, %esp
LCFI2:
    andl    $-16, %esp
    movl    $0, %eax
    movl    %eax, -8(%ebp)
    movl    -8(%ebp), %eax
    call    __alloca
    call    ___main
    movl    $42, -4(%ebp)
    movl    $0, %eax
    leave
    ret
LFE1:
    0
  • ?

    Es ist ein weit verbreiteter Irrglaube, dass Assembler-Code Maschinensprache ist. Maschinensprache ist nur ne Folge von Einsen und Nullen. Eine Assembler-Anweisung muss auch keineswegs genau einem Maschinenbefehl entsprechen.

    Sieht also "hübsch" aus, ist aber keine Maschinensprache (lange Rede, kurzer Sinn).

    0
  • R

    Eine Assembler-Anweisung muss auch keineswegs genau einem Maschinenbefehl entsprechen.

    Sollte aber, ansonsten würde ich es nicht als Assembler bezeichnen 🙂

    0
  • R

    Es wird wohl jeder Assembler Befehle haben, die durch mehrere Maschinenbefehle ersetzt werden. Denk z.B. an fwait, das automatisch bei vielen FPU-Befehlen eingefügt wird. Oder die automatische Bedingungsnegation und jmp-Generierung, wenn ein bedingtes Sprungziel zu weit entfernt ist. Sonst fällt mir noch z.B. für den Alpha der Befehl ldgp ein, der zu zwei Befehlen wird. Oder ein ganzer Haufen von Befehlen zum Laden von un-aligned Adressen.

    0
  • *

    Optimizer schrieb:

    Maschinensprache ist nur ne Folge von Einsen und Nullen.

    Das war ja eigentlich auch mein Gedanke?

    0
  • ?

    Der aber nicht sehr informativ ist. Ein PNG-Bild ist auch nur einsen und nullen. 🙂
    Das Problem ist doch immer: Wie interpretiert man sie? Der Prozessor weiß es und du weißt es, wenn du die Spezifikation des Prozessors liest.

    0
  • ?

    keiner von euch mal die grundzüge des von neumann rechners gelernt?
    Macht mal ne ausbildung zum FIAE, dann wisst ihr mehr zum thema maschinencode/assembler 😉

    0
  • P

    @Optimizer:
    deswegen hab ich ja "Assembler-Repräsentation" geschrieben 🙄

    aber wenn wir schon pingelig sind: wieso einsen und nullen? und wieso folge? 🕶

    0
  • C

    machinen sprechen ? 😕

    0
  • M

    camper schrieb:

    machinen sprechen ? 😕

    *g* 👍

    0
  • ?

    peterchen schrieb:

    @Optimizer:
    deswegen hab ich ja "Assembler-Repräsentation" geschrieben 🙄

    aber wenn wir schon pingelig sind: wieso einsen und nullen? und wieso folge? 🕶

    Mein Post war keinesfalls auf deins bezogen. Allerdings möchte ich wissen, was an "Folge von 1 und 0" falsch ist. Es sind eindeutig ein paar Bits die im Prozessor-Cache liegen und es ist eine Folge, weil der "Strom", wenn du so willst, sequentiell abgearbeitet wird. Bei Sprungbefehlen wird der Cache geleert und eine neue Folge reingeladen. Natürlich ist bei modernen Prozessoren noch mehr dran, aber das ist zumindest das Prinzip.

    0
  • R

    Wenn du dich dafür interessierst, wie das genau abläuft, solltest du dir einfach mal die Dokumente zu deinem Prozessor durchlesen. Die findest du auf der Homepage des Herstellers. Da findest du eigentlich alles kostenlos, was von interesse ist.

    Für x86er zB Intel Architecture Software Developer's Manual, Volume 2: Instruction Set Reference Manual

    @Ringding
    okay, hast eigentlich recht. Allein eine simple add-Anweisung kann ja bereits auf x86ern in 14 verschiedene Opcodes aufgelöst werden.

    0
  • ?

    [quote="Optimizer]Allerdings möchte ich wissen, was an "Folge von 1 und 0" falsch ist.[/quote]weil das auch nur eine repräsentation von dem ist, was "wirklich" da passiert. es sind ja keine einsen, die da fließen, sondern strom. oder kleine gelbe kügelchen. es gab ja z.b. auch nicht-binär-computer. da passt das auch nicht.
    aber wenn man so anfängt, dann muss man alles auf mind. molekularer ebene erklären. deswegen ist es doch ok. und das mit dem assembler auch, je nachdem wie weit du vereinfachen willst.
    🤡

    0
  • P

    Allerdings möchte ich wissen, was an "Folge von 1 und 0" falsch ist

    Wo ist bei einem Byte vorne?

    Die Befehle werden ja nicht bitweise abgearbeitet, sondern (in der ersten Stufe) byteweise. "Eine Datenstrom" wäre also umfassender, aber das ist so allgemein, da fällt schon fast Omas Kartoffelmuß drunter.

    Insofern halte ich Assember als Maschinencode-Repreäsentation für sinnvoll: Ist zwar keine "Maschinensprache", aber modelliert hinreichend genau die Sprache, die die "Maschine" versteht, und eine eineindeutige Abbildung ist in erster Näherung kein Problem.

    0
  • ?

    Stellt euch doch nicht so dämlich an!

    Eine Addition 2 + 4 wird in Maschinensprache folgendermaßen formuliert:

    0001101     0010     0100

    Aufgeschlüsselt bedeuten die Bitfolgen: "addiere 2 4"

    0
  • R

    @fifi
    Es gibt nicht "Die Maschinensprache".

    0
  • R

    Gibt es tatsächlich eine CPU, die einen Befehl zur Addition von Konstanten hat? 😕

    0
  • W

    fifi schrieb:

    Stellt euch doch nicht so dämlich an!

    Eine Addition 2 + 4 wird in Maschinensprache folgendermaßen formuliert:

    0001101     0010     0100

    Aufgeschlüsselt bedeuten die Bitfolgen: "addiere 2 4"

    Es könnte auch "Hole 2 Kaffee mit 4 Stück Zucker" heißen. Alles Interpretationssache.

    0
  • ?

    fifi schrieb:

    Stellt euch doch nicht so dämlich an!

    Eine Addition 2 + 4 wird in Maschinensprache folgendermaßen formuliert:

    0001101     0010     0100

    Aufgeschlüsselt bedeuten die Bitfolgen: "addiere 2 4"

    Wird nich normalerweise sowas in der art gemacht wie

    lade aus speicher xxxxxx in accumulator
    addiere aus speicher xxxxxxx+1 zum accumulator dazu
    speichere accumulator in xxxxxx

    oder so in der art.. ?

    Das isses so wurdsmir inner schule beigebracht. ^^

    0
Anmelden zum Antworten