Assembler - Wie kann ich nur 7 Bit ausgeben?

2 Antworten

Das hängt davon ab, WIE du Werte über 127 behandeln willst.

Soll bloß abgeschnitten werden (dann entweder mit "cmp" und einem "jmp", oder alternativ auf neuen Prozessoren ein "movc" um das Pipelining nicht durcheinander zu bringen), sollen die niederwertigsten 7 Bit maskiert werden (einfach ein "and" mit 0x7F auf einem Register) oder soll ein Fehler ausgelöst werden (dann einfach "ja katastrophe" o. Ähnliches)?

Wenn du AT&T Syntax mit GAS verwendest, vergiss nicht das entsprechende Suffix ans Ende deiner Instruktionen ran zu hängen. (also aus "movc" wird "movcb", aus "and" wird "andb", usw.)

Naja, viel Spaß! :)

PS: YASM ist deutlich besser für "Menschen-gemachten" Assemblercode geeignet als GAS, aber natürlich solltest du auch mit GAS klar kommen. Ich mag beide! :)

Disclaimer: Ich weiß nicht, auf welcher CPU du arbeitest, also habe ich jetzt einfach mal das naheliegendste "x86" geraten. Wobei sich das Grundprinzip auf den meisten CPUs kaum unterscheiden sollte. :)

Ich kenne jetzt weder diesen Assembler noch die genaue Syntax, aber brauchst du nicht nur eine Undverknüpfung deines berechneten Wertes mit 127? (bin 0111 1111) ?

Wer hatte den Assembler Compiler programmiert?

Der Assembler Compiler ist soweit ich weiß in Maschinencode geschrieben.

Wer war dieser Genie?

Mfg

...zur Frage

Ist die Integer-Multiplikation auf Softwareebene (MIPS Assembler) weiter optimierbar?

Guten Abend,

folgender Code für eine softwarebasierte Multiplikation in MIPS Assembler (es geht nicht darum den Befehl mult/multu zu verwenden, sondern mal eine eigene Multiplikation zu implementieren):

multiplikation:
    li $t0, 0                 # Zähler initialisieren
    
    loop:
    andi $t1, $a1, 1          # LSB vom Multiplikator
    beq $t1, $zero, cont0     # Springe bei LSB == 0

    sllv $t2, $a0, $t0        # $t2 *= $t0 * 2^(a0);
    addu $v0, $v0, $t2        # $v0 += $t2;
    
    cont0:
    addi $t0, $t0, 1          # Zähler inkrementieren
    srl $a1, $a1, 1           # Multiplikator /= 2;
    bne $a1, $zero, loop      # bis Multiplikator == 0
    jr $ra                    # Zurück zum Programm

Registerverwendung (nach MIPS Calling Convention):

  • $a0: Multiplikand
  • $a1: Multiplikator
  • $v0: Produkt

Jetzt habe ich zwei Fragen:

  • Was sind die Grenzen meiner Int-Multiplikationsroutine (außer Overflow)?
  • Lässt sich die Funktion weiter optimieren (hinsichtlich Anzahl der Instruktionen, Effizienz, Effizienz für unterschiedliche Zahlenbereiche (große vs kleine vs positive vs negative Zahlen))?

Habe Algorithmik oder was Informatiker im Studium haben leider nicht. Habe nur ne Einführung in C/C++ gehabt und nun Assembler in MIPS - falls die Frage einfach doof ist für einen Informatiker... ^^

Vielen Dank im Voraus für eine Antwort 😊

LG. Kesselwagen

...zur Frage

Was möchtest Du wissen?