ภาษาแอสเซมบลี

            แอสเซมบลีเป็นภาษาที่ช่วยในการสร้างรหัสคำสั่งที่มีประสิทธิภาพการทำงานเหนือกว่าภาษาระดับสูง ทั้งในแง่ความเร็วของการทำงานและความกระทัดรัดของตัวโปรแกรม ในบทนี้จะได้กล่าวถึงหลักการเบื้องต้นก่อนเริ่มศึกษาภาษาแอสเซมบลี และกรรมวิธีในการแปลภาษาแอสเซมบลีไปเป็นแฟ้มที่เก็บคำสั่งภาษาเครื่องซึ่งพร้อมที่จะใช้ปฎิบัติงาน เนื้อหาในบทนี้ประกอบไปด้วยเรื่องเกี่ยวกับ

           ภาษาเครื่อง          

           ภาษาแอสเซมบลี 

           ตัวอย่างโปรแกรม

           การแปลโปรแกรมและการเรียกใช้

ภาษาเครื่อง 

            คอมพิวเตอร์ในปัจจุบันทำงานด้วยระบบดิจิตอล ซึ่งมีสถานะการทำงานอยู่สองสถานะคือ ปิด และ  เปิด สถานะทั้งสองนิยมเขียนแทนด้วยตัวเลขฐานสองคือ 0 และ 1 ตามลำดับ ตัวเลขฐานสองแต่ละหลักซึ่งเรียกว่า บิต (bit) เป็นอักขระสำคัญใน ภาษาเครื่อง (Machine langauge) สำหรับใช้โปรแกรมคอมพิวเตอร์ให้ทำงานตามที่เราต้องการ

             ภาษาเครื่องเป็นภาษา ระดับล่าง (Low level) ที่ใช้สั่งงานซีพียูของเครื่องคอมพิวเตอร์โดยตรง ลักษณะของภาษาเครื่องจึงประกอบไปด้วยรหัสตัวเลขซึ่งนิยมเขียนในด้วยเลขฐานสองหรือเลขฐานสิบหก หากใช้เลขฐานสองรหัสภาษาเครื่องจะประกอบด้วยเลข 0 หรือ  1 เรียงต่อเนื่องกันเป็นรหัสคำสั่งหนึ่ง ๆ  เช่นรหัสสี่บรรทัดต่อไปนี้เป็นตัวอย่างคำสั่งภาษาเครื่องสี่คำสั่งเรียงต่อกัน

 

      10110000 00000101

      10110011 00000100

      00000000 11011000

      10100010 00000010 00000001

 

            นักออกแบบซีพียูจะสร้างโปรแกรมขนาดเล็กโปรแกรมหนึ่งและบรรจุไว้อยู่ในตัวซีพียูโดยตรง เรียกว่า รหัสระดับไมโคร (Microcode) รหัสระดับไมโครจะทำหน้าที่เป็นตัวแปลภาษาเครื่องไปเป็นสัญญาณไฟฟ้าสั่งงานวงจรภายในซีพียูและอุปกรณ์ที่เชื่อมต่อกับซีพียู

            สำหรับไมโครคอมพิวเตอร์ที่ใช้ซีพียูในตระกูล 8086 คำสั่งภาษาเครื่องทั้งสี่คำสั่งจะเขียนแทนด้วยภาษาแอสเซมบลีได้ดังนี้

 

      10110000 00000101             mov al,5

      10110011 00001000             mov bl,4

      00000000 11011000             add al,bl

      10100010 00000010 00000001    mov [120h],al

           

            คำสั่งแรกเป็นคำสั่งนำค่า 5 ไปเก็บไว้ที่ รีจิสเตอร์ (Register) AL ซึ่งเป็นหน่วยความจำความเร็วสูงภายในซีพียู คำสั่งต่อมาให้นำค่า 4 ไปเก็บไว้ที่รีจิสเตอร์อีกตัวหนึ่งคือ  BL ต่อมาให้บวกค่าในรีจิสเตอร์  AL เข้ากับ BL และเก็บผลลัพธ์ที่ได้จากการบวกไว้ใน  AL สำหรับคำสั่งสุดท้ายเป็น คำสั่งนำค่าจากรีจิสเตอร์  AL  ไปเก็บไว้ในหน่วยความจำที่ตำแหน่ง 120H

            จากตัวอย่างข้างต้นจะเห็นได้ว่าภาษาเครื่องเป็นภาษาที่ยากต่อการแปลความหมายต่อทั้ง
ผู้เขียนและผู้อ่านโปรแกรม นักคอมพิวเตอร์จึงได้ออกแบบรหัสอักขระซึ่งมีรูปแบบที่อ่านเข้าใจได้ง่ายกว่ารหัสฐานสอง เพื่อช่วยให้พัฒนาโปรแกรมได้โดยสะดวกรวดเร็วยิ่งขึ้น รหัสอักขระที่นำมาใช้แทนรหัสฐานสองนี้คือ ภาษาแอสเซมบลี (Assembly language)

 

            ภาษาแอสเซมบลีจัดอยู่ในกลุ่มของภาษาระดับล่างเช่นเดียวกับภาษาเครื่อง และมีความสัมพันธ์อย่างใกล้ชิดกับภาษาเครื่องและฮาร์ดแวร์ของซีพียู ภาษาแอสเซมบลีช่วยลดความยุ่งยากในการจดจำภาษาเครื่องในรูปของตัวเลขฐานสอง  

            คำสั่งหนึ่งๆ ในภาษาแอสเซมบลีจะมีรหัสที่ตรงกันกับภาษาเครื่องแบบหนึ่งต่อหนึ่งเสมอ  ข้อนี้แตกต่างไปจากภาษาระดับสูงอย่างเช่น ฟอร์แทรน, ซี, เบสิก หรือ ปาสคาสที่เมื่อผ่านการแปลด้วยคอมไพเลอร์แล้ว หนึ่งคำสั่งของภาษาระดับสูงมักประกอบด้วยคำสั่งภาษาเครื่องจำนวนมาก

            คำสั่งภาษาแอสเซมบลีมีรูปแบบแตกต่างกันไปตามชนิดซีพียู รูปแบบภาษาแอสเซมบลีของแต่ละซีพียูจะขึ้นอยู่กับชุดคำสั่งภาษาเครื่องและสถาปัตยกรรมของซีพียูนั้นโดยตรง หากกล่าวโดยเฉพาะเจาะจงแล้ว ภาษาแอสเซมบลีที่ใช้กับไมโครคอมพิวเตอร์ไอบีเอ็มพีซีก็คือชุดคำสั่งที่ใช้สำหรับซีพียู 8086 ถึง 80486  และ เพนเทียม

 

จุดเด่นสำคัญของภาษาแอสเซมบลี

   ภาษาแอสเซมบลีมีจุดเด่นหลายประการเมื่อเทียบกับภาษาระดับสูง ในแง่ของการศึกษาถึงสถาปัตยกรรมคอมพิวเตอร์และหลักการทำงานของระบบปฏิบัติการ เราจำเป็นต้องศึกษาถึงการทำงานของซีพียูและกรรมวิธีที่คอมพิวเตอร์ใช้ในสร้างรหัสคำสั่งภาษาเครื่อง ซึ่งย่อมต้องเกี่ยวโยงไปถึงเรื่องของภาษาแอสเซมบลีอย่างไม่อาจหลีกเลี่ยงได้

   การสร้างโปรแกรมขึ้นใช้งานบางกรณีไม่สามารถทำได้โดยการโปรแกรมด้วยภาษาระดับสูง ตัวอย่างเช่นการเขียนโปรแกรมสื่อสารกับตัวระบบปฏิบัติการ หรือโปรแกรมทางด้านกราฟิกที่ต้องการความเร็วการทำงานสูงสุดภายใต้เงื่อนไขหรือข้อจำกัดด้านเนื้อที่หน่วยความจำขนาดเล็ก 

   ภาษาระดับสูงมีกฏเกณฑ์การเขียนโปรแกรมเฉพาะตัวที่จำกัด ตัวอย่างเช่นในภาษาปาสคาลไม่ยินยอมให้มีการเก็บตัวแปรอักขระไปไว้ในตัวแปรจำนวนเต็มได้  แต่ในภาษาแอสเซมบลีมีกฏเกณฑ์ในเรื่องเหล่านี้น้อยมาก ภาษาแอสเซมบลีให้อิสระในการจัดการตัวโปรแกรมอย่างเต็มที่ จนกระทั่งกล่าวได้ว่าทุกสิ่งทุกอย่างขึ้นอยู่กับผู้เขียนโปรแกรมเป็นสำคัญ  ภาษาแอสเซมบลีจะช่วยเสริมสร้างให้นักเขียนโปรแกรมมีมุมมองที่หลากหลายกว่าเมื่อเทียบกับนักเขียนโปรแกรมที่รู้อยู่แต่เฉพาะเพียงภาษาระดับสูงเท่านั้น

 

ภาษาแอสเซมบลีและภาษาระดับสูง 

   นักเขียนโปรแกรมส่วนใหญ่ในปัจจุบันไม่ได้พัฒนาโปรแกรมประยุกต์โดยใช้ภาษาแอสเซม บลีเป็นหลักแต่อย่างใด หากแต่เขียนโปรแกรมภาษาแอสเซมบลีในรูปของโปรแกรมย่อยขนาดเล็กที่ทำงานเฉพาะเพื่อจุดประสงค์ใดอย่างหนึ่ง และเรียกใช้โปรแกรมด้วยภาษาระดับสูงอีกขั้นหนึ่ง

   การพัฒนาโปรแกรมด้วยภาษาระดับสูงใช้ระยะเวลาสั้นและสะดวกต่อการปรับปรุงแก้ไขตัวโปรแกรมมากกว่าเมื่อเทียบกับการพัฒนาโปรแกรมด้วยภาษาแอสเซมบลี หากแต่โปรแกรมที่เขียนด้วยภาษาระดับสูงมักทำงานได้ช้ากว่า นักเขียนโปรแกรมแก้ปัญหานี้โดยทดแทนส่วนของโปรแกรมที่ต้องการความเร็วการทำงานสูงเป็นพิเศษด้วยโปรแกรมย่อยภาษาแอสเซมบลี หรือใช้แอสเซมบลีเพื่อเชื่อมต่อกับระบบหรือฮาร์ดแวร์ระดับล่างซึ่งไม่สามารถทำได้ด้วยภาษาระดับสูง ตัวอย่างเช่นเมื่อเขียนโปรแกรมประมวลผลคำด้วยภาษาซีหรือปาสคาลและพบว่าการแสดงผลเอกสารบนจอภาพช้าเกินไป เราสามารถออกแบบโปรแกรมย่อยแสดงผลใหม่โดยใช้ภาษาแอสเซมบลี ข้อนี้นับเป็นจุดเด่นสำคัญของภาษาแอสเซมบลีที่มีต่อภาษาระดับสูงคือให้ความเร็วในการทำงานสูงสุดและยังได้รหัสที่กระทัดรัดกว่า

   สิ่งจำเป็นอย่างยิ่งสำหรับนักโปรแกรมภาษาแอสเซมบลีแล้วก็คือจะต้องศึกษาถึงสถาปัตย-กรรมของซีพียูที่ใช้โปรแกรมเป็นอันดับแรก และที่สำคัญยังต้องเข้าใจถึงวิธีการจัดการข้อมูลในระดับล่างสุด (ข้อมูลระดับบิต) อย่างชัดเจน   

   แอสเซมบลีเป็นภาษาที่เจาะจงอยู่กับซีพียูตัวใดตัวหนึ่งเป็นพิเศษและไม่สามารถโอนย้ายไปทำงานกับเครื่องที่ใช้ซีพียูต่างชนิดกันได้ แต่ภาษาแอสเซมบลีก็มีกฎเกณฑ์ข้อบังคับในการโปรแกรมแต่เพียงน้อย ต่างกับภาษาระดับสูงที่มีกฏเกณฑ์มากแต่ตัวโปรแกรมสามารถโอนย้ายไปทำงานต่างเครื่องได้ง่าย

 

ภาษาแอสเซมบลี : โครงสร้างเบื้องต้น 

   คำสั่งภาษาแอสเซมบลีอยู่ในรูปของรหัสอักขระและอ่านได้ง่ายกว่าภาษาเครื่อง รหัสอักขระดังกล่าวเรียกว่า รหัสนีโมนิก (Mnemonic)  คำสั่งภาษาเครื่องอาจอยู่ในรูปรหัสนีโมนิกเดี่ยว หรือตามด้วย ตัวถูกดำเนินการ (Operand) ของคำสั่งได้ดังเช่น

pushf             ; เฉพาะรหัสนีโมนิก 

dec   ax          ; ตัวถูกดำเนินการหนึ่งตัว 

add   ax,cx       ; ตัวถูกดำเนินการสองตัว

 

   คำสั่งแต่ละคำสั่งอาจตามด้วยคำอธิบายประกอบคำสั่งซึ่งขึ้นต้นด้วยเครื่องหมายอัฒภาค (;) อักขระที่อยู่ตามหลังเครื่องหมายอัฒภาคจะไม่มีผลต่อการทำงานใด ๆ ของโปรแกรม  คำอธิบายยังครอบคลุมไปทั้งบรรทัดได้ด้วยหากว่าวางเครื่องหมายอัฒภาคเป็นอักขระตัวแรกในบรรทัด

 

ตัวถูกดำเนินการ

   ตัวถูกดำเนินการในภาษาแอสเซมบลี เป็นได้ทั้งรีจิสเตอร์, ตัวแปร, ตำแหน่งหน่วยความจำหรือค่าตัวเลข ดังตัวอย่างต่อไปนี้

    

push ax          ; รีจิสเตอร์ 

dec   count       ; ตัวแปร

inc   [2000h]     ; หน่วยความจำ 

add   ax,10h      ; รีจิสเตอร์กับค่าตัวเลข

 

บรรทัดคำสั่ง

   หนึ่งบรรทัดคำสั่งในภาษาแอสเซมบลีจัดแบ่งออกได้เป็น 2 ประเภทคือ รหัสคำสั่ง และ
ไดเรกทีฟ รหัสคำสั่งประกอบด้วยคำสั่งที่ซีพียูนำไปปฏิบัติงานได้ ส่วนไดเรกทีฟเป็นข้อมูลรายละเอียดที่ช่วยบอกแอสเซมเบลอร์ในการสร้างรหัสคำสั่ง  หนึ่งบรรทัดคำสั่งมีรูปแบบทั่วไปดังต่อไปนี้

 

   [ชื่อ]  [นีโมนิก]  [ตัวถูกดำเนินการ]  [;คำอธิบาย]

   หนึ่งบรรทัดคำสั่งข้างต้นมีรูปแบบอิสระกล่าวคือ ไม่กำหนดว่าจะต้องเขียนที่คอลัมน์ใดของบรรทัด และจะใช้ช่องว่างตั้งแต่หนึ่งช่องหรือมากกว่านั้นเพื่อแยกแต่ละส่วนออกจากกันได้ ตัวอย่างของบรรทัดคำสั่งที่เป็นรหัสคำสั่งเราได้พบมาก่อนหน้านั้นแล้วเช่น

 

add   ax,10h      ; บรรทัดคำสั่งในรูปรหัสคำสั่ง

    \     \               \

   นีโมนิก     ตัวถูกดำเนินการ        คำอธิบาย 

 

   ตัวอย่างของไดเรกทีฟจะใช้ คำสั่งเทียม (Psuedo-opcode) ซึ่งเป็นคำสั่งแอสเซมเบลอร์รู้จักแต่ไม่ใช้คำสั่งที่ซีพียูจะปฏิบัติงานได้ตัวอย่างเช่นคำสั่ง  db สำหรับใช้กำหนดตัวแปรขนาดหนึ่งไบต์

 

   count       db    50h   ; ตัวนับ 

  \      \        \

      ชื่อ        คำสั่งเทียม      คำอธิบาย

 

ชื่อ

   ชื่อใช้เป็นส่วนสำหรับอ้างอิงตำแหน่งหน่วยความจำ เพื่อใช้เป็น เลเบล ตัวแปร หรือ ค่าคงตัวภาษาแอสเซมบลีของไมโครคอมพิวเตอร์ 8086 กำหนดให้ใช้สัญลักษณ์ดังต่อไปนี้ประกอบในการตั้งชื่อได้

อักขระ	รายละเอียด
A ถึง Z a และ  z	ตัวอักษร
0 ถึง 9	ตัวเลข
?	เครื่องหมายอัศเจรีย์
_	เครื่องหมายขีดล่าง
@	สัญลักษณ์ @
$	สัญลักษณ์เงินดอลล่าร์
.	เครื่องหมายจุด

 

   การตั้งชื่อในโปรแกรมภาษาแอสเซมบลีมีข้อกำหนดเบื้องต้นดังต่อไปนี้คือ

·         แอสเซมเบลอร์แยกความแตกต่างของชื่อโดยใช้อักขระเพียง 31 ตัวแรกเท่านั้น

·         ไม่มีความแตกต่างระหว่างตัวอักษรเล็กและใหญ่

·         อักขระตัวแรกห้ามเป็นตัวเลข

·         หากใช้จุดในการตั้งชื่อ จะต้องใช้จุดเป็นอักขระตัวแรก

·         ห้ามตั้งชื่อซ้ำกับคำสงวน

เลเบล 

   หากว่ามีชื่อนำหน้ารหัสคำสั่ง เราจะเรียกชื่อนั้นว่าเป็น เลเบล (Label) ซึ่งเป็นตำแหน่งสำหรับอ้างอิงเพื่อใช้ในคำสั่งกระโดดหรือคำสั่งที่ทำงานเป็นวงรอบ ตัวอย่างเช่นเลเบล start และ next ประจำคำสั่งต่อไปนี้

  

start:      mov   ax,@data

            mov   dx,ax

              :   

              :

            mov   cx,0ffh

next:       inc   ax

              :

              :

             loop  next

ตัวแปรและค่าคงตัว

   ชื่อซึ่งใช้เป็นตัวแปรหรือค่าคงตัวมักใช้ประกอบกับคำสั่งเทียมของแอสเซมเบลอร์ เช่นคำสั่ง  db สำหรับกำหนดตัวแปรขนาดหนึ่งไบต์ หรือคำสั่ง  equ สำหรับกำหนดค่าคงตัวในโปรแกรมดังเช่น

 

count       db     50h            ; ตัวแปร 

max_int  equ   32767       ; ค่าคงตัว 

              :

 

คำสงวน

   คำสงวนเป็นชื่อที่ใช้ในจุดประสงค์โดยเฉพาะในแอสเซมเบลอร์ ซึ่งอาจจะเป็นรหัสนีโมนิก หรือเป็นไดเรกทีฟก็ได้ ตัวอย่างเช่น add, mov, db, loop, ax หรือ end เป็นต้น แอสเซม เบลอร์จึงห้ามนำคำสงวนมาใช้ในการอ้างอิงเป็นชื่อ  ตัวอย่างเช่นการใช้ชื่อต่อไปนี้ถือว่าไม่ถูกต้อง

 

add:  add   ax,cx

loop: inc   dx

end:  jmp   stop 

                  

เครื่องมือโปรแกรมภาษาแอสเซมบลี

   การโปรแกรมภาษาแอสเซมบลีจำเป็นต้องใช้เครื่องมือหลายอย่างช่วยในการสร้างโปรแกรม เครื่องมือเหล่านี้ได้แก่ เอดิเตอร์ใช้สร้างโปรแกรม, แอสเซมเบลอร์ใช้แปลโปรแกรม, ลิงเกอร์ใช้เชื่อมโยงโปรแกรม และดีบักเกอร์ใช้สำหรับตรวจวิเคราะห์ข้อผิดพลาด

 

เอดิเตอร์

   เอดิเตอร์เป็นเครื่องมือเบื้องต้นสำหรับใช้ในการสร้างแฟ้มโปรแกรมภาษาแอสเซมบลี เอดิเตอร์สำหรับสร้างโปรแกรมในปัจจุบันมีมากมายหลายตัว ผู้เขียนโปรแกรมสามารถเลือกใช้ได้ตามความถนัด หากแต่มีข้อแม้ว่าต้องเป็นเอดิเตอร์ที่เก็บแฟ้มข้อมูลแบบแอสกี   โปรแกรมที่สร้างขึ้นจะเรียกว่าโปรแกรมต้นฉบับภาษาแอสเซมบลี หรือเรียกโดยย่อว่า โปรแกรมต้นฉบับ (Source program)  โปรแกรม FIIRST.ASM  ตามรูปที่ 1.1 เป็นโปรแกรมตัวอย่างที่สร้างจากเอดิเตอร์แอสกี 

   โปรแกรมข้างต้นประกอบไปด้วยคำสั่งที่ทำหน้าที่พิมพ์ข้อความ "My first assembly language program" ออกทางจอภาพ   โปรแกรม FIRST.ASM ใช้นามสกุล แฟ้มว่า .ASM  เพื่อให้สื่อความหมายถึงโปรแกรมภาษาแอสเซมบลี นอกจากนี้ยังช่วยย่นย่อการสั่งงานเมื่อเรียกแอสเซมเบลอร์มาแปลโปรแกรมเพราะไม่จำเป็นต้องป้อนนามสกุล เพราะแอสเซมเบลอร์จะนำแฟ้มที่มีนามสกุล .ASM มาแปลโดยอัตโนมัติ

 

1.       ;------------------------------------------

2.       ;first.asm

3.       ;

4.       ;Generate executable file first.exe with :

5.       ;     masm first;

6.       ;     link first;

7.       ;

8.       ;------------------------------------------

9.       ;

10.                   dosseg

11.                   .model small

12.       

13.                   .stack 100h

14.       

15.                   .data

16.      mesg         db  'My first assembly language program'

17.                   db  0dh,0ah,'$'            ; newline

18.       

19.                   .code

20.      start:       mov    ax,@data             ; Load segment location

21.                   mov    ds,ax                ;   into ds

22.       

23.                   mov    dx,offset mesg       ; Load address of message

24.                   mov    ah,9                 ; DOS  String display func.

25.                   int    21h                  ; Call DOS

26.       

27.                   mov    ax,4c00h             ; DOS Exit func.

28.                   int    21h                  ; Call DOS

29.       

30.                   end    start

รูปที่ 1.1 โปรแกรม FIRST.ASM

 

   บรรทัดที่ 1 ถึง 9 ของโปรแกรม FIRST.ASM เป็นคำอธิบายรายละเอียดทั่วไป  ในบรรทัดที่ 10 บรรจุคำสั่งเทียม dosseg ซึ่งเป็นคำสั่งบ่งบอกการจัดแบ่งหน่วยความจำให้กับตัวโปรแกรมออกเป็นส่วนๆ ตามที่ได้กำหนดให้ไว้ก่อน  ซีพียูในตระกูล 8086 จะแบ่งโปรแกรมออกเป็นส่วนย่อยเรียกว่า เซกเมนต์ (Segment)  เซกเมนต์ของโปรแกรมมักประกอบด้วย เซกเมนต์คำสั่ง (Code segment) ซึ่งใช้เก็บคำสั่ง เซกเมนต์ข้อมูล (Data segment) สำหรับใช้เก็บตัวแปร และ เซกเมนต์สแต็ก (Stack segment) ซึ่งใช้เก็บตำแหน่งที่อยู่เมื่อมีการเรียกใช้โปรแกรมย่อย คำสั่งเทียม dosseg ส่งผลให้มีการสร้างเซกเมนต์ของโปรแกรมโดยเริ่มต้นด้วยเซกเมนต์คำสั่ง แล้วต่อด้วยเซกเมนต์ข้อมูล และเซก เมนต์สแต็กตามลำดับ 

   บรรทัดที่ 11 กำหนดขนาดของโปรแกรมแบบ  small ซึ่งจะทำให้เซกเมนต์ของคำสั่งและข้อมูลมีขนาดได้สูงสุดเซกเมนต์ละ 64 กิโลไบต์ และในบรรทัดที่ 13  เป็นคำสั่งเทียม .stack กำหนดขนาดของแสต็กขนาด 256 ไบต์

   บรรทัดที่ 15 เป็นคำสั่งเทียม .data กำหนดจุดเริ่มต้นของเซกเมนต์ข้อมูล และมีการสร้างตัวแปร mesg  โดยใช้คำสั่งเทียม  db   ตัวแปร mesg  บรรจุสายอักขระ 'My first assembly language program' ที่ต้องการพิมพ์บนจอภาพพร้อมทั้งรหัสขึ้นบรรทัดใหม่ (0dh และ 0ah)   ส่วนสัญลักษณ์ ‘$’ เป็นรหัสบอกถึงจุดสุดท้ายของสายอักขระ

   บรรทัดที่ 19 เป็นคำสั่งเทียม .code กำหนดจุดเริ่มต้นของเซกเมนต์คำสั่ง  บรรทัดที่ 20 เป็นคำสั่งอ่านค่าเซกเมนต์ข้อมูลมาเก็บไว้ที่รีจิสเตอร์ AX และ ในบรรทัดที่ 21 ให้นำค่าจากรีจิสเตอร์ AX ไปไว้ในรีจิสเตอร์ DS  

   คำสั่งในบรรทัดที่ 23 ถึง 25 เป็นคำสั่งพิมพ์สายอักขะที่เก็บอยู่ในตัวแปร mesg  ออกไปยัง
จอภาพด้วยการเรียกใช้บริการจากดอสผ่านคำสั่ง int 21h ฟังก์ชันการบริการของดอสซึ่งทำหน้าที่พิมพ์สายอักขระจะต้องกำหนดค่า 9 ไว้ในรีจิสเตอร์ AH  และตำแหน่งหน่วยความจำที่เก็บสายอักขระไว้ในรีจิสเตอร์ DX  

   คำสั่งในบรรทัดที่ 27 ถึง 29 เป็นคำสั่งจบการทำงานของโปรแกรมและโอนการทำงานกลับไปยังดอส โดยยังคงใช้ int 21h  และกำหนดหมายเลขฟังก์ชันสำหรับจบโปรแกรมซึ่งเท่ากับ  4CH ไว้ในรีจิสเตอร์ AH  ตลอดจนกำหนดรหัสการจบโปรแกรมด้วยค่า 00H ไว้ในรีจิสเตอร์ AL  

   คำสั่ง end สุดท้ายในบรรทัดที่  30 เป็นคำสั่งบอกถึงจุดสิ้นสุดของโปรแกรม และกำกับด้วยเลเบล start  เพื่อบอกให้แอสเซมเบลอร์ทราบถึงตำแหน่งคำสั่งแรกในโปรแกรมแอสเซมเบลอร์ 

   คอมพิวเตอร์ทำงานตามคำสั่งภาษาเครื่องจึงไม่สามารถเข้าใจความหมายของภาษาแอสเซมบลีได้โดยตรง เราจึงจำเป็นต้องอาศัยโปรแกรมที่ทำหน้าที่แปลภาษาแอสเซมบลีใปเป็นภาษาเครื่อง ตัวแปลภาษาดังกล่าวเรียกว่า แอสเซมเบลอร์ (Assembler)

   แอสเซมเบลอร์โดยทั่วไปของระบบไมโครคอมพิวเตอร์จะแปลแฟ้มโปรแกรมต้นฉบับและเก็บผลลัพธ์ภาษาเครื่องอยู่ในรูปของแฟ้มโปรแกรมอีกแฟ้มหนึ่ง แฟ้มโปรแกรมที่ได้จากการแปลเรียกว่า โปรแกรมออปเจ็ค (Object program) และโดยปกติจะใช้นามสกุล  .OBJ   แอสเซมเบลอร์ยังสร้างแฟ้มนามสกุล  .LST  ซึ่งบรรจุคำสั่งเหมือนกับแฟ้ม  .ASM พร้อมด้วยรหัสภาษาเครื่องกำกับแต่ละคำสั่ง แฟ้ม  .LST เป็นแฟ้มเผื่อเลือกที่ผู้ใช้กำหนดเองว่าต้องการให้แอสเซมเบลอร์สร้างหรือไม่

   แอสเซมเบลอร์ที่นิยมใช้กันในปัจุบันได้แก่มาโครแอสเซมเบลอร์ (MASM) ของไมโครซอฟต์ หรือเทอร์โบแอสเซมเบลอร์ (TASM) ของบริษัทบอร์แลนด์  ตัวอย่างการแปลโปรแกรม FIRST.ASM โดยใช้  MASM ให้ใช้คำสั่งต่อไปนี้

 

C:>\masm first;

Microsoft (R) Macro Assembler Version 5.00

Copyright (C) Microsoft Corp 1981-1985, 1987.  All rights reserved.

51536 + 363616 Bytes symbol space free

0 Warning Errors

0 Severe  Errors

C:\>

 

หรือเมื่อใช้  TASM ให้ใช้คำสั่งต่อไปนี้ 

 

C:\>tasm first;

Turbo Assembler  Version 1.0  Copyright (c) 1988 by Borland International

Assembling file:   FIRST.ASM

Error messages:    None

Warning messages:  None

Remaining memory:  405k

C:\>

 

   ขอให้สังเกตุว่าเราไม่จำเป็นต้องป้อนนามสกุล .ASM ต่อท้ายชื่อ เนื่องจากทั้ง MASM และ TASM  จะนำแฟ้ม FIRST.ASM มาแปลโดยอัตโนมัติ  ยกเว้นในกรณีที่เราตั้งชื่อโปรแกรมต้นฉบับโดยไม่ได้ใช้นามสกุล .ASM  ก็จำเป็นต้องกำหนดนามสกุลต่อท้ายชื่อแฟ้มด้วย

   คำสั่งข้างต้นยังใช้พารามิเตอร์ ";" เพื่อบังคับให้แอสเซมเบลอร์สร้างแฟ้ม .OBJ โดยให้คงชื่อ FIRST ไว้ดังเดิม เมื่อใช้คำสั่งขอดูรายชื่อแฟ้มจะพบแฟ้ม FIRST.OBJ ที่แอสเซมเบลอร์สร้างขึ้นดังตัวอย่าง

 

C:\>dir first.*

Volume in drive C is NGUAN

Volume Serial Number is 1CCE-8CCB

Directory of C:\

FIRST    ASM           577 06-23-94  11:26a

FIRST    OBJ           271 06-23-94  11:26a

2 file(s)            742 bytes

100,265,984 bytes free

 

ลิงเกอร์

   ถึงแม้ว่าการแปลโปรแกรมด้วยแอสเซมเบลอร์จะได้โปรแกรมออบเจ็คที่บรรจุรหัสภาษาเครื่อง แต่โปรแกรมออบเจ็คดังกล่าวยังไม่สามารถนำมาใช้งานได้ ทั้งนี้เพราะรหัสภาษาเครื่องที่ได้ยังไม่สมบูรณ์ ก่อนการเรียกใช้โปรแกรมจำเป็นต้องผ่านขั้นตอนอีกขั้นหนึ่งคือ การลิงค์ (Linking)

   การลิงค์จะทำหน้าที่แปลงโปรแกรมออปเจ็คต์ไปเป็นโปรแกรมที่ทำงานได้  ในที่นี้คือการแปลงจาก FIRST.OBJ ไปเป็น FIRST.EXE การสร้างโปรแกรม FIRST.EXE สามารถใช้โปรแกรม LINK ของไมโครซอฟต์ตามตัวอย่าง

 

C:>link first;

Microsoft (R) Segmented-Executable Linker  Version 5.13

Copyright (C) Microsoft Corp 1984-1991.  All rights reserved.

C:\>

 

หรือใช้โปรแกรม TLINK ของบอร์แลนด์ตามตัวอย่าง

 

C:>tlink first;

Turbo Link  Version 2.0  Copyright (c) 1987, 1988 Borland International

C:\>

 

   เมื่อเสร็จสิ้นขั้นตอนการลิงค์จะได้แฟ้ม  FIRST.EXE ที่พร้อมจะใช้งานได้ดังนี้

 

C:\>dir first.*

Volume in drive C is NGUAN

Volume Serial Number is 1CCE-8CCB

Directory of C:\

FIRST    ASM           577 06-23-94  11:26a

FIRST    EXE           583 07-03-94  11:36a

FIRST    OBJ           271 06-23-94  11:26a

3 file(s)          1,447 bytes

 

   ลิงเกอร์ยังสร้างแฟ้มนามสกุล  .MAP  ซึ่งบรรจุรายละเอียดเกี่ยวกับตัวโปรแกรม, ข้อมูลที่ใช้ในตัวโปรแกรม และสแต็ก  แฟ้ม .MAP เป็นแฟ้มเผื่อเลือกที่ผู้ใช้กำหนดได้เองว่าต้องการให้ลิงเกอร์สร้างหรือไม่ รายละเอียดเก่ยวกับแฟ้ม  .MAP จะกล่าวอีกครั้งในบทที่ 5

 

การสั่งงานจากดอส

   เมื่อต้องการสั่งงานโปรแกรม ให้พิมพ์ชื่อแฟ้มจากเครื่องหมายเตรียมพร้อมของดอสดังตัวอย่างต่อไปนี้

 

C:\>first

My first assembly language program

C:\>

 

   แฟ้ม .EXE จะประกอบด้วยข้อมูลรายละเอียดสำคัญเกี่ยวกับตัวโปรแกรมอยู่ในส่วนต้นของแฟ้ม เมื่อพิมพ์ชื่อโปรแกรมจากเครื่องหมายเตรียมพร้อมของดอส ดอสจะถอดรหัสจากข้อมูลส่วนหัวของแฟ้ม  .EXE และอ่านโปรแกรมลงสู่หน่วยความจำให้ซีพียูปฏิบัติงานตามคำสั่งต่อไป

 

ดีบักเกอร์

   ดีบักเกอร์เป็นเครื่องมือสำคัญอีกโปรแกรมหนึ่งสำหรับใช้ในการตรวจสอบขั้นตอนการทำงานของโปรแกรมที่เขียนขึ้น ดีบักเกอร์ช่วยให้ผู้เขียนโปรแกรมสามารถทดสอบและตรวจผลลัพธ์การทำงานของคำสั่งไปทีละคำสั่ง  ดีบักเกอร์จึงเป็นเครื่องมือสำคัญในการค้นหาและ  วิเคราะห์ข้อผิดพลาดของโปรแกรม  ตัวอย่างข้างล่างนี้เป็นการเรียกใช้โปรแกรม  DEBUG เพื่อตรวจสอบโปรแกรม FIRST.EXE ที่ได้จากการแปล

 

C:\>debug first.exe    ดีบักโปรแกรม FIRST.EXE
-u          ขอดูโปรแกรม
202E:0010 B83020        MOV     AX,2030
202E:0013 8ED8          MOV     DS,AX
202E:0015 BA0200        MOV     DX,0002
202E:0018 B409          MOV     AH,09
202E:001A CD21          INT     21
202E:001C B8004C        MOV     AX,4C00
202E:001F CD21          INT     21
202E:0021 004D79        ADD     [DI+79],CL
202E:0024 206669        AND     [BP+69],AH
202E:0027 7273          JB      009C
202E:0029 7420          JZ      004B
202E:002B 61            DB      61
202E:002C 7373          JNB     00A1
202E:002E 65            DB      65
202E:002F 6D            DB      6D
-r          ขอดูรีจิสเตอร์
AX=0000  BX=0000  CX=0047  DX=0000  SP=0100  BP=0000  SI=0000  DI=0000
DS=201E  ES=201E  SS=2033  CS=202E  IP=0010   NV UP EI PL NZ NA PO NC
202E:0010 B83020        MOV     AX,2030
-g          สั่งทำงาน    My first assembly language program Program terminated normally ผลลัพธ์พิมพ์ทางจอภาพ -q          เลิกโปรแกรมดีบัก C:\>

 

   โปรแกรมดีบักเกอร์ที่นิยมใช้อยู่ในปัจุจุบันได้แก่ DEBUG ของไมโครซอฟต์ ซึ่งเป็นดีบักเกอร์ระดับภาษาเครื่อง นอกจากนี้ยังมี TDEBUG ของบอร์แลนด์ และ CODEVIEW ของไมโครซอฟต์ซึ่งเป็นดีบักเกอร์ในระดับภาษาแอสเซมบลีต้นฉบับ

CREF และ LIB

   เครื่องมือช่วยพัฒนาโปรแกรมภาษาแอสเซมบลีที่สำคัญจากรูปที่ 1.1 ซึ่งยังไม่ได้กล่าวถึงคือ โปรแกรมจัดทำข้อมูลอ้างอิง (Cross Reference) และโปรแกรมจัดการคลังโปรแกรม (Library Manager) ซึ่งผลิตภัณฑ์ของไมโครซอฟต์ใช้ชื่อ  CREF  และ LIB ตามลำดับ

   โปรแกรม CREF ทำหน้าที่แปลงแฟ้ม .CRF ที่ได้จากขั้นตอนของการแปลด้วยแอสเซมเบลอร์ ไปเป็นแฟ้มแอสกีนามสกุล  .REF  แฟ้ม  .REF จะบรรจุรายละเอียดการใช้เลเบล และการจัดวางหน่วยความจำเพื่อใช้เป็นข้อมูลอ้างอิง  แอสเซมเบลอร์จะสร้างแฟ้ม .CRF  หรือไม่ขึ้นอยู่กับพารามิเตอร์ที่ผู้ใช้กำหนดเมื่อสั่งแปลโปรแกรม 

   โปรแกรม LIB ทำหน้าที่ร่วมกับ LINK ในการสร้างหรือปรับเปลี่ยนคลังโปรแกรม .LIB ซึ่งเป็นที่รวมของแฟ้ม .OBJ หลาย ๆ แฟ้ม   ในการพัฒนาโปรแกรมขนาดใหญ่ นักเขียนโปรแกรมมักจะแยกโปรแกรมออกเป็นโมดูลและแปลโมดูลนั้นเป็นแฟ้ม .OBJ  หากว่า แฟ้ม .OBJ อยู่ในรูปของโปรแกรมย่อยที่ไม่มีการเปลี่ยนแปลงใดอีก ผู้เขียนโปรแกรมก็นิยมรวมแฟ้ม .OBJ ไว้เป็นคลังโปรแกรมในรูปของแฟ้มนามสกุล  .LIB  เมื่อต้องการเพิ่มหรือเปลี่ยนแปลงส่วนหนึ่งส่วนใดของแฟ้ม  .LIB ก็จะใช้โปรแกรม LIB เป็นตัวช่วยจัดการแฟ้ม .COM

    นอกเหนือไปจากแฟ้มนามสกุล  .EXE แล้ว ยังมีแฟ้มอีกประเภทหนึ่งซึ่งเป็นแฟ้มโปรแกรมที่ทำงานได้เช่นเดียวกับแฟ้ม .EXE  แฟ้มดังกล่าวได้แก่แฟ้ม .COM 

แฟ้ม .COM  สามารถสร้างได้จากการเขียนโปรแกรมด้วย  DEBUG โดยตรง หรือใช้โปรแกรม  EXE2BIN แปลงจากแฟ้ม  .EXE   ไปเป็น .COM  การแปลงแฟ้ม .EXE  ไปเป็นแฟ้ม .COM  จะได้โปรแกรมที่มีขนาดเล็กกระทัดรัดกว่า หากแต่มีข้อจำกัดหลายอย่างโดยเฉพาะขนาดของโปรแกรมที่มีได้ไม่เกิน 64  แฟ้ม .COM  จึงเหมาะสำหรับโปรแกรมขนาดเล็ก

แฟ้ม .COM  จะมีจุดเริ่มต้นโปรแกรมที่หน่วยความจำ 100h เสมอ การเขียนโปรแกรมในรูปของ  .COM  จึงมีรูปแบบแตกต่างไปจากการเขียนโปรแกรมเพื่อสร้างแฟ้ม  .EXE ตัวอย่างในรูปที่ 1.2 แสดงถึงโปรแกรม FIRST.ASM ซึ่งเขียนเพื่อสร้างโปรแกรม FIRST.COM 

 

1.       ;------------------------------------------

2.       ;fcom.asm

3.       ;

4.       ;Generate executable file first.com with :

5.       ;     masm fcom;

6.       ;     link fcom;

7.       ;     exe2bin fcom.exe fcom.com

8.       ;------------------------------------------

9.       ;

10.      prg          segment

11.                   assume cs:prg, ds:prg, ss:prg

12.                   org    0100h

13.      start: jmp    begin

14.      mesg         db  'My first assembly language program'

15.                   db  0dh,0ah,'$'            ; newline

16.       

17.      begin: mov    dx,offset mesg       ; Load address of message

18.                   mov    ah,9                 ; DOS  String display func.

19.                   int    21h                  ; Call DOS

20.       

21.                   mov    ax,4c00h             ; DOS Exit func.

22.                   int    21h                  ; Call DOS

23.                   end    start

รูปที่ 1.2 ตัวอย่างโปรแกรมแอสเซมบลีเพื่สร้างแฟ้มแบบ .com

 

โปรแกรมAssembler

     โปรแกรมที่เขียนด้วยรหัส Mnemonics เรียกว่า ภาษา Assembly และก่อนที่จะให้ CPU ทำงานตามโปรแกรมที่เขียนด้วยภาษา Assembly ได้ต้องเปลี่ยนให้เป็นภาษา Machineก่อน โดยใช้โปรแกรมพิเศษช่วยเปลี่ยนเรียกว่า Assembler โดยปกติ โปรแกรมจะเขียนในรูป Assembly ซึ่งมีข้อดีกว่าเขียนด้วยภาษา Machine กล่าวคือ เขียนได้รวดเร็วกว่าจำได้ง่ายและ ตัวโปรแกรม Assembler จะมีส่วนช่วยในการตรวจสอบโปรแกรมด้วย จึงต้องใช้ตัว Assembler และระบบพัฒนาบนคอมพิวเตอร์ PC โปรแกรมที่ใช้งานแอสเซมเบลอร์มีอยู่หลายโปรแกรมอาทิเช่น CROSS32, X51 ,ASM51 และ SXA51

SXA51
     SXA51 เป็นโปรแกรมที่ใช้ในการ Assembler ซีพียู MCS-51 โดยเราเขียนโปรแกรมที่เป็น Source โปรแกรม ด้วยโปรแกรมอีดิเตอร์ตัวใดก็ได้ (Q-EDIT, SK, EditPlus2, EDIT For Dos หรือ UltraEdit-32) แล้วให้ทำการบันทึกเป็นไฟล์นามสกุล .ASM ไว้โดยเขียนเฉพาะคำสั่งเท่านั้นแล้วตัวโปรแกรม SXA51 จะทำการแปลภาษาเครื่องออกมา เป็นเลขฐาน16 สามารถนำมาโปรแกรมให้กับไอซีได้เลย

                       C:\ > SXA51 - <Option> File name.ASM <CR>

- <OPTION> แสดงตัวเลือกให้ดังรายการ
-L = ให้สร้างไฟล์แสดงรายละเอียด Address Op-code โดยจะได้ไฟล์นามสกุล .LST
-N = ไม่สร้างไฟล์เอาต์พุตใดๆ เพื่อความรวดเร็ว
-C = สร้าง Symbol cross-reference ไว้ที่ท้ายของโปรแกรมเพื่อความสะดวกของการหาตำแหน่งของ LABLE
-D = แสดง Process ขณะที่กำลังทำการAssemblerโดยโปรแกรมจะแสดงเลขบรรทัดที่กำลังแปลอยู่

 

โปรแกรมแอสเซมเบลอร์ Cross32

      โปรแกรม Cross32 เป็นโปรแกรมครอส - แอสเซมเบลอร์ (Cross - Assembler) แบบตรวจสอบสองครั้ง (two pass) โดยมีทางเลือกแบบตรวจสอบครั้งที่สาม (third pass) ถ้าหากตรวจสอบพบ phase errorในโปรแกรมต้นแบบ การใช้งานโปรแกรม Cross32 จะต้องมีการกำหนดเบอร์ของไมโครโพรเซสเซอร์ที่ต้องการ โดยใช้คำสั่ง CPU directive ในส่วนหัวของโปรแกรม เช่น CPU "8051.TBL" จะเป็นการระบุให้โปรแกรม Cross32 ทราบว่าต้องการใช้ตารางคำสั่งของ CPU เบอร์8051 และต้องกำหนดรูปแบบของไฟล์แสดงรหัสภาษาเครื่อง โดยการใช้คำสั่ง HOF directive เพื่อระบุให้โปรแกรม ครอส 32 ทราบว่า จะต้องวางไฟล์ตามมาตรฐานใด เช่น HOF "INT8" เป็นการกำหนดว่าให้วางไฟล์ในรูปแบบตามมาตรฐานของบริษัทอินเทล เป็นต้น
การเขียนโปรแกรมจะใช้เทกซ์ เอดิเตอร์(Text Editor) สร้างโปรแกรมต้นแบบ โดยพิมพ์ที่ส่วนหัวของโปรแกรมที่มีรายละเอียดดังนี้
             CPU "8051.TBL"          ;ระบุตารางคำสั่งของไมโครคอนโทรลเลอร์เบอร์ 8051
             HOF "INT8"             ;กำหนดรูปแบบของไฟล์แสดงรหัสมาตฐานอินเทล
             ORG 0000H             ;ระบุตำแหน่งแอดเดรสในหน่วยความจำเพื่อที่จะให้                         
                                       ; เริ่มต้นการทำงานของโปรแกรม
.
                                       . ;ส่วนของโปรแกรมที่เป็นคำสั่ง(แอสเซมบลี)
.
             END                        ;จบโปรแกรม

รูปแบบของคำสั่งที่ใช้งานจะเป็นดังนี้

                C32 Filename.asm [-L LISTFILE] [-H HEXFILE)
โดยที่ส่วนที่อยู่ภายใน [ ] เป็นทางเลือก จะใช้หรือไม่ใช้ก็ได้
Filename.asm หมายถึง โปรแกรมต้นแบบ (Source Program) ที่เขียนขึ้นโดยมีนามสกุลเป็นจุด ASM
- L list file หมายถึง ให้ Cross32 สร้างไฟล์แสดงรายละเอียดการแอสเซมเบลอร์ (assemble listing file) โดยใช้ชื่อไฟล์ที่ตามหลังมา (ในที่นี้คือ list file)
- H hex file หมายถึง ให้ Cross32 สร้างไฟล์รหัสภาษาเครื่อง (machine code) ออกมาในไฟล์ที่ ตามหลังมา (ในที่นี้คือ hex file)
ถ้าไม่ใช้ทางเลือก - L หรือ - H โปรแกรม Cross32จะไม่สร้างไฟล์เหล่านี้ ขึ้นมา ในกรณีเช่นนี้รหัสที่แสดงการผิดพลาด (error code) จะแสดงออกมาจอภาพ (ถ้ามี) แต่ถ้าเลือกทางเลือก - L แล้ว รหัสผิดพลาดจะถูกสร้างขึ้นใน list file ด้วย (ใช้โปรแกรมTex Editor ตรวจสอบรายละเอียด ของข้อผิดพลาดในตำแหน่งต่างๆได้ ) 

 

โปรแกรมแอสเซมเบลอร์อื่นๆ

            โปรแกรมที่เป็นแอสเซมเบลอร์ตัวอื่นๆ อาจจะมีวิธีการใช้กำกับมาด้วย การใช้งานและคำสั่งที่เป็นแอสเซมเบลอร์ไดเร็กทีฟ (Assembler Directives) จะเป็นของแอสเซมเบลอร์แต่ละตัว แต่จะใกล้เคียงกันมากส่วนคำสั่งของ MCS-51 จะใช้เหมือนกันทุกประการ โปรแกรมแอสเซมเบลอร์อื่นๆสามารถที่จะดาว์นโหลดหามาได้จากเวปไซด์ดังนี้
ASMB51: http://www.atmel.com/atmel/products/prod74.htm 
ASM51: http://chaokhun.kmitl.ac.th/~kswichit/C52EVB/asm51 
AS31: http://www.pjrc.com/tech/8051/index.html#as31_assembler 
SXA51: http://www.kmitl.ac.th/electronics/article/Mcs-51/uedit1.html 
Reads51: http://www.rigelcorp.com/8051/SetupReads51.exe (for window)

 

 

แอสเซมเบลอร์และภาษาแอสเซมบลี 

 

   เนื่องจากในปัจจุบันมนุษย์ได้พัฒนาคอมพิวเตอร์ให้มาเป็นเครื่องมือที่ทรงประสิทธิ์ภาพของมนุษย์ ดังนั้นเราจึงจำเป็นจะต้องเรียนรู้วิธีการทำงานของเครื่องคอมพิวเตอร์ วิธีการใช้งานและวิธีสั่งการคอมพิวเตอร์ แต่เนื่องจากคอมพิวเตอร์เป็นเครื่องจักรซึ่งจะรู้จักเฉพาะภาษาเครื่องเท่านั้น และภาษาเครื่องนั้นก็ยากเกินกว่าที่มนุษย์จะเข้าใจ จึงทำให้เกิดภาษาคอมพิวเตอร์ขึ้น 

 

1. ภาษาคอมพิวเตอร์ 

   ภาษาคอมพิวเตอร์คือภาษาที่ใช้สื่อสารระหว่างมนุษย์กับคอมพิวเตอร์ แต่เนื่องจากในปัจจุบัน คอมพิวเตอร์ไม่สามารถคิดเองได้ ดังนั้นภาษาคอมพิวเตอร์ส่วนใหญ่จึงเป็นการสั่งงานคอมพิวเตอร์มากกว่าการพูดคุยกับคอมพิวเตอร์ 

1.1 ระดับของภาษาคอมพิวเตอร์

ในปัจจุบัน ภาษาคอมพิวเตอร์ได้มีการพัฒนาขึ้นมาอย่างรวดเร็ว ทำให้เกิดภาษาคอมพิวเตอร์ขึ้นมามากมาย แต่เราก็สามารถแบ่งภาษาต่างๆ ที่มีอยู่ในปัจจุบันออกได้เป็น 2 ระดับคือ

1. ภาษาระดับต่ำ ได้แก่ภาษาเครื่อง และภาษาสัญลักษณ์ต่างๆ ที่มีรูปแบบใกล้เคียงกับภาษาเครื่อง รวมทั้งภาษาแอสเซมบลีด้วย ซึ่งจะค่อนข้างยากที่จะทำความเข้าใจกับภาษานี้

2. ภาษาระดับสูง ได้แก่ภาษาคอมพิวเตอร์ที่มีรูปแบบคล้ายภาษามนุษย์มากขึ้น ทำให้มนุษย์สามารถเข้าใจภาษาระดับนี้ง่ายขึ้น 

1.2 การแปลภาษาคอมพิวเตอร์ให้เป็นภาษาเครื่อง 

 ปัจจุบันภาษาคอมพิวเตอร์มีอยู่หลายภาษามาก แต่ก็ยังมีเพียงแค่ภาษาเดียวที่คอมพิวเตอร์สามารถเข้าใจได้ ซึ่งก็คือภาษาเครื่อง ดังนั้นเราจึงจำเป็นที่จะต้องทำการแปลงภาษาในแต่ละภาษาให้อยู่ในรูปแบบของภาษาเครื่องเพื่อทำให้คอมพิวเตอร์สามารถเข้าใจได้

 

ซึ่งวิธีการแปลภาษานั้นเราสามารถแบ่งออกได้เป็น 3 รูปแบบคือ

1. Assembling[1] คือรูปแบบการแปลภาษาแอสเซมบลีให้เป็นภาษาเครื่อง ถึงแม้ว่าภาษาแอสเซมบลีจะมีลักษณะภาษาเครื่องมากอยู่แล้วก็ตาม แต่คอมพิวเตอร์ก็ยังไม่สามารถเข้าใจภาษาแอสเซมบลีได้ จึงจำเป็นต้องมีการแปลก่อนถึงจะนำไปให้งานได้ 

2. Compiler คือรูปแบบการแปลภาษาคอมพิวเตอร์แบบหนึ่ง โดยจะทำการตรวจสอบไวยากรณ์ (Syntax) ของภาษานั้นๆ ทั้งหมดก่อน แล้วจึงเริ่มทำการการแปลให้อยู่ในรูปภาษาเครื่อง แล้วจึงทำงานรวดเดียว

3. Interpreter คือรูปแบบการแปลภาษาคอมพิวเตอร์ ที่จะทำการตรวจสอบไวยากรณ์ของภาษานั้นๆ ทีละคำสั่ง แล้วจึงทำการแปลและทำงานตามคำสั่งนั้น ทำเช่นนี้ทีละคำสั่ง ทำไปเรื่อยๆ จนจบโปรแกรม 

 

2. ภาษาแอสเซมบลี 

   ในระยะแรกๆ ที่เริ่มมีการสร้างคอมพิวเตอร์ขึ้นมาเพื่อใช้งานนั้น มนุษย์เราก็ได้สั่งงานคอมพิวเตอร์โดยใช้ภาษาเครื่องเป็นหลัก แต่เมื่อคอมพิวเตอร์มีการพัฒนาขึ้นมา การเขียนโปรแกรมเริ่มมีความซับซ้อนมากยิ่งขึ้น การใช้ภาษาเครื่องในการเขียนโปรแกรมนั้น เริ่มไม่ค่อยสะดวก จึงได้มีการสร้างภาษาสัญลักษณ์ขึ้นมา แทนการใช้ภาษาเครื่อง ซึ่งภาษาแอสเซมบลีก็ถือว่าเป็นภาษาสัญลักษณ์ภาษาหนึ่งเช่นกัน ภาษาประเภทนี้จะมีโครงสร้างการเขียนโปรแกรมใกล้เคียงกับภาษาเครื่องมาก 

2.1 ข้อดีของภาษาแอสเซมบลี 

           เนื่องจากภาษาแอสเซมบลีใกล้เคียงกับภาษาเครื่องมาก ดังนั้นเวลาที่ใช้ในการแปล และรันโปรแกรมนั้นจะเร็วมาก และสามารถทำงานทุกอย่างที่คอมพิวเตอร์เครื่องนั้นสามารถทำงานได้โดยไม่มีข้อจำกัด 

2.2 ข้อเสียของภาษาแอสเซมบลี 

           เนื่องจากภาษาแอสเซมบลีมีโครงสร้างภาษาใกล้เคียงกับภาษาเครื่องมาก จึงทำให้มนุษย์ไม่สามารถเข้าใจภาษานี้ได้ง่ายๆ และภาษานี้ไม่เหมาะกับการเขียนโปรแกรมที่มีความซับซ้อนมากๆ เพราะอาจจะทำให้เสียเวลานานในการตรวจสอบและแก้ไขโปรแกรมในภายหลัง 

 

3.แอสเซมเบลอร์

  ในการเขียนโปรแกรมภาษาแอสเซมบลีจริงๆ แล้วนั้น เราจะใช้แอสเซมเบลอร์ซึ่งเป็นโปรแกรมตัวหนึ่ง ที่ช่วยในการแปลจากภาษาแอสเซมบลี ให้กลายเป็นภาษาเครื่อง โดยปกติเราจะนิยมใช้แอสเซมเบลอร์ในการเขียนโปรแกรมภาษาแอสเซมบลี เนื่องจากมีความสะดวก และมีเครื่องที่ช่วยในการเขียนโปรแกรมมากมาย นอกจากนี้เรายังสามารถใช้กลุ่มคำสั่งเทียม (directives) และการกำหนดมาโคร (macro) ได้อีกด้วย

   ในการเขียนโปรแกรม ขั้นแรกเราจะสร้างไฟล์ภาษาแอสเซมบลีในรูปของโปรแกรมต้นฉบับ (Source program / source code) จากนั้นจะทำการ Assembling และ linking เพื่อแปลภาษาแอสเซมบลีที่อยู่ในรูปรหัสนีโมนิก (Mnemonic) ให้เป็นรหัสภาษาเครื่อง (Op-code) เพื่อให้สามารถรันโปรแกรมได้ โดยโปรแกรมแอสเซมเบลอร์จะแปลงโปรแกรมต้นฉบับให้เป็นภาษาเครื่อง โดยการแปลงนี้เราจะได้ไฟล์ใหม่ 3 ไฟล์คือ

1.Object file คือไฟล์ที่มีนามสกุล .OBJ ซึ่งจะประกอบด้วยภาษาเครื่องที่ใช้สำหรับแปลงเป็นไฟล์ .EXE (Executable file) โดยไฟล์นี้จะถูกสร้างโดยโปรแกรมแอสเซมเบลอร์และจะนำไปใช้ต่อโดยโปรแกรม LINK เพื่อทำให้ได้เป็นไฟล์ที่รันได้ (.EXE)

2. List file เป็นไฟล์ที่มีนามสกุล .LST ซึ่งจะบรรจุภาษาเครื่อง และโปรแกรมต้นฉบับ รวมทั้งอธิบายข้อผิดพลาดที่เกิดขึ้น (error) เพื่อให้เราสามารถแก้ไขข้อผิดพลาดของโปรแกรมได้ง่าย

3. Cross Reference File เป็นไฟล์ที่มีนามสกุลเป็น .CRF จะรวบรวมชื่อต่างๆ ที่ใช้ในโปรแกรมทั้งหมด

สำหรับโปรแกรม LINK จะทำหน้าที่แปลงไฟล์รหัสภาษาเครื่อง (object file) ให้เป็นไฟล์ที่สามารถทำงานได้ หรือ Executable file หลังจากทำการ linking เราจะได้ไฟล์ใหม่ 2 ไฟล์คือ

1.Run file เป็นไฟล์ที่มีนามสกุล .EXE ซึ่งสามารถโหลดลงหน่วยความจำและทำงานได้

2.Load map file เป็นไฟล์ที่มีนามสกุล .MAP ซึ่งจะบอกความสัมพันธ์ของเซกเมนต์ต่างๆ ในโปรแกรม

 

4. Turbo Assembly 

   ในหัวข้อนี้เราจะมาศึกษากันในเรื่องการใช้แอสเซมเบลอร์มาตรฐานตัวหนึ่งที่มีชื่อว่า Turbo Assembly ซึ่งเป็นแอสเซมเบลอร์ที่มีการนิยมใช้กันอย่างกว้างขวางมาก ทั้งในอดีตและในปัจจุบัน 

   Turbo Assembly (ต่อไปจะเรียกสั้นๆ ว่า TASM) เป็นโปรแกรมที่เขียนขึ้นจากบริษัท Borland การใช้งานโปรแกรมนี้ ท่านจะต้องมีไฟล์โปรแกรมที่จำเป็นคือ TASM.EXE และ LINK.EXE ซึ่งเป็นไฟล์โปรแกรมที่จะใช้ในการแปล และที่ขาดไม่ได้ ก็คือไฟล์โปรแกรมต้นฉบับที่ท่านเขียนขึ้นเอง และบันทึกลงดิสก์โดยให้มีนามสกุลเป็น .ASM

   การแปลงไฟล์ .ASM ไปเป็นไฟล์ OBJ สามารถทำได้โดยใช้คำสั่งดังนี้

TASM program.ASM

   หลังจากนั้นท่านจะได้ไฟล์ .OBJ ขึ้นมา ต่อไปเราจะทำให้มันสามารถรันได้ ด้วยคำสั่งดังนี้

LINK program.OBJ

   ท่านจะได้ไฟล์ .EXE ซึ่งเป็นไฟล์ที่สามารถนำไปรันได้โดยสมบูรณ์

 

 

5. โครงสร้างทั่วไปของภาษาแอสแซมบลี

5.1 ค่าคงที่

ค่าคงที่แบ่งออกเป็น 3 แบบคือค่าคงที่ชนิดตัวเลข ค่าคงที่ชนิดตัวอักษร และค่าคงที่ชนิดสตริง

โดยค่าคงที่ชนิดตัวเลขได้แก่

เลขฐานสิบ จะใช้เลข 0-9 ในการเขียน ส่วนในภาษาแอสเซมบลีจะเขียนตัวเลขแล้วตามด้วยตัว D เช่น 125D

เลขฐานสิบหก จะใช้เลข 0-9 และ A-F ในการเขียน และในภาษาแอสเซมบลีจะเขียนแล้วตามด้วยตัว H แต่ถ้าตัวเลขขึ้นต้นด้วยตัว A-F ให้ใส่ 0 ไว้หน้าตัวเลขด้วย เช่น 0AFH

เลขฐานสอง จะใช้เลข 0-1 ในการเขียน และในภาษาแอสเซมบลีจะเขียนแล้วตามด้วยตัว B เช่น 01B โดยทั่วไปแล้วเลขฐาน2จะใช้ในการทดสอบบิตต่างๆ

เลขฐานแปด จะใช้เลข 0-7 ในการเขียน และในภาษาแอสเซมบลีจะเขียนแล้วตามด้วยตัว O เช่น 04O

ค่าคงที่ชนิดตัวอักษร จะเขียนแทนด้วยตัวอักษรหนึ่งตัวอักษรแต่ตัวอักษรนั้นจะต้องอยู่ในเครื่องหมาย Single quote (‘)

ค่าคงที่ชนิดสตริง ที่จริงแล้วมีอยู่หลายแบบ เช่นค่าคงที่ชนิดสตริงแบบบิต ค่าคงที่ชนิดสตริงชนิดแบบไบต์ ค่าคงที่ชนิดสตริงแบบเวิร์ด แต่ในที่นี้เราจะหมายถึงค่าคงที่สตริงชนิดไบต์ ซึ่งเราสามารถเขียนเป็นข้อความใดๆ ก็ได้ แต่ข้อความนั้นจะต้องอยู่ในเครื่องหมาย single quote (‘) หรือ double quote (“) เช่น ‘Please input number : ’

           นอกจากนี้ถ้าเราต้องการบอกว่าเครื่องหมาย Double quote (“) หรือ single quote (‘) อยู่ในสตริงด้วย ให้ใช้เครื่องหมายใดเครื่องหมายหนึ่งคร่อมเครื่องหมายที่ต้องการ เช่น

‘This word “help” is meaning “explained”. ’  หรือ    “This word ‘help’ is meaning ‘explained’.”

5.2 รูปแบบของคำสั่งในภาษาแอสเซมบลี

ในภาษาแอสเซมบลี จะมีรูปแบบการเขียนคำสั่งดังนี้ 

[label:] Mnemonic [operand]
โดย Label หรือป้ายนั้นจะมีหรือไม่มีก็ได้ แล้วแต่ผู้ใช้จะกำหนด (เรื่องของป้ายนั้นเราจะไปศึกษากันตอนหลัง)
Mnemonic คือรหัสหรือคำสั่งภาษาแอสเซมบลีนั่นเอง
Operand คือส่วนที่จะนำมาดำเนินการตามคำสั่งแอสเซมบลีนั้นโดยจะมีหรือไม่มีนั้นขึ้นอยู่กับคำสั่งภาษาแอสเซมบลีคำสั่งนั้น

5.3 หมายเหตุ (Comment)

    ในการเขียนโปรแกรมทั่วไป ถ้าโปรแกรมที่มีการเขียนขึ้นมาอย่างซับซ้อน เราจำเป็นจะต้องมีหมายเหตุ เพื่ออธิบายส่วนต่างๆ ของโปรแกรม เพื่อให้ง่ายต่อการทำความเข้าใจตัวโปรแกรมเหล่านั้น โดยหมายเหตุเหล่านี้จะไม่มีกระทบใดๆ กับการทำงานของโปรแกรมเลยแม้แต่น้อย รูปแบบของหมายเหตุ คือจะขึ้นต้นด้วยเครื่องหมาย (;) และจบด้วยการขึ้นบรรทัดใหม่ ตัวอย่างเช่น

; this program write by MyDeViSion Group.
mov ax,50 ; move value 50 into register AX

5.4 คำสั่งเทียม (Directives)

    คือคำสั่งที่แอสเซมเบลอร์ได้เตรียมไว้ ไม่ถือว่าเป็นคำสั่งภาษาแอสเซมบลี โดยจะมีรูปแบบแตกต่างกันออกไป โดยส่วนใหญ่จะใช้ในการกำหนดค่าต่างให้กับแอสเซมเบลอร์ เพื่อให้        แอสเซมเบลอร์แปลภาษาแอสเซมบลีได้อย่างถูกต้องตามเป้าหมายของเรา หรือเพื่อเพิ่มความสะดวกในการเขียนโปรแกรม แต่เนื่องจากคำสั่งเทียมไม่ใช่คำสั่งในภาษาแอสเซมบลี ดังนั้นคำสั่งเทียมจะไม่ถูกแปลไปเป็นตัวโปรแกรมด้วย แต่จะช่วยกำหนดค่าต่างๆ ให้แอสเซมเบลอร์เพื่อให้แอสเซมเบลอร์ทำงานตามที่เราต้องการ 

5.5 โครงสร้างการโปรแกรมแอสเซมบลีบน Dos

   ในหัวข้อนี้ เราจะได้ทราบถึงวิธีการพิมพ์ค่า การรับค่า และการออกจากโปรแกรม ซึ่งจัดว่าเป็นการใช้งานบริการของ Dos ขั้นพื้นฐาน ซึ่งจะมีดังต่อไปนี้

1) การพิมพ์อักขระ เราจะเรียกใช้บริการของ Dos ผ่านทางการ interrupt (ซึ่งเราจะศึกษาในบทต่อๆไป) ซึ่งมีเงื่อนไขดังนี้

ก่อนเรียกคำสั่ง
ตัวแปรรีจิสเตอร์ AH ต้องกำหนดค่าให้เท่ากับ 2
ตัวแปรรีจิสเตอร์ DL เก็บรหัสแอสกีของตัวอักขระที่ต้องการจะแสดงผล
หลังเรียกคำสั่ง
ตัวแปรรีจิสเตอร์ AL จะเก็บค่ารหัสแอสกีของตัวอักขระที่ได้แสดงผลไป
ตัวอย่างการใช้งาน
mov ah,2 ; ทำการเรียกใช้บริการที่ 2 ของดอส (พิมพ์อักขระ)
mov dl,‘A’ ; กำหนดค่าให้กับตัวแปรรีจิสเตอร์ DL
int 21h ; เรียกใช้บริการของดอสผ่านทาง interrupt
; หมายเลข 21h
หมายเหตุ จะมีการพิมพ์อักขระออกมาจริงๆ ก็ต่อเมื่อเรียกคำสั่ง int 21h ขึ้นมาทำงานแล้วเท่านั้น
2) การพิมพ์สตริง เราจะเรียกใช้ผ่านทาง interrupt หมายเลข 21h เช่นเดิม
ก่อนเรียกคำสั่ง
ตัวแปรรีจิสเตอร์ AH ต้องกำหนดค่าให้เท่ากับ 9
ตัวแปรรีจิสเตอร์ DX ต้องกำหนดตำแหน่งเริ่มต้นของสตริง โดยสตริงนั้นจะต้องสิ้นสุดด้วยเครื่องหมาย $
ตัวอย่างการใช้งาน
mov ah,09 ;ทำการเรียกใช้บริการที่ 9 ของดอส (พิมพ์สตริง)
lea dx,string ;กำหนดตำแหน่งเริ่มต้นของสตริงไว้ใน DX โดยที่
; string คือตัวแปรที่ประกาศไว้ใน data segment
int 21h ;ทำการเรียกบริการของดอสผ่านทาง interrupt 21h
หมายเหตุ จะมีการพิมพ์สตริงออกมาจริงๆ ก็ต่อเมื่อเรียกคำสั่ง int 21h ขึ้นมาทำงานแล้วเท่านั้น
3) การรับอักขระ เราสามารถทำได้ดังนี้
ก่อนเรียกคำสั่ง
ตัวแปรรีจิสเตอร์ AH ต้องกำหนดค่าให้เท่ากับ 1
หลังเรียกคำสั่ง
ตัวแปรรีจิสเตอร์ AL จะเก็บค่ารหัสแอสกี้ของอักขระที่มีการรับเข้ามา
ตัวอย่างการใช้งาน
mov ah,01 ; ทำการเรียกใช้บริการที่ 1 ของดอส (รับอักขระ)
int 21h ; ทำการเรียกบริการของดอสผ่านทาง interrupt 21h
หมายเหตุ จะมีการรับอักขระเข้ามาจริงๆ ก็ต่อเมื่อเรียกคำสั่ง int 21h ขึ้นมาทำงานแล้วเท่านั้น
4) การรับสตริง
ก่อนเรียกคำสั่ง
ตัวแปรรีจิสเตอร์ AH ต้องมีค่าเท่ากับ 0AH

 

  ตัวแปรรีจิสเตอร์ DX ต้องชี้ไปยังตัวแปรชนิดสตริงที่ประกาศไว้ใน data segment โดยรูปแบบของตัวแปรชนิดสตริงเฉพาะในคำสั่งนี้จะแตกต่างจากรูปแบบสตริงทั่วไปตรงที่ เราต้องประกาศเนื้อที่ไว้ก่อนสตริงจริง 2 bytes โดยไบต์แรกจะต้องกำหนดขนาดสูงสุดของสตริง (โดยรวมอักขระของแป้นพิมพ์ enter ที่มีขนาดหนึ่งไบต์ไว้แล้วด้วย) และไบต์ที่สองจะถูกกำหนดโดยบริการของดอส ซึ่งไบต์นี้จะบอกถึงขนาดของสตริงที่มีการรับเข้ามา ดังรูป

ตำแหน่งในหน่วยความจำ	0010	0011	0012	0013	0014	0015
เลขฐานสิบหก/ค่ารหัสแอสกี	06	03	55	53	41	0D
ความหมาย/ตัวอักขระ	จำนวนสูงสุด	จำนวนที่รับเข้ามา	U	S	A	รหัสการกดปุ่ม enter

 

หลังเรียกคำสั่ง
ตัวแปรรีจิสเตอร์ DX จะชี้ไปยังตำแหน่งของสตริงที่รับเข้ามา ที่ถูกเก็บไว้ในตัวแปรชนิดสตริงที่ประกาศไว้ใน data segment
ตัวอย่างการใช้งาน
mov ah,0AH ; ทำการเรียกใช้บริการที่ 0AH ของดอส (รับสตริง)
mov dx,string ; ทำการกำหนดตำแหน่งเริ่มต้นของตัวแปรสตริงที่
;ได้ประกาศไว้ใน data segment ตามรูปแบบที่กล่าว
;ไว้ข้างต้น เพื่อจะรับค่าสตริงเข้ามาเก็บไว้ในตัวแปร
int 21h ; ทำการเรียกบริการของดอสผ่านทาง interrupt 21h
หมายเหตุ จะมีการรับสตริงเข้ามาจริงๆ ก็ต่อเมื่อเรียกคำสั่ง int 21h ขึ้นมาทำงานแล้วเท่านั้น
5) การออกจากโปรแกรม ทำได้โดยใช้คำสั่งจากดอส ดังนี้
ก่อนเรียกใช้คำสั่ง
ตัวแปรรีจิสเตอร์ AH จะต้องมีค่าเท่ากับ 4Ch
ตัวแปรรีจิสเตอร์ AL จะต้องเก็บค่าที่จะส่งกลับไปให้ระบบ ซึ่งปกติจะมีค่าเป็น 0
ตัวอย่างการใช้งาน
mov ah,4ch
int 21h

 

6. กฎการตั้งชื่อ 

   ข้อดีของการใช้แอสเซมเบลอร์นอกจากจะสะดวกในเรื่องของการตรวจสอบโปรแกรมแล้ว เรายังสามารถประกาศตัวแปรขึ้นมาเพื่อมาใช้งานได้ โดยไม่ต้องยุ่งเกี่ยวกับหน่วยความจำโดยตรง แต่ถึงกระนั้นเราก็จำเป็นจะต้องมีการตั้งชื่อของตัวแปร โดยชื่อของตัวแปรจะต้องเป็นไปตามกฎของแอสเซมเบลอร์ซึ่งโดยปกติจะมีหลักการดังนี้ 

1.             เริ่มต้นด้วยตัวอักษรตัวใหญ่หรือตัวเล็ก เครื่องหมาย underscore (_) , ?, $, @ ห้ามขึ้นต้นด้วยตัวเลข

2.             สามารถตั้งชื่อได้ยาวถึง 31 ตัวอักษร 

3.             ห้ามใช้เครื่องหมาย . ภายในชื่อ 

4.             ห้ามตั้งชื่อซ้ำกับคำสงวน (reserve name) และเครื่องหมายพิเศษ

นอกจากเราจะใช้กฎการตั้งชื่อกับตัวแปรแล้วยังสามารถใช้ได้กับลาเบล โพรซิเยอร์ และเซกเมนต์ด้วย 

 

  7. การกำหนดค่าคงที่  

   เราสามารถกำหนดค่าคงที่ที่ใช้บ่อยให้มีชื่อใดชื่อหนึ่ง โดยการใช้คำสั่งเทียม EQU โดยชื่อที่สร้างขึ้นมานั้นจะใช้แทนค่าคงที่ที่กำหนด และเมื่อมีการแปลโปรแกรม ตัวแอสเซมเบลอร์จะทำการแทนที่คำที่เราสร้างขึ้นมานั้นด้วยค่าคงที่ที่เรากำหนดจากคำสั่งเทียม EQU ก่อนแล้วจึงทำการแปลโปรแกรมต่อไป

รูปแบบ

 

constant_name EQU constant_value
ตัวอย่างการใช้งาน             COUNT EQU 25
                                     mov ax,COUNT
                                    ; จะเหมือนกับการใช้คำสั่ง
                                     mov ax,25

 

8. ตัวแปร

   ในการเขียนโปรแกรมทั่วไป จำเป็นจะต้องมีการประกาศตัวแปรขึ้นมาเพื่อใช้ในงานต่างๆ ในภาษาแอสเซมบลีก็เช่นกัน ก็จำเป็นจะต้องมีการประกาศตัวแปรขึ้นมา โดยการประกาศตัวแปรจะมีรูปแบบดังต่อไปนี้ 

8.1 ตัวแปรชนิดตัวเลข 

รูปแบบ

                                    Variable                type        value

                        แต่กรณีที่ไม่ต้องการกำหนดค่า ให้ใส่เครื่องหมาย ? ลงในส่วนที่เป็น value

                        โดยในชนิดของตัวแปรเราสามารถใช้คำสั่งเทียมต่อไปนี้กำหนด ดังนี้

                           DB          คือตัวแปรขนาด 1  ไบต์

                                    DW        คือตัวแปรขนาด 2  ไบต์

                                    DD         คือตัวแปรขนาด 4  ไบต์

                                    DQ         คือตัวแปรขนาด 8  ไบต์

                                    DT          คือตัวแปรขนาด 10 ไบต์

ตัวอย่างการใช้งาน

                                    DATA1 DB          15

                                    DATA2 DD         ?                               

8.2 ตัวแปรชนิดสตริง 

           ในการประกาศตัวแปรแบบข้างต้นนี้เวลาเราจะนำไปพิมพ์จะพิมพ์ได้ทีละตัวอักษร จึงไม่สะดวกเมื่อจะพิมพ์เป็นข้อความ ดังนั้นเราจึงมักใช้การประกาศแบบข้อความโดยส่วนของการใส่ค่าเราจะใส่เป็นข้อความลงไปเช่น 

DAT     DB     ‘HELLO WORLD$’

เมื่อจะพิมพ์ข้อความให้เราทำดังนี้

                                       mov ax,@DATA1

                                                    mov ds,ax

                                                    lea   dx,DAT

                                                    mov ah,09

                                                    int   21h

เราเรียกตัวแปรที่ประกาศแบบนี้ว่าตัวแปรชนิดสตริงแบบไบต์ ซึ่งในสตริงนั้นๆ จะประกอบไปด้วยแต่ละไบต์ของข้อมูล

นอกจากนี้เรายังสามารถสร้างสตริงแบบเวิร์ด หรือแบบอื่นๆ ได้ดังตัวอย่างต่อไปนี้ 

                                    DAT2    DW        540Fh, 3542h, 78D8h

                                    DAT3    DD         4562FD74h, 789E4892h

                                                             DD         254E78B6h,00000000h

            แต่สตริงพวกนี้ไม่ได้ใช้เก็บข้อความเหมือนกับสตริงแบบไบต์ เพียงแต่เป็นการนำเอาข้อมูลมาเรียงต่อกันเท่านั้น 

 

8.3 Array

   นอกจากนี้เราสามารถเรียกตัวแปรชนิดสตริง ว่าเป็นตัวแปรชนิดอาร์เรย์ชนิดหนึ่งก็ได้ เนื่องจากตัวแปรชนิดอาร์เรย์ก็คือการนำเอาข้อมูลที่มีขนาดเท่ากันมาเรียงต่อกันนั้นเอง

นอกจากการประกาศตัวแปรในแบบที่กล่าวมาแล้วนั้นเรายังสามารถประกาศอาร์เรย์ขึ้นมาโดยใช้คำสั่งเทียม dup ได้ดังนี้

รูปแบบ

                                   Variable                type        size dup( value )

                   โดยถ้าเราไม่ต้องการใส่ค่าให้กับตัวแปรแต่ละตัวให้ใส่เครื่องหมาย ? ในช่อง value

ตัวอย่างการใช้งาน

                                    DATA1 DB          10 dup(?)

                    ซึ่งตัวเลขหน้า dup คือจำนวนช่อง และ ? ค่าของแต่ละช่อง

 

9. LABEL

ลาเบลคือการมาร์คตำแหน่งสำหรับการกระโดดมาเพื่อสร้างจุดที่จะให้เครื่องมารัน โดยจะเป็นชื่อแล้วตามด้วยเครื่องหมาย :

รูปแบบ 

                                    [label:] Mnemonic [operand]

   สังเกตว่าเราไม่จำเป็นต้องระบุลาเบลให้กับคำสั่งทุกทำสั่ง เราจะระบุลาเบลเฉพาะคำสั่งที่เราต้องการใช้เป็นจุดสำหรับให้เครื่องมารันที่คำสั่งนั้นเท่านั้น

ตัวอย่างการใช้งาน 

                                    ELSE :                 mov ax,16h

หมายเหตุ ลาเบลจะไม่ถูกแปลไปเป็นภาษาเครื่องเนื่องจากจะมีการกำหนดตำแหน่งหน่วยความจำเป็นแบบสัมพัทธ์ซึ่งไม่จำเป็นต้องใช้ลาเบลในการกำหนดจุดกระโดด

 

10. โพรซีเยอร์ (PROCEDURE)

  โพรซีเยอร์คือโปรแกรมย่อย โดยมีประโยชน์เมื่อเราต้องเขียนโปรแกรมยาวๆ การแบ่งเป็นโปรแกรมย่อยจะทำให้เราไม่สับสน และทำให้เราเรียกใช้ได้ง่าย ทั้งยังสามารถย่อการเขียนโค๊ดให้สั้นลงได้ โดยรูปแบบการประกาศโพรซีเยอร์เราจะใช้คำสั่งเทียม proc และ endp ดังนี้

รูปแบบ 

                     Procedure_name  proc   [far/near]

                     Procedure_code

                                    Procedure_name endp

   โดย far หรือ near นี้จะขึ้นอยู่กับขนาดของโปรแกรมโดยถ้าโปรแกรมมีขนาดเล็กและโพรซิเยอร์นี้อยู่ภายในเซกเมนท์เดียวกันควรจะกำหนดเป็น near เพราะจะทำให้การทำงานเร็วกว่า แต่ถ้าเราเขียนโปรแกรมขนาดใหญ่แล้วโพรซิเยอร์ย่อยเหล่านี้อยู่คนละเซกเมนท์ก็จะต้องกำหนดให้เป็น far แต่อาจจะทำงานช้ากว่า ทั้งนี้ถ้าเราไม่ได้กำหนด ตัวแอสเซมเบลอร์จะกำหนดให้เราโดยอัตโนมัติ

ตัวอย่างการใช้งาน

                                    printstar                proc                        ; โปรแกรมพิมพ์ตัวอักษร *

                                                    mov        ah,02h   ; เรียกฟังก์ชันหมายเลข 2

                                                    mov        dl, ‘*’    ; ต้องการให้พิมพ์ *

                                                    int           21h         ; เรียก interrupt 21h

                                                   ret                           ; คำสั่งคืนค่าการทำงานไปยัง

                                                                                   ; โปรแกรมหลัก

                                    printstar                endp

หมายเหตุ ในการสั่งงานโพรซิเยอร์ย่อยเราจะใช้คำสั่ง call และโพรซิเยอร์ย่อยจะคืนค่าการทำงานกลับมาด้วยคำสั่ง ret

 

11. เซกเมนต์ (Segment) 

   ในการจัดหน่วยความจำของระบบไมโครโปรเซสเซอร์ของตระกูลอินเทล ได้จัดหน่วยความจำออกเป็น Segment โดยแต่ละเซกเมนต์จะประกอบด้วยออฟเซต ซึ่งแต่ละออฟเซตจะมีขนาด 1 ไบต์

ซึ่งในแต่ละเซกเมนต์มีขนาดได้ไม่เกิน 64 Kb

   สำหรับการเขียนโปรแกรมนั้นเราได้แบ่งเซกเมนต์ออกเป็นสามรูปแบบคือ 

1.             code segment คือเซกเมนต์ที่ทำหน้าที่เก็บตัวโปรแกรมของเราไว้

2.             data segment คือเซกเมนต์ที่ทำหน้าที่เก็บข้อมูลทั่วไป

3.             stack segment คือเซกเมนต์สำหรับการเก็บข้อมูลแบบ stack และข้อมูลแบบชั่วคราว

4.             extra segment เป็นเซกเมนต์พิเศษสำหรับใช้คู่กับ data segment ในการทำงานแบบสตริง

สำหรับการประกาศเซกเมนต์นั้นมี 2 แบบคือแบบเก่าและแบบอย่างง่าย

        การประกาศเซกเมนต์แบบเก่า 

เราจะใช้คำสั่งเทียม Segment และ ends ในการประกาศ ซึ่งมีรูปแบบดังนี้

รูปแบบ 

                                                    Segment_name   segment               [option]

                                                                    Segment_code

                                                    Segment_name   ends

โดย Option ของเซกเมนต์จะใช้ในการกำหนดรายละเอียดของเซกเมนต์ มีอยู่ 3 ชนิดได้แก่

1. Alignment Type เป็นการกำหนดแอดเดรสเริ่มต้นของเซกเมนต์ เพื่อวางข้อมูลโดยการกำหนดเป็นดังนี้

                                    Byte       ตำแหน่งเซกเมนต์เริ่มต้นที่ไบต์ต่อไป

                                    Word     ตำแหน่งเซกเมนต์เริ่มต้นที่เวิร์ดต่อไป

                                    Para        ตำแหน่งเซกเมนต์เริ่มต้นที่ paragraph ต่อไป (16Bytes)

                                    Page       ตำแหน่งเซกเมนต์เริ่มต้นที่หน้าต่อไป (256 Bytes)

2. Combine Type ใช้กำหนดเซกเมนต์เพื่อรวมเข้ากับเซกเมนต์อื่นที่มีชื่อเหมือนกันในขั้นตอนการ link ซึ่งได้แก่ Stack, Common Public และ AT expression

3. Class Type จะใช้เครื่องหมาย Apostrophe S (‘) กำกับในการใช้กลุ่มของเซกเมนต์ที่สัมพันธ์กัน เมื่อมีการ link เช่น ‘CODE’ เพื่อใช้ในการจัดลำดับก่อนหลังของเซกเมนต์ในหน่วยความจำ

ตัวอย่างการใช้งาน 

                                                   stseg       segment

                                                                   db           64 dup(?)

                                                   stseg       ends

                                   ;--------------------------------------------------------------

                                                   dtseg      segment

                                                   data1      db           52h

                                                   data2      db           29h

                                                   sum        db           ?

                                                   dtseg      ends

                                   ;-------------------------------------------------------------

                                                   cdseg      segment

                                                   main       proc far

                                                                   assume cs:cdseg,ds:dtseg,ss:stseg

                                                                   mov ax,dtseg

                                                                   mov ds,ax

                                                                   mov al,data1

                                                                   mov bl,data2

                                                                   add al,bl

                                                                   mov sum,al

                                                                   mov ah,4ch

                                                                   int 21h

                                                   main       endp

                                                   cdseg      end main

นอกจากนี้ยังมีคำสั่งเทียมที่ใช้ควบคู่กับการประกาศเซกเมนต์ข้อมูลซึ่งได้แก่ 

การกำหนดชนิดของเซกเมนต์ ด้วยคำสั่งเทียม ASSUME

     ในการประกาศเซกเมนต์นั้น เรายังไม่ได้บอกว่าเซกเมนต์ที่ประกาศขึ้นมานั้นเป็นเซกเมนต์ชนิดใด เราจึงจำเป็นต้องบอกว่าเซกเมนต์ที่เราประกาศขึ้นมานั้นเป็นเซกเมนต์ชนิดใดด้วยคำสั่งเทียม ASSUME ดังรูปแบบต่อไปนี้

                   รูปแบบ :

                                   ASSUME CS:code_segment [,DS:data_segment] [,SS:stack_segment]

                   ตัวอย่างเช่น :

                                   assume cs:cdseg, ds:dtseg, ss:stseg

    เป็นการกำหนดให้รีจิสเตอร์ CS ชี้ไปยังเซกเมนต์ cdseg เพื่อกำหนดว่าเป็น code segment ให้รีจิสเตอร์ DS ชี้ไปยังเซกเมนต์ dtseg เพื่อกำหนดว่าเป็น data segment และรีจิสเตอร์ SS ชี้ไปยังเซกเมนต์ stseg เพื่อกำหนดว่าเป็น stack segment

หมายเหตุ ที่จริงแล้วรีจิสเตอร์ที่กำหนดมานั้นไม่ได้ชี้ไปยังเซกเมนต์ที่กำหนดจริงๆ เป็นเพียงการบอกว่าเซกเมนต์ที่กำหนดนั้นเป็นเซกเมนต์ชนิดอะไรเท่านั้น

การกำหนดตำแหน่งเริ่มต้นในหน่วยความจำด้วยคำสั่ง ORG 

  คำสั่งเทียม ORG (origin) ใช้สำหรับกำหนดค่าต่ำแหน่งออฟเซตเริ่มต้น หรือกำหนดตำแหน่งเริ่มต้นของข้อมูลที่ตามมา โดยตัวเลขที่ตาม ORG จะเป็นเลขฐานสิบหรือฐานสิบหกก็ได้ ถ้าไม่มีตัวHตามหลังจะเป็นเลขฐานสิบ โดยทั่วไปแล้วมักใช้กำหนดตำแหน่งเริ่มต้นของโปรแกรมย่อยต่างๆ

 

การประกาศเซกเมนต์อย่างง่าย

   สำหรับแอสเซมเบลอร์รุ่นใหม่ๆ จะอนุญาตให้เราสามารถกำหนดเซกเมนต์อย่างง่ายได้ แต่การกำหนดแบบนี้ไม่สามารถใช้ในการเขียนโปรแกรมแล้วแปลออกมาเป็นไฟล์ .COM ได้ (ปกติจะแปลแล้วได้ .EXE ออกมา) ซึ่งเราจะใช้วิธีการกำหนดโมเดลในการใช้หน่วยความจำของโปรแกรมซึ่งมีดังต่อไปนี้

•    Tiny ส่วนที่เป็นข้อมูลและโปรแกรมจะอยู่ในเซกเมนต์เดียวกัน การกำหนดแบบนี้มักใช้ในโปรแกรมที่มีนามสกุลเป็น .COM การกำหนดแบบนี้ไม่สามารถใช้ในการกำหนดเซกเมนต์อย่างง่ายได้

   Small ใช้กับพื้นที่หน่วยความจำข้อมูลและโปรแกรมที่มีขนาดไม่เกิน 64 กิโลไบต์ โดยใช้หนึ่งเซกเมนต์สำหรับเก็บโปรแกรม และใช้หนึ่งเซกเมนต์สำหรับเก็บข้อมูล

   Medium ในโมเดลนี้ขนาดของข้อมูลและสแตกจะมีขนาดไม่เกินหนึ่งเซกเมนต์ แต่โปรแกรมมีขนาดใหญ่ไม่เกินหนึ่งเซกเมนต์

   Compact ในโมเดลนี้จะตรงข้ามกับโมเดล Medium คือโปรแกรมจะมีขนาดไม่เกินหนึ่งเซกเมนต์ ส่วนข้อมูลมีขนาดเกินหนึ่งเซกเมนต์ได้

   Large ในโมเดลนี้ทั้งโปรแกรมและข้อมูลมีขนาดเกินหนึ่งเซกเมนต์ได้ แต่อาร์เรย์ต้องมีขนาดไม่เกิน 64 กิโลไบต์

    ในการเขียนโปรแกรมที่ผ่านมาจะเห็นมาเราจะต้องกำหนดค่าให้กับรีจิสเตอร์เซกเมนต์สี่ตัวคือ CS, DS, SS, และ ES ถ้าหากโปรแกรมภาษาแอสเซมบลีที่เขียนขึ้นมีขนาดไม่เกินหนึ่งเซกเมนต์เราสามารถใช้คำสั่งเทียม “.CODE”, “.DATA” และ “.STACK” แทนการกำหนดค่าให้รีจิสเตอร์ CS, DS และ SS ได้ โดยคำสั่งเทียมเหล่านี้จะกำหนดเซกเมนต์ให้โปรแกรมของเราโดยอัตโนมัติ

ตารางเปรียบเทียบการเขียนโปรแกรมแบบเต็มรูปแบบและการกำหนดเซกเมนต์อย่างง่าย

; -------------------stack segment----------------------name1              segment                         db 64 dup(?)name1              ends;-------------------- data segment --------------------name2               segmentdata1                 dw 2345hdata2                 dw 98F4hresult                 dw ?name2               ends;-------------------- code segment --------------------name3               segmentmain                  proc          far                          assume cs:name3,ds:name2,ss:name1                          mov ax,name2                          mov ds,ax                          …main                  endpname3                ends                           end main

;--------------------------------------------------------------------                                .model  small                                .stack 64;--------------------------------------------------------------------                                .datadata1                       dw  2345hdata2                       dw  98F4hresult                       dw  ?;-------------------------------------------------------------------                              .codemain:                     mov  ax,@data                              mov  da,ax                              …                              end main

    

           มาถึงตรงนี้เราจะมาเรียนรู้ถึงการกำหนดเซกเมนต์อย่างง่ายซึ่งจะมีคำสั่งที่เกี่ยวข้องดังต่อไปนี้ 

                   คำสั่งกำหนดโมเดลของโปรแกรม ในการกำหนดเซกเมนต์อย่างง่ายเราจำเป็นต้องกำหนดโมเดลของโปรแกรมก่อนโดยใช้คำสั่งเทียม .model ซึ่งมีรูปแบบดังนี้

รูปแบบ :

                                   .model   memory_model

ตัวอย่างการใช้งาน :  

                                   .model small

คำสั่งกำหนดขนาดของสแตกเซกเมนต์ เราสามารถกำหนดขนาดของสแตกเซกเมนต์ด้วยคำสั่งเทียม .stack ซึ่งมีรูปแบบดังนี้

รูปแบบ :

                                   .stack     stack_size

ตัวอย่างการใช้งาน :

                                   .stack 64

คำสั่งกำหนดเซกเมนต์ข้อมูล เราสามารถกำหนดตำแหน่งเริ่มต้นของเซกเมนต์ข้อมูลเพื่อประกาศตัวแปร ด้วยคำสั่งเทียม .data ซึ่งมีรูปแบบดังนี้

รูปแบบ :

                                   .data

ตัวอย่างการใช้งาน :

                                   .data

                   data1      db           30h

                   data2      db           40h

                   result      db           ?

                   คำสั่งกำหนดเซกเมนต์โปรแกรม ในการเขียนโปรแกรมเราจำเป็นจะต้องบอกตำแหน่งเริ่มต้นของเซกเมนต์ที่ใช้เก็บตัวโปรแกรม ซึ่งเราจะกำหนดด้วยคำสั่ง .code ซึ่งมีรูปแบบดังนี้

รูปแบบ :

                                   .code

ตัวอย่างการใช้งาน :

                                   .code

                   main:     mov ax,@data

                                   mov ds,ax

                                   mov al,data1

                                   add al,data2

                                   mov result,ax

                                   mov ax,4c00h

                                   int 21h

                                   end         main

 

การใช้งานเซกเมนต์ข้อมูล 

           โดยปกติแล้วเมื่อใดก็ตามที่เรามีการใช้ตัวแปรหรือข้อมูล โปรแกรมจะไปค้นหาข้อมูลเหล่านั้นเซกเมนต์ข้อมูล ซึ่งจะถูกกำหนดด้วยรีจิสเตอร์ DS แต่ในเซกเมนต์ที่เราประกาศขึ้นนั้นยังไม่ได้มีการกำหนดค่าให้กับรีจิสเตอร์ DS อย่างแท้จริง ดังนั้นเราจะต้องเขียนโปรแกรมกำหนดค่าให้กับตัวแปรรีจิสเตอร์ DS เอง แต่เนื่องจากตัวแปรรีจิสเตอร์ประเภทเซกเมนต์ เราไม่สามารถกำหนดค่าให้กับตัวแปรเหล่านั้นได้โดยตรง ดังนั้นเราจึงนำตำแหน่งของเซกเมนต์ข้อมูลไปเก็บไว้ในตัวแปรรีจิสเตอร์ AX ก่อน แล้วจึงค่อยนำมาเก็บไว้ในตัวแปรรีจิสเตอร์ DS

             ซึ่งถ้าเป็นการประกาศเซกเมนต์แบบเก่า เราสามารถเขียนโปรแกรมได้ดังนี้

                                   mov       ax,data_segment_name

                                   mov       ds,ax

                   แต่ถ้าเป็นการประกาศเซกเมนต์แบบใหม่ เราสามารถเขียนโปรแกรมได้ดังนี้

                                   mov       ax,@data

                                   mov       ds,ax

 

---