## The Assembler Description

### ... General Assembler Directives

####

       An  ASxxxx  directive  is placed in the operator field of the
    source line.  Only one directive is  allowed  per  source  line.
    Each  directive  may  have  a blank operand field or one or more
    operands.  Legal operands differ with each directive.

####

- .module Directive
- .title Directive
- .sbttl Directive
- .page Directive
- .error Directive
- .byte and .db Directives
- .word and .dw Directives
- .3byte Directive
- .4byte and .quad Directives
- .blkb, .blkw, .ds, .blk3, and .blk4 Directives
- .ascii Directive
- .ascis Directive
- .asciz Directive
- .assume Directive
- .radix Directive
- .even Directive
- .odd Directive
- .area Directive
- .org Directive
- .globl Directive
- .if, .else, and .endif Directives
- .include Directive
- .setdp Directive
- .16bit, .24bit, and .32bit Directives
- Return to the Assembler Index

####

    .module Directive

    Format:

            .module string

       The .module directive causes the string to be included in the
    assemblers output file as an identifier for this particular  ob-
    ject  module.   The  string  may  be  from 1 to 79 characters in
    length.  Only one identifier is allowed  per  assembled  module.
    The  main use of this directive is to allow the linker to report
    a modules' use of undefined symbols.  At link time all undefined
    symbols  are  reported  and  the  modules  referencing  them are
    listed.

##### => Section Index

####

    .title Directive

    Format:

            .title  string

       The .title directive provides a character string to be placed
    on the second line of each page during listing.

##### => Section Index

####

    .sbttl Directive

    Format:

            .sbttl  string

       The .sbttl directive provides a character string to be placed
    on the third line of each page during listing.

##### => Section Index

####

    .page Directive

    Format:

            .page

       The .page directive causes a page ejection with a new heading
    to be printed.  The new page occurs after the next line  of  the
    source  program is processed, this allows an immediately follow-
    ing .sbttl directive to appear  on  the  new  page.   The  .page
    source  line will not appear in the file listing.  Paging may be
    disabled by invoking the -p directive.

##### => Section Index

####

    .error Directive

    Format:

            .error exp

    where:  exp     represents   an  absolute  expression.   If  the
                    evaluation of the expression results  in  a  non
                    zero value then an 'e' error is reported and the
                    text line is listed in the generated error.

       The  .error  directive  is  useful to report configuration or
    value errors during the assembly process.  (The .error directive
    is  identical in function to the .assume directive, just perhaps
    more descriptive.)

##### => Section Index

####

    .byte and .db Directives

    Format:

            .byte   exp             ;Stores the binary value
            .db     exp             ;of the expression in the
                                    ;next byte.

            .byte   exp1,exp2,expn  ;Stores the binary values
            .db     exp1,exp2,expn  ;of the list of expressions
                                    ;in successive bytes.

    where:  exp,    represent expressions that will be
            exp1,   truncated to 8-bits of data.
            .       Each expression will be calculated
            .       as a 16-bit word expression,
            .       the high-order byte will be truncated.
            .       Multiple expressions must be
            expn    separated by commas.

       The  .byte  or .db directives are used to generate successive
    bytes of binary data in the object module.

##### => Section Index

####

    .word and .dw Directives

    Format:

            .word   exp             ;Stores the binary value
            .dw     exp             ;of the expression in
                                    ;the next word.

            .word   exp1,exp2,expn  ;Stores the binary values
            .dw     exp1,exp2,expn  ;of the list of expressions
                                    ;in successive words.

    where:  exp,    represent expressions that will occupy two
            exp1,   bytes of data. Each expression will be
            .       calculated as a 16-bit word expression.
            .       Multiple expressions must be
            expn    separated by commas.

       The  .word  or .dw directives are used to generate successive
    words of binary data in the object module.

##### => Section Index

####

    .3byte Directive

    Format:

            .3byte  exp             ;Stores the binary value
                                    ;of the expression in
                                    ;the next triple (3 bytes).

            .3byte  exp1,exp2,expn  ;Stores the binary values
                                    ;of the list of expressions
                                    ;in successive triples
                                    ;(3 bytes).

    where:  exp,    represent expressions that will occupy three
            exp1,   bytes of data. Each expression will be
            .       calculated as a 24-bit word expression.
            .       Multiple expressions must be
            expn    separated by commas.

       The  .3byte  directive is used to generate successive triples
    of binary data in the object module.  (This  directive  is  only
    available in assemblers supporting 24-bit addressing.)

##### => Section Index

####

    .4byte and .quad Directives

    Format:

            .4byte  exp             ;Stores the binary value
            .quad   exp             ;of the expression in
                                    ;the next quad (4 bytes).

            .4byte  exp1,exp2,expn  ;Stores the binary values
            .quad   exp1,exp2,expn  ;of the list of expressions
                                    ;in successive quads
                                    ;(4 bytes).

    where:  exp,    represent expressions that will occupy three
            exp1,   bytes of data. Each expression will be
            .       calculated as a 32-bit word expression.
            .       Multiple expressions must be
            expn    separated by commas.

       The  .4byte or .quad directive is used to generate successive
    quads of binary data in the object module.  (This  directive  is
    only available in assemblers supporting 32-bit addressing.)

##### => Section Index

####

    .blkb, .blkw, .ds, .3byte, and .4byte Directives

    Format:

            .blkb   N       ;reserve N bytes of space
            .blkw   N       ;reserve N words of space
            .ds     N       ;reserve N bytes of space
            .blk3   N       ;reserve N triples of space
            .blk4   N       ;reserve N quads of space

       The  .blkb  and .ds directives reserve byte blocks in the ob-
    ject module;  the .blkw directive  reserves  word  blocks;   the
    .blk3  reserves  3 byte blocks(available in assembles supporting
    24-bit addressing);  the .blk4 reserves 4 byte blocks (available
    in assemblers supporting 32-bit addressing).

##### => Section Index

####

    .ascii Directive

    Format:

            .ascii  /string/

    where:  string  is a string of printable ascii characters.

            /  /    represent   the  delimiting  characters.   These
                    delimiters   may   be   any   paired    printing
                    characters,  as  long  as the characters are not
                    contained within  the  string  itself.   If  the
                    delimiting  characters  do not match, the .ascii
                    directive will give the (q) error.

    The  .ascii  directive  places  one binary byte of data for each
    character in the string into the object module.

##### => Section Index

####

    .ascis Directive

    Format:

            .ascis  /string/

    where:  string  is a string of printable ascii characters.

            /  /    represent   the  delimiting  characters.   These
                    delimiters   may   be   any   paired    printing
                    characters,  as  long  as the characters are not
                    contained within  the  string  itself.   If  the
                    delimiting  characters  do not match, the .ascis
                    directive will give the (q) error.

    The  .ascis  directive  places  one binary byte of data for each
    character in the  string  into  the  object  module.   The  last
    character in the string will have the high order bit set.

##### => Section Index

####

    .asciz Directive

    Format:

            .asciz  /string/

    where:  string  is a string of printable ascii characters.

            /  /    represent   the  delimiting  characters.   These
                    delimiters   may   be   any   paired    printing
                    characters,  as  long  as the characters are not
                    contained within  the  string  itself.   If  the
                    delimiting  characters  do not match, the .asciz
                    directive will give the (q) error.

    The  .asciz  directive  places  one binary byte of data for each
    character in the string into the object module.   Following  all
    the  character  data  a  zero  byte is inserted to terminate the
    character string.

##### => Section Index

####

    .assume Directive

    Format:

            .assume exp

    where:  exp     represents   an  absolute  expression.   If  the
                    evaluation of the expression results  in  a  non
                    zero value then an 'e' error is reported and the
                    text line is listed in the generated error.

       The  .assume  directive  is useful to check assumptions about
    assembler values.  (The .assume directive is identical in  func-
    tion to the .error directive, just perhaps more descriptive.)

##### => Section Index

####

    .radix Directive

    Format:

            .radix  character

    where:  character  represents  a single character specifying the
                    default radix to be used for succeeding numbers.
                    The character may be any one of the following:

                    B,b     Binary

                    O,o     Octal
                    Q,q

                    D,d     Decimal
                    'blank'

                    H,h     Hexidecimal
                    X,x

##### => Section Index

####

    .even Directive

    Format:

            .even

       The .even directive ensures that the current location counter
    contains an even boundary value by adding 1 if the current loca-
    tion is odd.

##### => Section Index

####

    .odd Directive

    Format:

            .odd

       The  .odd directive ensures that the current location counter
    contains an odd boundary value by adding one if the current  lo-
    cation is even.

##### => Section Index

####

    .area Directive

    Format:

            .area   name    [(options)]

    where:  name    represents the symbolic name of the program sec-
                    tion.   This  name  may  be  the  same  as   any
                    user-defined  symbol  as  the area names are in-
                    dependent of all symbols and labels.

            options specify the type of program or data area:
                    ABS     absolute (automatically invokes OVR)
                    REL     relocatable
                    OVR     overlay
                    CON     concatenate
                    PAG     paged area

       The .area directive provides a means of defining and separat-
    ing multiple programming and data sections.   The  name  is  the
    area  label used by the assembler and the linker to collect code
    from various separately assembled modules into one section.  The
    name may be from 1 to 79 characters in length.

       The options are specified within parenthesis and separated by
    commas as shown in the following example:

            .area  TEST  (REL,CON)  ;This section is relocatable
                                    ;and concatenated with other
                                    ;sections of this program area.

            .area  DATA  (REL,OVR)  ;This section is relocatable
                                    ;and overlays other sections
                                    ;of this program area.

            .area  SYS   (ABS,OVR)  ;(CON not allowed with ABS)
                                    ;This section is defined as
                                    ;absolute. Absolute sections
                                    ;are always overlayed with
                                    ;other sections of this program
                                    ;area.

            .area  PAGE  (PAG)      ;This is a paged section. The
                                    ;section must be on a 256 byte
                                    ;boundary and its length is
                                    ;checked by the linker to be
                                    ;no larger than 256 bytes.
                                    ;This is useful for direct page
                                    ;areas.

       The  default  area type is REL|CON;  i.e.  a relocatable sec-
    tion which is concatenated with other sections of code with  the
    same area name.  The ABS option indicates an absolute area.  The
    OVR and CON options indicate if program  sections  of  the  same
    name  will overlay each other (start at the same location) or be
    concatenated with each other (appended to each other).

       Multiple  invocations  of  the  .area directive with the same
    name must specify the same options or leave  the  options  field
    blank,  this  defaults  to  the previously specified options for
    this program area.
    The   ASxxxx   assemblers   automatically  provide  two  program
    sections:

            '.  .ABS.'      This dumby section contains all absolute
                            symbols and their values.

            '_CODE'         This  is  the default program/data area.
                            This program area is of type (REL,CON).

    The  ASxxxx  assemblers  also automatically generate two symbols
    for each program area:

            's_'      This is the starting address of the pro-
                            gram area.

            'l_'      This is the length of the program area.

##### => Section Index

####

    .org Directive

    Format:

            .org    exp

    where:  exp     is  an absolute expression that becomes the cur-
                    rent location counter.

    The  .org directive is valid only in an absolute program section
    and will give a (q) error if used in a relocatable program area.
    The  .org  directive specifies that the current location counter
    is to become the specified absolute value.

##### => Section Index

####

    .globl Directive

    Format:

            .globl  sym1,sym2,...,symn

    where:  sym1,           represent legal symbolic names. When
            sym2,...        When multiple symbols are specified,
            symn            they are separated by commas.

       A  .globl directive may also have a label field and/or a com-
    ment field.

       The  .globl directive is provided to define (and thus provide
    linkage to) symbols not  otherwise  defined  as  global  symbols
    within  a  module.   In  defining  global  symbols the directive
    .globl J is similar to:

          J == expression or J::

       Because  object  modules  are linked by global symbols, these
    symbols are vital to a program.  All internal symbols  appearing
    within  a  given program must be defined at the end of pass 1 or
    they will be considered undefined.  The assembly directive  (-g)
    can  be  be  invoked to make all undefined symbols global at the
    end of pass 1.

##### => Section Index

####

    .if, .else, and .endif Directives

    Format:

            .if     expr
            .                       ;}
            .                       ;} range of true condition
            .                       ;}
            .else
            .                       ;}
            .                       ;} range of false condition
            .                       ;}
            .endif

       The  conditional  assembly directives allow you to include or
    exclude blocks of source code during the assembly process, based
    on the evaluation of the condition test.

       The  range of true condition will be processed if the expres-
    sion 'expr' is not zero (i.e.  true) and the range of false con-
    dition  will  be processed if the expression 'expr' is zero (i.e
    false).  The range of true condition is optional as is the .else
    directive  and  the range of false condition.  The following are
    all valid .if/.else/.endif constructions:

            .if     A-4             ;evaluate A-4
            .byte   1,2             ;insert bytes if A-4 is
            .endif                  ;not zero

            .if     K+3             ;evaluate K+3
            .else
            .byte   3,4             ;insert bytes if K+3
            .endif                  ;is zero

            .if     J&3             ;evaluate J masked by 3
            .byte   12              ;insert this byte if J&3
            .else                   ;is not zero
            .byte   13              ;insert this byte if J&3
            .endif                  ;is zero

    The .if/.else/.endif directives may be nested upto 10 levels.

       The  .page  directive  is  processed within a false condition
    range to allow extended textual information to  be  incorporated
    in  the  source  program  with  out  the need to use the comment
    delimiter (;):

            .if     0

            .page
            This text will be bypassed during assembly
            but appear in the listing file.
            .
            .
            .

            .endif

##### => Section Index

####

    .include Directive

    Format:

            .include        string

    where:  string  represents  a  delimited string that is the file
                    specification of an ASxxxx source file.

       The .include directive is used to insert a source file within
    the source file currently being assembled.  When this  directive
    is encountered, an implicit .page directive is issued.  When the
    end of the specified source file is reached, an  implicit  .page
    directive is issued and input continues from the previous source
    file.  The maximum nesting level of source files specified by  a
    .include directive is five.

       The  total  number  of separately specified .include files is
    unlimited as each .include file is opened and then closed during
    each pass made by the assembler.

       The  default  directory  path,  if none is specified, for any
    .include file is the directory path of the  current  file.   For
    example:   if  the  current  source file, D:\proj\file1.asm, in-
    cludes  a  file  specified   as   "include1"   then   the   file
    D:\proj\include1.asm is opened.

##### => Section Index

####

    .setdp Directive

    Format:

            .setdp [base [,area]]

    The  set  direct  page  directive has a common format in all the
    AS68xx assemblers.  The .setdp directive is used to  inform  the
    assembler  of  the current direct page region and the offset ad-
    dress within the selected area.  The normal  invocation  methods
    are:

            .area   DIRECT  (PAG)
            .setdp

            or

            .setdp  0,DIRECT

    for  all  the  68xx microprocessors (the 6804 has only the paged
    ram area).  The commands specify that the direct page is in area
    DIRECT and its offset address is 0 (the only valid value for all
    but the 6809 microprocessor).  Be sure to place the DIRECT  area
    at address 0 during linking.  When the base address and area are
    not specified, then zero and the current area are the  defaults.
    If  a  .setdp directive is not issued the assembler defaults the
    direct page to the area "_CODE" at offset 0.

       The  assembler  verifies  that  any  local variable used in a
    direct variable reference is located in this area.  Local  vari-
    able  and  constant value direct access addresses are checked to
    be within the address range from 0 to 255.

       External direct references are assumed by the assembler to be
    in the correct area and have valid  offsets.   The  linker  will
    check all direct page relocations to verify that they are within
    the correct area.

       The  6809  microprocessor  allows the selection of the direct
    page to be on any 256 byte boundary by loading  the  appropriate
    value  into the dp register.  Typically one would like to select
    the page boundary at link time, one method follows:

            .area   DIRECT  (PAG)   ; define the direct page
            .setdp
            .
            .
            .
            .area   PROGRAM
            .
            ldd     #DIRECT         ; load the direct page register
            tfr     a,dp            ; for access to the direct page

    At  link  time specify the base and global equates to locate the
    direct page:

            -b DIRECT = 0x1000
            -g DIRECT = 0x1000

    Both  the  area address and offset value must be specified (area
    and variable names are independent).   The  linker  will  verify
    that  the  relocated  direct page accesses are within the direct
    page.
    The  preceeding  sequence  could  be repeated for multiple paged
    areas, however an alternate method is to define a non-paged area
    and use the .setdp directive to specify the offset value:

            .area   DIRECT          ; define non-paged area
            .
            .
            .
            .area   PROGRAM
            .
            .setdp  0,DIRECT        ; direct page area
            ldd     #DIRECT         ; load the direct page register
            tfr     a,dp            ; for access to the direct page
            .
            .
            .setdp  0x100,DIRECT    ; direct page area
            ldd     #DIRECT+0x100   ; load the direct page register
            tfr     a,dp            ; for access to the direct page

    The  linker  will  verify that subsequent direct page references
    are in the specified area and offset address range.  It  is  the
    programmers responsibility to load the dp register with the cor-
    rect page segment  corresponding  to  the  .setdp  base  address
    specified.

       For  those  cases  where a single piece of code must access a
    defined data structure within a direct page and there  are  many
    pages,  define  a  dumby  direct page linked at address 0.  This
    dumby page is used only to define  the  variable  labels.   Then
    load  the dp register with the real base address but donot use a
    .setdp  directive.   This  method  is  equivalent   to   indexed
    addressing,  where the dp register is the index register and the
    direct addressing is the offset.

##### => Section Index

####

#####

    .16bit, .24bit, and .32bit Directives

    Format:

            .16bit          ;specify 16-bit addressing
            .24bit          ;specify 24-bit addressing
            .32bit          ;specify 32-bit addressing

       The  .16bit, .24bit, and .32bit directives are special direc-
    tives for assembler configuration when default  values  are  not
    used.  (Currently only the as8xCxxx assembler can use the .16bit
    and .24bit directives in special mode.)

     => Section Index

####

... Exit the ASxxxx Documentation

... Home Page