Xorp Blog Podcast

Assembler Tanulmányok: Bináris műveletek, elforgatások

Bár már befejeztem az Assembler tantárggyal kapcsolatos tanulmányaim, azért fontosnak tartom a fennmaradt forráskódok és ismeretek lejegyezni. A mostani témakör egy nagyon fontos része az Assembler nyelvnek. Méghozzá a bináris műveletek és elforgatások. Sajnos már teljesen kijöttem a gyakorlatból (ha egyáltalán mondhatnám, hogy benne voltam). Így inkább a konkrét példán keresztül próbálok a dolgokra rávilágítani. Sajnos nem egyszerű felfogni. :)

Tehát a feladat ez: x=(b#(b#N_1)_5 : a#31_7 : b#9_8 : a#3_7)#+32 Ennek a műveletnek a végeredményét (változóját) kell visszaadni. Persze az egyes jelölések magyarázatra szolgálnak. Íme:

Az egyéni feladatok megoldása során a különböző változók “részeivel”, azaz csak néhány bitjével kapcsolatos tevékenységeket kell elvégezni. A “bitsorozatok” megadására, a feladatok leírására a következő jelöléseket használtuk:

  • Bitek sorszámozása mindig a 0. bittel kezdődik, amely a legalacsonyabb helyiértékű (LSB) bitet jelöli.
  • hivatkozás egy “normál változóra”, regiszterre, konstansra
  • EAX ==> az EAX regiszter összes bitje
  • valtozo ==> a valtozo nevű változó összes bitje
  • Bitsorozatok összefűzése
    BS1:BS2 :
    az a bitsorozat, amely az BS1 és BS2 bitsorozatok egymás mögé írásával jön létre
    • %1001_1010:%011_1001 ==> %10011010_0111001=%100_1101_0011_1001
    • %1011_1110:%101:%10_1101 ==> %10111110_101_101101=% _0111_1101_0110_1101
  • Egy bitsorozat szomszédos bitjeinek kiemelése
    BS#x_y:
    A BS bitsorozatnak az x sorszámúval kezdődő szomszédos y db bitje (BS x. bitje a kiemelés 0. bitje lesz, BS (x+1). bitje a kiemelés 1. bitje lesz, stb…) // Ha a kiválasztandó bitek valamelyikének sorszáma nagyobb, mint a BS bitsorozat MSB bitjének sorszáma, akkor a BS bitsorozat bitjeit szükség szerint megtöbbszörözzük, azaz összefűzzük sajátmagával: BS#x_y == . . . :BS:BS:BS:BS#x_y.
    • %100_1011_0101#2_5 ==> %0_1101
    • %100_1011_0101#6_3 ==> %010
    • %1011_1111#5_5 ==> %11_101 // A legmagasabb helyiértéken “túlnyúló” bitek a legalacsonyabb helyiértékűek lesznek. <== A többszörözési szabály miatt
    • %1#0_5 ==> %1_1111 // Előző sor szabályának többszöri alkalmazásával.
    • %10#0_10 ==> %10_1010_1010
    • %10#1_10 ==> %01_0101_0101
    • AL#12_3 ==> AL#4_3 // <== A többszörözési szabály miatt
    • A példákban, itt és a következőkben – az érthetőség javítása érdekében, többnyire – csak konstansokra hivatkozunk.
  • Egyetlen bit kiemelése
    BS#x: A BS bitsorozatnak az x sorszámú bitje. (BS#x==BS#x_1)
    • %100_1011_0101#6 ==> %0
  • Bitek megszámlálása
    BS#N_x: Az x értékű bitek száma a BS
    bitsorozatban. (x legális értékei: 0, 1)
    BS#N:
    A BS bitsorozat bitjeinek száma (BS#N==(BS#N_0)+(BS#N_1))
    • %10_0010#N ==> 6
    • EAX#N ==> 32
    • DH#N ==> 8
    • %10_0010#N_0 ==> 4
    • %10_0010#N_1 ==> 2
  • Legmagasabb helyiértékű bit (MSB) kiemelése
    BS#^ == BS#((BS#N)-1) == BS#((BS#N)-1)_1
    • %10_0101#^ ==> %1
  • Zérus kiterjesztés ill. magas helyiértékű bitek kiemelése
    BS#+x:
    a BS bitsorozat kibővítése x bit méretre a magas helyiértékeken elhelyezett 0 bitekkel
    • %101#+7 ==> %000_0101
    • %1101#+2 ==> %11 // ha x kisebb, mint a bővítendő bitsorozat mérete, akkor a magas helyiértékű x bit
    • %1101#+4 ==> %1101 // ha x megegyezik a
      bitsorozat méretével, akkor maga a bitsorozat
    • Megj: BS#+x == ((%0#0_x):BS)#0_x – kivéve, ha x<BS#N (ekkor a magas helyiértékű bitek lesznekl kiemelve,nem az alacsonyak)
  • Előjel kiterjesztés ill. alacsony helyiértékű bitek kiemelése
    BS#-x: a BS bitsorozat kibővítése x bit méretre, a legmagasabb helyiértékű bit megfelelő számú ismétlésével
    • %101#-7 ==> %111_1101
    • %1101#-2 ==> %01 // ha x kisebb, mint a bővítendő bitsorozat mérete, akkor az alacsony helyiértékű x bit
    • %0101#-7 ==> %000_0101
    • %1101#-4 ==> %1101 // ha x megegyezik a
      bitsorozat méretével, akkor maga a bitsorozat
    • Megj: BS#-x == (((BS#^)#0_x):BS)#0_x
  • Aritmetikai alapműveletek (túlcsordulás esetén sem változik a bitsorozat mérete)
    • %101#-7 + %101#+7 ==> %111_1101 + %000_0101 ==> %000_0010
    • %101#-7 – %101#+7 ==> %111_1101 – %000_0101 ==> %111_1000
  • Eltolások – jobbra és balra / Ezen műveletek nem változtatják meg a bitsorozat hosszát!
    BS#<x:
    A BS bitsorozat balra tolása x bittel. Az alacsony helyiértékeken új 0 bitek jelennek meg
    BS#>x:
    A BS bitsorozat jobbra tolása x bittel. A magas helyiértékeken új 0 bitek jelennek
    meg
    BS#>>x:
    A BS bitsorozat jobbra tolása x bittel. A magas helyiértékeken az MSB (előjel-) bit ismétlődik
    • %101#<1 ==> %010 ; %1001_0110#<3 ==> %1011_0000
    • %101#>1 ==> %010 ; %1001_0110#>3 ==> %0001_0010

    • %101#>>1 ==> %110 ; %1001_0110#>>3 ==> %1111_0010 ; %0001_0110#>>3 ==> %0000_0010
  • Forgatások – jobbra és balra
    BS#<x<:
    A BS bitsorozat balra forgatása x bittel. Az alacsony helyiértékeken a magas helyiértékről kiforgatott bitek jelennek meg.
    BS#>x>:
    A BS bitsorozat jobbra forgatása x bittel. A magas helyiértékeken az alacsony helyiértékről kiforgatott bitek jelennek meg.
    • %101#<1< ==> %011 ; %1001_0110#<3< ==> %1011_0100
    • %101#>1> ==> %110 ; %1001_0110#>3> ==>1101_0010
  • Bitsorrend megfordítása (Tükrözése)
    • %1010#T ==> %0101
    • %101001#T ==> %100101
  • Bitenkénti logikai műveletek
    BS1 & BS2 : Bitenkénti logikai és művelet a BS1 és BS2 bitsorozatok között
    BS1 | BS2
    : Bitenkénti logikai vagy művelet a BS1 és BS2 bitsorozatok között
    BS1 ^ BS2
    : Bitenkénti logikai kizáró vagy művelet a BS1 és BS2 bitsorozatok között
    • %1010 & %1100 ==> %1000 // Az eredmény valamely bitje akkor 1, ha midkét bitsorozatban 1 található az adott sorszámú helyen
    • %1010 | %1100 ==> %1110 // Az eredmény valamely bitje akkor 1, ha legalább az egyik bitsorozatban 1 található az adott sorszámú helyen
    • %1010 ^ %1100 ==> %0110 // Az eredmény valamely bitje akkor 1, ha a két bitsorozatban eltérő bitek találhatóak az adott sorszámú helyen

    Ezek alapján a feladat megoldásának forráskódja itt található. Különösebb kommentárt nem fűznék hozzá, hisz minden sor utasítás meg van magyarázva a forrásban.

    Categories: Debrecen, Programozás

    Assembler Tanulmányok: Kiterjesztett pontosságú műveletek » « Jubilleumi 1000. Bejegyzés a Xorp Blogon

    17 Comments

    1. Ismét köszi!
      Remélem most is segítségemre lesz!
      :D
      Üdv,
      Ádám

    2. %1#0_5 ==> %1_1111 // Előző sor szabályának többszöri alkalmazásával

      Oda miért kell a _ jel?? amikor nem is szerepel a feladatban?
      Válaszodat előre is köszönöm!

    3. És bocsi, ez pontosan mit csinál??

      and($0000_007F,ecx);

      ??

    4. meg 1szer shr-t 1szer ror-al forgatsz?
      mikor melyikkel kell?Honnan tudod?

      És bocsi a sok kérdésért!!

    5. Fu ennyi kerdest. Megprobalok valaszolni amire tudok, de remelem megerto leszel baromira nememlexem mar mi hogy is volt :( Az SHR biztos hgoy bitek eltolasa jobbra… ami kb igy nez ki 0000_1000 ezt shr 2vel igy nez ki 0000_0010 a forgatasra nem emlekszem miben kulonbozik oszinten, az akkori gyakorlatvezeto hatasara irtam at azokat. Talan gyorsitas miatt…

      Az AND muveletet gondolom nem kell bemutatnom $0000_001F ez meg egy maszk. az F ugye negy darab egyes 1111 amit nem irunk ki hanem odacsapjuk egy F-el tehat a maszak ot darab egyest fog tartalmazni, amit az es muvelettel akarunk kivagni.

      %1#0_5 ==> %1_1111 ezt mar magam se ertem :(

      Remelem azert segit vmit a dolog. Sok sikert!

    6. Köszi szépen!!
      A te segítségeddel az előzi feladatban 3 pontot kaptam plusszba! :D
      Még1 szer köszi önzetlenséged!

    7. Hehe nagyon szivesen! Vegulis ez volt az inditatas, hogy ha lehet segitsek. Sajnos ezt az egyetemen sokan nem igy latjak. En meg szeretem egy picivel mindig jobba tenni a vilagot… Sok szerencset a tanulmanyaidhoz!

    8. Az email címedet nem küldenéd el lécci a kapusadam@freemail.hu címre?
      Csak mert nem szeretnék mindent ide írni! :D
      Előre is köszi!

    9. És bocsi itt ezt kihagytad: ezt itt nem tudom hog hogy kell vag ymég ne mjöttem rá…

      b#(b#N_1)_5 : a#31_7 : b#9_8 : a#3_7)# 32 a # 32 -őt
      azt a kiegészítést lécci!
      Előre is köszi! Még1szer!

    10. //feltoltes: ebx = ( y#(a#N_1)_9 : (a#19_19)#<5 )#-32
      bt(27, ebx); //30. bitig fel van toltve, csak 1 bit kell
      if(@c) then
      or($F000_0000, ebx); //ha 1-es volt az ertekes jegy, ezzel toltom fel a 31. bitet
      endif;

      Ezzel tolod fel hogy 32 bites legyen! az egesz tologatas vegen!

    11. Hali. Nagy segítségemre lenne, ha tudhatnám, hogy mien parancsokkal lehet biteket kezelni HLA-ban. Köszi

    12. Csao,

      Ajanlom neked ennek az egesz sorozatnak a bevezeto bejegyzeset. Ott talalhato altalanos atfogo dokumentumok. Katt ide.

    13. Hát ezek a dokumentumok már megvannak, de nem nagyon találtam benne ezeket a parancsokat. Például adot bitek kiválasztása,forgatása, bővíése, meg egyebek. az egésznek a működését azt értem, már csak a parancsokra lenne szükségem.

    14. Akkor viszont nemertem mi a problemad. Az osszes kerdesedre valaszt kapsz mindket dokumentumban. AZ eljee bemutatas, a vege muveletek leirasa, es szintaxisa! :)

    15. hali!
      a köv feladattal gondom lenne!
      plz help!

      x=(a#17_14 : b#13_7 : a#9_8 : b#(a#N_0)_2)#-32

      MOV(a,EAX);
      ROR(17,CL);
      MOV(b,EBX);
      ROL(12,EBX);
      SHLD(7,EBX,EAX);
      MOV(a,EBX);
      ROL(15,EAX);
      SHLD(8,EBX,EAX);
      MOV(a,EBX);
      MOV(0,CL);
      for (MOV(1,ECX); ECX

    16. Az iras kb 1 eves… En elegge kiestem a gyakorlatbol es most se idom se kedvem nincs… :) De gyakvezeto nem azert van? :) Nekunk mindig segitett ha elakadtunk.

    Hozzászólás

    Copyright © 2018 Xorp Blog Podcast

    Theme by Anders NorenUp ↑

    %d blogger ezt szereti: