Amiga Machine Language (Chapter 3)

A amigaspirit.hu - pegasos.hu Wiki wikiből

     Chapter 3.
     ---------
     3.Working With Assemblers.
     -------------------------
       The instructions that you've learned so far are incomprehensible
       to the MC68000 processor.The letters MOVE mean absolutely nothing
       to the processor-it needs the instructions in binary form.Every
       instruction must be coded in a word-which normally takes a lot of
       work.
       An assembler does this work for you.An assembler is a program that
       translates the instructions from text into the coresponding binary
       instructions.The text that is translated is called Mnemonic or
       Memcode.Its a lot easier working with text instructions-or does
       $4280 mean more to you than CLR.L D0?
       This chapter is about working with assemblers.We'll describe the
       following three:
     ASSEM;
       This is the assembler from the Amiga's development package.This
       assembler is quite powerful,but it is clearly inferior to its two
       fellow compilers in some areas.
     AssemPro;
       This is the Abacus assembler.It has a debugger in addition to the
       assembler.This lets you test and correct programs.In our opinion,
       it is the best one to use for writing and testing practice
       programs.For this reason,we wrote the programs in this book with
       this assembler.
     KUMA-SEKA;
       This is a popular assembler which also has a debugger.
       All assemblers perform a similar task-they translate memcode,so
       that you can write a runable program to disk.To test the program
       directly,you need a debugger which is something Assem doesn't
       have.

     3.1.The Development Assembler.
     -----------------------------
       This assembler is a plain disk assembler.That means that it can
       only assemble text files that are on disk and write the result
       back to disk.You can't make direct input or test run the new
       program.
       You can call ASSEM from the CLI by typing ASSEM followed by
       parameters that specify what you wish the assembler to do.
       In the simplest case,you call it like this:
            ASSEM Source -O Destination
       Source is the filename of the file containing the program text.
       Destination is the name of the file that contains the results of
       assembling after the process is over.The "-O"means that the
       following name is used for the object file.
       There are several other parameters that can be passed.These are
       written with their option(ie-O),so that the assembler knows what
       to do with the file that you've told it to use.The following
       possible options must be followed by a filename.
           -O    Object file
           -V    Error messages that occur during assembling are written
                 to a file.If this isn't given,the error messages appear
                 in the CLI window.
           -L    The output of the assembled program lines are sent to
                 this file.You can also use"PRT:"to have it printed.
           -H    This file is read in at the beginning of the assembled
                 file and assembled along with it.
           -E    A file is created that contains lines which have EQU
                 instructions.
           -C    This option isn't followed by a filename but by another
                 option.You can also use OPT to do this.The following
                 options are available:
                 
                 OPT S  A symbol table is created which contains all the
                        labels and their values.
                 OPT X  A cross reference list is created(where labels
                        are used).
                 OPT W  A number must follow this option.It sets the
                        ammount of workspace to be reserved.
       The assembler creates an object file.This is not runnable.To make
       it runnable,you need to call the linker,ALINK.This program can
       link several assembled or compiled object files together to make a
       runnable program.In the simplest case,you enter the following
       instruction in the CLI:
            ALINK Source TO Destination
       Source is the object file produced by the assembler.Destination is
       the name of the program.It can be started directly.
     3.2.AssemPro.
     ------------
       Abacus's AssemPro is a package which combines editor,assembler and
       debugger in an easy to use package.
       The AssemPro Program is divided into several windows-one for the
       assembler,the editor,the debugger and several help functions.
       Producing a program is very easy:
         
         1)  Write the program with the editor and then store it to disk.
         2)  Start the assembler,so that the program is translated.
         3)  If desired,start the debugger,load the program and test it.
       Within the debugger you can work through parts of the program or
       even through single commands.As after each one of these steps the
       debugger shows you the state of the registers and flags in the
       status register,you can easily try the programs presented in this
       book.
       You need to load AssemPro only once when working with machine
       language programs.Thus you don't need to save back and to between
       editor,assembler,linker and debugger.
       AssemPro has an especially interesting function:the reassembler.
       With this debugger function you are able to convert runnable
       programs into the source text of the program.Once you have made
       the source text,you can edit the program using the editor and
       assemble it again.AssemPro is equipped with functions other
       assemblers miss.There are however,some differences you should know
       about.As many programs you see were written for the K-SEKA,be
       aware of one difference:the EVEN command.AssemPro uses the ALIGN
       instruction.
       Note,that when entering and assembling one of the programs in
       AssemPro you must make sure that you place an END directive at the
       end of the source text.
       The following is an introduction into working with AssemPro and
       the programs in this book.
       
       Start AssemPro normally,next click on the editor window and start
       typing in your program.If the program is on disk already,load it
       by selecting the appropriate menu or by using the key combination
       right <AMIGA> key and <o>.To do this you only need to ckick on the
       filename in the displayed requester and click on the OK gadget.
       Once you have typed in or loaded the program into the editor,you
       can assemble it.It is best to save your source before assembling.
       You assemble your program by clicking on the assembler window
       displayed above the editor window and pressing <AMIGA> and <a>.You
       can then choose how to locate your program in the memory.Remember
       that data used by the co-processors must be located in CHIP RAM.
       By clicking OK you start the assembler process.If you additionally
       select "breakable",you can cancel the process by pressing both
       shift keys.If any error occurs during assembling,AssemPro uses a
       window to tell you this.Use this window to correct the error and
       continue with "Save and try again".
       Now the runnable program is located in the Amiga's memory.Use the
       menu item "Save as"to save it on disk.If you want to store it on
       RAM disk,click the given filename and enter RAM: in front of this
       name.In addition you can click on the menu item "ICON"and choose
       if you only want the program itself on disk but the icon too.Use
       this icon to start the program at a later time from Workbench.
       To test-run the program,you move the debugger window to the 
       foreground of the screen(for instance by clicking on the back
       gadget).Use "Load"in the debugger menu or <AMIGA> <o> to call the
       select file window,where you select the saved program.The program
       is then loaded into the memory and its shown disassembled.
       The highlighted line(orange)represents the current state of the 
       program counter.This is the line where the processor reads its
       next instruction,provided you tell the processor so.There are
       three ways to do so.
       The first one is to start the program with "Start".This
       alternative does not enable you to stop the program if anything
       goes wrong.
       The second possibility,"Start breakable"is better in this respect.
       After the program starts,it continuously displays the registers
       contents on the left side of the window.In addition to that you
       can cancel the process by pressing <ESC>.Note that this only works
       if your program doesn't use the <ESC>key itself.
       The third possibility enables you to only partly run your program.
       You can do this by stepping through the program or by placing
       breakpoints throughout the program.You place these by clicking on 
       the desired address and then pressing <AMIGA> ."BREAKPOINT"is
       displayed where the command was displayed before.If you start the
       program now,it stops whenever it comes across any breakpoints.
       You can start a small part of the program by moving the mouse
       pointer to the orange line,clicking the left button and holding it
       down while you drag the mouse pointer downward.If you release the
       button,the processor works through this part of the program,
       stopping at the line,where you positioned the mouse pointer.This
       is a very useful method to step by step test a program.
       AssemPro as another helpful window:the Table.This window lists the
       valid address methods for instructions and the parameters of Amiga
       functions.This is extremely helpful whenever you are not sure
       about one of the instructions.
     3.3.The K-SEKA Assembler.
     ------------------------
       The SEKA assembler,from KUMA,has a simple text editor and a
       debugger in addition to the assembler.This program is controlled
       by simple instructions and it is easy to use.It is also multi-
       functional and quick,so it is great for small test and example
       programs.You can use it to write bigger programs once you've got
       use to the editor.Now lets look at the editor.
       To load a program as source code(text)into the editor,enter"r"
       (read).The program asks you for the name of the file with the
       "<FILENAME>"prompt.You then enter the name of the text file.If you
       created the file with SEKA,the file is stored on disk with".s" on
       the end of its name.You don't need to include the".s"when you load
       the file.Thats taken care of automatically.("s"stands for source.)
       You can store programs you've just written or modified by using
       the"w"instruction.The program asks you for the name.If you enter
       "Test",the file is written to the disk with"Test.s"as its name.
       This is a normal text file in ASCII format.
       There are two ways to enter or change a programs:using the line
       editor or the screen editor.You can enter the second by hitting
       the <ESC>key.The upper screen section is then reserved for the
       editor.You can move with the cursor keys and change the text
       easily.The lines that you enter are inserted into the existing
       text and automatically numbered.By hitting the <ESC>key again,you
       leave the screen editor. 
       There's really not much to say about this editor.It's really just
       for simple insertions and changes.Other functions are called in
       normal instruction mode,the mode in which">"is the input prompt.
       The following instructions are available to you for text editing
       (<n>stands for a number.The meaning of the instructions is in
       parenthesis.)
       Instruction        Function
       ----------------------------------------------------------------
       t(Target)          Puts the cursor on the highest line in the
                          text.
       t<n>               Puts the cursor on line n.
       b(Bottom)          Puts the cursor on the last line in the text.
       u(Up)              Go up one line.
       u<n>               Go up n lines.
       d(Down)            Go down one line.
       d<n>               Go down n lines.
       z(Zap)             Deletes the current line.
       z<n>               Deletes n lines starting at the cursor line.
       e(Edit)            Lets you edit the current line(and only that
                          line).
       e<n>               Edit from line n.
       ftext(Find)        Searches for the text entered starting at the
                          current line.The case of a letter makes a
                          difference,so make sure to enter it correctly.
                          Blanks that appear after the f are looked for
                          as well!
       f                  Continues searching beyond the text that was
                          previously given.
       i(Insert)          Starts the line editor.Now you can enter a
                          program line by line.However,you can't use the
                          cursor to move into another line.Line numbers
                          are generated automatically.The lines that
                          follow are moved down,not erased.
       ks(Kill Source)    The source text is deleted if you answer"y"
                          when the program asks if you are sure.Otherwise
                          nothing happens.
       o(Old)             Cancels the "ks"function and saves the old text
       p(Print)           Prints the current line.
       p<n>               Prints n lines starting at cursor line.
       Those are the K-SEKA's editor functions.In combination with the
       screen editor,they allow for simple text editing.You can,for
       example,delete the current line(and other lines)while working in
       the screen editor by hitting <ESC> to get into instruction mode
       and then entering"z"(or "z<n>").
       If you'd like to edit all lines that contain "trap",for example,
       you can do the following:
          -Jump to the beginning of the text using "t"
          -Search for a "trap"instruction by entering "ftrap" in the
           first line.
          -Press <ESC> and edit the line.
          -Press <ESC> again to get into instruction mode.
          -Search using "f",<ESC>,etc.until you get to the end of the
           text.
       This sounds very clumsy,but in practise it works quite well and
       goes quickly.Experiment with the editor bit,so you can get use to
       it.
       Now here are the instructions for working with disks:
       Instruction             Function
       -----------------------------------------------------------------
       v(View files)           Look at the disk's directory.You can also
                               include the disk drive or subdirectory
                               that interests you.For example,"vc"causes
                               the "c"subdirectory to be listed and makes
                               it the current directory.
       kf(Kill file)           The program asks for the name of the file.
                               The file is deleted(and you aren't asked
                               if your sure either-so be careful).
       r(Read)                 After inputting this instruction,you'll be
                               asked which file to load(FILENAME>).The
                               file that you specify is then loaded.If
                               only "r"is entered,a text file is loaded
                               in the editor.
       ri(Read Image)          Loads a file into memory.After you've
                               entered the filename,SEKA asks for the
                               address the file should begin at in memory
                               (BEGIN>)and the highest address that
                               should be used for the file(END>).
       rx(Read from Auxillary) This works just like the "ri"function
                               except that it reads from the serial port
                               instead of from disk(You don't need a file
                               name).
       rl(Read Link file)      This instruction reads in a SEKA created 
                               link file.First you'll be asked if you are
                               sure,because the text buffer is erased
                               when the link file is loaded.
       w(Write)                After entering this instruction,you'll be 
                               asked for the name of the file the text
                               should be written to.A".s"is automatically
                               appended to the name,so that it can be 
                               recognized as a SEKA file.
       wi(Write Image)         Stores a block of memory to disk after the
                               name,beginning and end are entered.
       wx(Write to Auxillary)  This is similar to"wi";the only difference
                               is that the output is to the serial inter-
                               face.
       wl(Write Link file)     Asks for the name and then stores a link 
                               file that was assembled with the"I"option
                               to disk.If this isn't available,the
                               message "* * Link option not specified"
                               appears.
       Once you've typed in or loaded a program,you can call the
       assembler and have the program translated.Just enter"a"to do so.
       You'll then be asked which options you want to use.If you enter a
       <RETURN>,the program is assembled normally-ie the results of
       translating a program in memory is stored in memory.Then the
       program can be executed straight away.
       You can enter one or more of the following options,however:
         v     The output of the results goes to the screen.
         p     or
         e     goes to the printer with a title line.
         h     The output stops after every page and waits for a key
               stroke.This is useful for controlling output to the screen
               or for putting new sheets of paper in the printer.
         o     This option allows the assembler to optimize all possible
               branch instructions.This allows the program code to be
               shorter than it would otherwise be.Several messages appear
               but you can ignore them.
         l     This option causes linkable code to be produced.You can
               save it with the"wl"instruction and read it with the "rl"
               instruction.
       A symbol table is included at the end of the listing if desired.
       The table contains all labels and their values.It also contains
       macro names.A macro allows several instructions to be combined in
       to a single instruction.
       For example,suppose you wrote a routinethat outputs the text that 
       register A0 points to.Every time you need to use the routine,you
       must type:
           lea  text,a0      ;pointer to text in A0
           bsr  pline        ;output text
       You can simplify this by defining a macro for this function.To do
       this,put the following at the beginning of the program:
           print:macro     ;Macro with the name "Print"
            lea  ?1,a0     ;Parameter in A0
            bsr  pmsg      ;Output text
           endm            ;End of macro
       Now,you can simply write the following in your program:
           print text       ;Output text
       This line is replaced using the macro during assembly.The
       parameter "text"is inserted where "?1"appears in the macro.You can
       have several parameters in a macro.You give them names like "?2",
       "?3",etc...
       You can also decide whether you'd like to see the macros in the
       output listing of the assembler.This is one of the pseudo-ops that
       are available in the assembler.The SEKA assembler has the
       following pseudo-ops:
         dc      Defines one or more data items that should appear in
                 this location in the program.The word length can be
                 specified with .B,.W,or .L-and if this is left off, .B
                 is used.Text can be entered in question marks or
                 apostrophes.For example:dc.b "Hello",10,13,0
         blk     Reserves a number of bytes,words or long words,depending
                 on whether .B,.W,or .L is chosen.The first parameter
                 specifies the number of words to be reserved.The second
                 (which is optional)is used to fill the memory area.For
                 example:blk.w 10,0
         org     The parameter that follows the org instruction is the
                 address from which the (absolute) program should be
                 assembled.For example: org $40000
         code    Causes the program to be assembled in relative mode,the
                 mode in which a program is assembled starting at address
                 0.The Amiga takes care of the new addressing after the
                 program is loaded.
         data    This means that from here on only data appear.This can
                 be left out.
         even    Makes the current address even by sometimes inserting a
                 fill byte.
         odd     The opposite of even-it makes the address odd.
         end     Assembling ends here.
         equ or  Used for establishing the value of a label
         =       For example: Value=123 or Value:equ 123
         list    Turns the output on again(after nlist).You can use the
                 following parameters to influence the output:
                   c    Macro calls
                   d    Macro definitions
                   e    Macro expansion of the program
                   x    Code expansions
                 For example: list e
         nlist   Turns off output.You can use the same parameters here as
                 with "list".
         page    Causes the printer to execute a page feed,so that you'll
                 start a new page.
         if      The following parameter decides whether you should
                 continue assembling.If it is zero,you won't continue
                 assembling.
         else    If the "if"parameter is zero,you'll begin assembling
                 here.
         endif   End of conditional assembling.
         macro   Start of a macro definition.
         endm    End of macro definition.
         ?n      The text in the macro that is replaced by the nth
                 parameter in the calling line.
         ?0      Generates a new three digit number for each macro call-
                 this is very useful for local labels.
                 For example: x?0:bsr pmsg
         illegal Produces an illegal machine language instruction.
         globl   Defines the following label as globel when the "I"option
                 of the assembler is chosen.
       Once you've assembled your program,the program code is in memory.
       Using the "h"instruction,you can find out how large the program is
       and where it is located in memory.The beginning and end address is
       given in hex and the length in decimal(according to the last
       executed operations):
          Work   The memory area defined in the beginning
          Src    Text in memory
          RelC   Relocation table of the program
          RelD   Relocation table of the memory area
          Code   Program code produced
          Data   The program's memory area
       You'll find program in memory at the location given by Code.It's a
       pain to have to enter this address whenever you want to start the
       program.It make's good sense to mark the beginning of the program
       with a label(for example,"run:").You can use the "g"instruction to
       run the program as follows:
          g run
       The"g"(GO)instruction is one of SEKA's debugger instrucions.Heres
       an overview:
        x    Output all registers.
        xr   Output and change of registers(ie xd0)
        gn   Jump to address n.You`ll be asked for break points,addresses
             at which the program should be terminate.
        jn   This is similar to the one above-a JSR is used to jump into
             the program.The program must end with a RTS instruction.
        qn   Output the memory starting at address n.You can also specify
             the word length.For example: q.w $10000
        nn   Disassembled output starting at address n.
        an   Direct assembling starting at address n.Direct program
             instructions are entered.
        nn   Modify the contents of memory starting at address n.Here too
             the word length can be given.You can terminate input with
             the <ESC> key.
        sn   Executes the program instruction that the PC points to.After
             you enter this instruction,n program steps are executed.
        f    Fill a memory area.You can choose the word width.All the
             needed parameters are asked for individually.
        c    Copies one memory area to another.All the needed parameters
             are asked for individually.
        ?    Outputs the value of an expression or a label.
             For example: ?run+$1000-256
        a    Sets an instruction sequence that is passed to the program
             when it starts as if it were started from CLI with this
             sequence.
        !    Leaves the SEKA assembler after being asked if your sure.
       You saw some of the calculations like SEKA can make in the "?"
       example.You can also use them in programming.The folowing
       operations work in SEKA:
          +  Addition
          -  Subtraction
          *  Multiplication
          /  Division
          &  Logic AND
          !  Logic OR
          ~  EXclusive OR (XOR) 
       These operations can also be combined.You can choose the counting
       system.A "$"stands for hexadecimal,"@"for octal,and "%"for binary.
       If these symbols aren`t used,the number is interpreted as a
       decimal number.
       Lets go back to the debugger.As mentioned,after entering "g
       address",you`ll be asked for break points.You can enter up to 16
       addresses at which the program halts.If you don`t enter break
       points,but instead hit <RETURN>,the program must end with an
       ILLEGAL instruction.If it ends instead with a RTS,the next return
       address from the stack is retrieved and jumped to.This is usually
       address 4 which causes SEKA to come back with "**Illegal
       Instruction at $000004",but theres no guarantee that it will.Your
       computor can end up so confused that it can`t function.
       The SEKA program puts an ILLEGAL instruction in the place
       specified as break points after saving the contents of these
       locations.If the processor hits an illegal instruction,it jumps
       back to the debugger by using the illegal instruction vector that
       SEKA set up earlier.Then SEKA repairs the modified memory
       locations and then displays the status line.Here you can find out
       where the program terminated.
       Using break points is a good technique for finding errors in the
       program.You can,for example,put a break point in front of a
       routine that you`re not sure about and start the program.When the
       program aborts at this spot,you can go through the routine step by
       step using the "s"option.Then you can watch what happens to the
       status line after each instruction and find the mistake.
       Program errors are called bugs.That`s why the program that finds
       them is called a debugger.
Személyes eszközök