4. Assembler Befehler

Assembler Befehler

  • ?

    Hallo Forum,

    ich bin gerade dabei ein Assemblerprogramm von einer PDP Eleven nachzuvollziehen. Kennt Ihr eine Seite wo die Assembler Syntax erklärt wird?

    Was machen ZB. die folgenden Befehler:

    x:
mov N, r0           // N ist ein Marker für eine Speicherstelle. Ist in r1 die Adresse N oder der Inhalt von N?
mov #N, r0          // Wird hier die Adresse N nach r0 geschoben?
add r1, new
dec r1
bgt x               // Branch if greater. Verändert dec das Flag? Wenn nein, wird gesprungen wenn r1>new oder wenn new>r1

    Die ganzen Fragen kann man nur klären wenn man sich mit PDP Eleven Assembler auskennt. Bin für jeden Tip dankbar.

    Viele Grüße

    h

    0
  • ?

    Was macht dieses Programm?

    mov N, r1
    mov #M, r0
    mov #0, RESULT

    foo:
    mov r1, (r0)+
    add r1, result
    dec r1
    bgt foo

    mov N, r1
    dec r1
    mul #2, r1

    bar:
    mov M(r1), r0
    add R0, RESULT
    sub #2, r1
    bge bar
    halt

    Es schreibt bei M die Zahlen hinter Speicherzelle N bis 0 nacheinander hin. Der untere Abschnitt bei bar ist mir aber unverständlich.

    0
  • D

    also wenn ich das recht verstehe, wird zuallererst mal vie Variable N in Register 1 geschoben. Register 0 wird ein Zeiger auf M und die Variablen RESULT ein Zeiger auf Die Adresse von 0(?) oder direkt auf 0? - oder fehlt da was?

    anschließend wird zwischen foo und bgt (branch if greater 0) passiert folgendes:
    R1 wird an die Adresse r0 geschrieben und r0 dann um eins nach rechts verschoben. r1 wird zusätzlich auf RESULT addiert und anschließend um eins vermindert.
    Das Ganze passiert halt so lange bis r1 = 0 ist.

    Du hast dann also alle Zahlen von N bis 1 in einem Array ab der Speicherstelle #M zu stehen, zusätzlich die Summe aller Zahlen von 1 bis N in Result.

    Anschließend wird N nach r1 geschoben und r1 um eins verminder. Das Ergebnis wird dann verdoppelt.
    Zwischen bar: und bge (branch if greater or equal) also bis der Inhalt von r1 = 0 ist wird nun das r1-te Zeichen des Arrays M nach r0 geschoben und auf result addiert. Anschließend wird r1 halbiert.

    wozu das ganze musst du dir jetzt aber selber zusammen reimen

    0
  • ?

    Der drittletztes Befehl ist sub und nicht div.
    Könnte es sein das die PDP11 Byteaddressierbar war? Das Wort ist dort 16 Bit breit. Deshalb das mul 2. Ich dachte er würde über die Arrygrenzen hinaus zugreifen...

    Demnach würde das Programm in Result 2*den Wer der Speicherzelle N ausrechnen.

    0
  • D

    könnte hinkommen.. ich kenn mich mit der pdp11 nicht aus - ist für mich ein museumsstück 😉

    Bei mir auf Arbeit steht seit Neuestem eine Siemens S190 rum.. schon toll das Teil

    0
Anmelden zum Antworten