Kan du assemblerprogrammering?

Har kodat lite asm i mina dagar, antar att du är du är intresserad av x86 assembler.
Addition sker genom add instruktionen, ADD eller ADC (Add with carry).

För att skriva ut en sträng så använder man på moderna OS inbyggda funktioner i OS:et, api-anrop. Förr (på gamla goa DOS tiden) så använde man antingen BIOS funktioner (interupts) eller skrev direkt till textminnet, detta är inte möjligt på moderna OS.

Har programmerat assembler för en PIC18F452, hjälper det?

Assembler för 486 och ZiLog80, men du bör posta lite kod eller något

Används i första hand för inbyggda system, även om många nog gått över till C nu, fast även där är det mycket bra att kunna för att debugga saker som går fel.

Inbyggda system = Typ allt ifrån bilar till microvågsugnar. Men mycket sånt har gått över till C som sagt, fast ASM är fortfarande rätt vanligt.

Wikipedia hade rätt bra info om current usage av ASM.
http://en.wikipedia.org/wiki/Assembly_language#Current_usage

Assembler kanske inte används så där rakt av nu för tiden, men det är fortfarande mycket viktigt för debugging av program som kompilerar till maskinkod och för att se vilken typ av kod ens kompilator genererar för den kod man skrivit. Mycket viktigt när man kommer närmare hårdvaras om t.ex. i spekonsoller, drivrutiner etc.

Har hackat lite assembler i några kurser, fast det var till typ "flex" processorn och nån annan som jag glömt namnet på.

Texas Instruments TI83 räknare skriver man ASM till. Rätt kul att göra små spel eller så kan man använda den som en fjärrkontroll och bygga en IR sändare till den och styra med ASM. Finns massor med roligt.

De största skillnaderna är nog:

* Inga kommentarer, variabelnamn, funktionsnamn, eller namngivna positioner (labels) i den disassemblade koden.
* Många assemblatorer tillåter komplexa structurer (structs) och makron, detta syns inte i den disassebemblade koden.

Det är viktigt att du förstår hur processorn jobbar innan man börjar testa lite assembler. Förstår man hur processorn jobbar blir det lättare. Assembler i sig är egentligen busenkelt om man förstår processorn. Det är så enkelt att det blir svårt och göra komplicerade saker.

Vad för assembler är det du använder? Det flesta processorer har multiplikation inbyggt, så det är inget man själv måste koda. Att "addera dessa gång på gång" är en värdelös multiplikationsalgorithm, men en sån implementation skulle kunna se ut som den nedan.

x86 multiplikation genom att "loopa gång på gång." Obs. funkar inte om tal2 (räknaren är noll).

xor eax, eax    // nollställ resultatet
mov ebx, tal1  // spara undan tal1
mov ecx, tal2  // antal gånger
l1: 
add eax, ebx  // addera på talet
dec ecx          // minska räknaren
jz end            // hoppa till slutet om räknaren är noll
jmp l1            // loopa
end: 
// klart

Reserverar mig för fel, var ett bra tag sen jag kodade asm.

Inom inbyggda system lever assembler kvar som inline assembler, man använder alltså assembler inne i den vanliga koden. (t.ex C)
På detta sätt kan man göra effektivare kod och i vissa fall tydligare. Det uppstår dock ibland problem som flyktiga variabler, vilket innebär att man kanske måste deklarera variabeln som volatile och då har man istället en "slöare kod".
Inline assembler förekom även på x86or, vanligt var att man sparkade igång muspekaren genom biosen från dos.
Men det börjar försvinna från 86or idag, då man eftersträvar enkelt och tydlig kod.
Det är ingen som vill ha en kod man för varje rad sitter och beundrar hur jävla duktig programmeraren måste ha varit, utan att man istället tycker att varje kodrad är enkel och effektiv.

Nå inom debuggning lever assembler kvar och kommer göra det i väldigt många år till.
Många studenter läser dessutom någon "assemblerkurs" i ettan för att förstå grunderna inom mjukvaruprogrammering. (Det finns hårdvarubeskrivande språk för dem som tycker assembler är för newbies, vilket dock inte används för x86or)

$ betyder att talet är hexadecimalt, 10 hexadecimalt är 16 decimalt.

opcoden 21 betyder helt enkelt "ladda R1 med ett värde". Den kommer att ladda R1 med den efterföljande byten, $10 i detta fall.
Samma sak med 20 (ladda R0) och 22 (ladda R2).

"Men tolkar jag rätt om i detta fall (2= op code, 1 = register, 10 Value)."
Troligen, verkar ju vara ett designat låtsas assemblerspråk, så då kanske det räcker med 16 instruktioner. Med tanke på att det finns 16 register så verkar den andra nibblen representera registret.

"Inline assembler förekom även på x86or, vanligt var att man sparkade igång muspekaren genom biosen från dos."

Inline assembler förekommer ganska mycket fortfarande, speciellt när man vill använda sig av dataparallism (SIMD).

Vad menar du egentligen?
"ta hänsyn till nån speciell ordning som vissa sammanhang skall komma i"
Menar du själva programflödet eller vadå? Programflödet styr man ju med hopp.

Vad är "Load, NextChar, Ready, Text" som du pratar om? Genom lite snabbt googlande så antar jag att du refererar till denna bild:
http://wwwes.cs.utwente.nl/software/simpsim/images/asmwin.gif
Men varför inte skriva det i tråden då? Så slipper vi gissa vad du pratar om?

Vad Load, NextChar, Ready och Text gör bör ju vara ganska enkelt att förstå om man kan lite engelska. (Läsa kommentarerna kanske?)

Har du sysslat med någon programmering innan? Känns som att det skulle vara bättre om du började med ett normalt språk istället.

Ska försöka klara exakt vad den gör:

load R1, Text // ladda in addressen till texten till R1
load R2, 1 // ladda in 1 till R2
load R0, 0 // ladda in värdet 0 till R0, värdet 0 används för att terminera strängar,observera att detta är en byte med värdet 0 och inte själva tecknet 0.

NextChar: load RF, [R1] // hämta värdet som R1 pekar på, dvs indirekt addressering och skriv det till RF, som verkar vara ett minnesmappad register. Det som skrivs till RF är det som skrivs ut på skärmen.
addi R1, R1, R2 // R1 = R1 + 1, dvs peka på nästa bokstav i texten
jmpEQ RF=R0, Ready // hoppa till Ready om sista utskrivna tecket är nulltermineraren.
jmp NextChar // Loopa

Ready: halt // stoppar processorn

"Därför undrade jag, om Text ligger sist i flödet, varför kommer bokstäverna fram först när man kör RUN.."

Du tänker på fel sätt nu, Text är ju för det första inga instruktioner, utan ren binärdata som man tolkar som text. Själva assemblatorn kommer att fixa till så att det ligger åtkompligt i minnet.
Ordningen i koden spelar ingen större roll. Den kommer alltid börja högst uppe och följa alla hopp.

Nej.
Finns multiplikationsalgorithmer man bör implementera.

"addi R3, R2, R1" är inte ett av dessa vart resultatet ska sparas?
Och varför sparar du 2:an på tre ställen? räcker väl att spara den i R0 och göra typ:

R0 + R0 -> R1
R1 + R0 -> R1

... Säger ordet pseudo-kod dig något?
med -> menade jag självklart "lagra resultatet"