The BLITZ Assembler

Harry H. Porter III

Department of Computer Science

Portland State University

September 25, 2007

Introduction

This document describes the BLITZ Assembler tool. The assembler takes a single input source program, written in BLITZ assembly code, and produces an “object file”. The input assembly code program may be produced as the output of a compiler or may be hand-coded by an assembly language programmer. Later, one or more object files are combined to produce an “executable file” by the linker.

The material in this document closely resembles the “help” info printed by

asm –h

However, the material in this document is more inclusive. This document includes corrections, clarifications, elaborations, and additional information.

Command Line Options

The assembler tool is called “asm”. Like any Unix/Linux command, it accepts command line options. Here are the command line options, which may be given in any order.

filename

The input source will come from this file. (Normally this file will end with “.s”.) If an input file is not given on the command line, the source must come from stdin. Only one input source is allowed.

-h

Print help info. All other options will be ignored and no assembly will be performed.

-l

Print a detailed listing on stdout, showing what machine code was generated.

-s

Print the symbol table on stdout, showing the values of all symbols appearing in the program.

-d

Print internal assembler info, for debugging the assembler tool itself.

-o filename

If there are no errors, an object file will be created. This option can be used to give the object file a specific name. If this option is not used, then the input .s file must be named on the command line (i.e., the source must not come from stdin.) In this option is not used, the name of the object file will be computed from the name of the input file by removing the “.s” extension, if any, and appending “.o”. For example:

test.s --> test.o

foo --> foo.o

Lexical Issues

Identifiers

Identifiers may contain letters, digits, and underscores. They must begin with a letter or underscore. Case is significant. Identifiers are limited in length to 200 characters.

Integers

Integers may be specified in decimal or in hex. Integers must range from 0 to 2147483647. Hex notation may be used, and begin with 0x, for example, 0x1234abcd. The hex numerals a-f can be capitalized so, for example 0x1234ABCD is equivalent to 0x1234abcd. Shorter integers like 0xFFFF are not sign-extended.

Floating-Point Constants (Real Numbers)

Real numbers are specified in decimal notation, for example:

123.456

456e10 Either “e” or “.” is required.

456.789e10 Both fraction and exponent can appear.

+123.456

-123.456 A leading “+” or “-” is optionally allowed.

456.789e10 The “e” may be upper or lower case.

456.789E-10 The exponent can be negative.

456.789e+10 If the exponent is positive, the “+” is optional.

Reals are represented using the IEEE double precision floating point representation. Each real number is represented with 64 bits. The leading sign is optional. The number must contain either a decimal point (“.”) or an “e” to indicate that it is a real number and not an integer. The “e” may be upper or lower case and must be followed by at least one digit. A sign may be included after the “e” and before the exponent.

Strings

Strings use double quotes. For example,

"Hello, world!\n"

The following escape sequences are allowed within strings:

\0 00 0 NUL control-@

\a 07 7 BEL (alert) control-G

\b 08 8 BS (backspace) control-H

\t 09 9 HT (tab) control-I

\n 0A 10 LF/NL (newline) control-J

\v 0B 11 VT control-K

\f 0C 12 FF (form feed) control-L

\r 0D 13 CR (return) control-M

\" 22 34 "

\' 27 39 '

\\ 5C 92 \

\xHH HH (other)

The last form, in which HH are any two hex digits, can be used to include any byte within a string. For example, these two strings include the same bytes:

"Hello, world!\n"

"Hello, world!\h0A"

Strings may not contain newlines directly; in other words, a string may not span multiple lines. However, the following string is okay:

"First\nSecond\nThird\n"

The source file may not contain unprintable ASCII characters; use the escape sequences if you wish to include unprintable characters in string or character constants.

String constants are limited in length to 200 characters.

Note that—unlike in the “C” language—strings do not include the NUL character. However, it can be included where desired, as in:

"Hello, world!\n\0"

Characters

Character constants use single quotes. The same escape sequences are allowed. For example:

'x'

'\n'

A character constant must specify exactly one byte.

Comments

Comments begin with the exclamation mark (!) and extend through the end-of-line.

Punctuation symbols

The following symbols have special meaning:

,

[

]

:

.

+

++

-

--

*

/

<<

>>

>>>

&

|

^

~

(

)

=

Keywords

The following classes of keywords are recognized:

BLITZ instruction op-codes (e.g., add, sub, syscall, ...)

Synthetic instructions (e.g., mov, set, ...)

Assembler pseudo-ops (e.g., .text, .import, .byte, ...)

Register names (r0, r1, ... r15)

White space

Tabs and space characters may be used between tokens.

End-of-line

The EOL (newline) character is treated as a token, not as white space; the EOL is significant in syntax parsing.

Assembler Commands

An number of assembler command may appear in the assembler source code. (Assembler commands are often called “pseudo-ops”.) Syntactically, these command are used like normal machine instructions. For example, some of them expect operands and some of them may be prefixed with a label. For example:

set r1,mydata

jmp label43

.data

mydata: .word 123

However, these are commands to the assembler, telling it how to produce the machine code. These commands are processed directly by the assembler and, unlike normal instructions, are not translated into machine instructions.

To distinguish the assembler commands from normal instructions, most all of the commands start with a period.

.text

The instructions and data following the .text command (up to the next .data or .bss command) will be placed in the “.text” segment. The .text segment will be marked by the operating system as “read-only” during execution.

.data

The instructions and data following the .data command (up to the next .text or .bss command) will be placed in the “.data” segment. The .data segment will be marked by the operating system as “readable” and “writable” during execution.

.bss

The bytes following the .bss command (up to the next .text or .data command) will be placed in the “.bss” segment. The .bss segment will be initialized to zero by the operating system at program load time and will be flagged as “readable” and “writable”.

.ascii

This command expects a single string operand. These bytes will be loaded into memory. Note that no terminating NULL ('\0') character will be added to the end of the string.

.byte

This pseudo-op expects a single expression as an operand. This expression will be evaluated at assembly time, the value will be truncated to 8 bits, and the result used to initialize a single byte of memory.

.word

This pseudo-op expects a single expression as an operand. This expression will be evaluated at assembly time to a 32 bit value, and the result used to initialize four bytes of memory. The assembler does not require alignment for .word, although many instructions do.

.double

This pseudo-op expects a single floating-point constant as an operand. Here are examples of allowable floating point constants:

1.2

-3.4E-21

+4.5e+21

.export

This pseudo-op expects a single symbol as an operand. This symbol must be given a value in this file. This symbol with its value will be placed in the object file and made available during segment linking.

.import

This pseudo-op expects a single symbol as an operand. This symbol must not be given a value in this file; instead it will receive its value from another .s file during segment linking. All uses of this symbol in this file will be replaced by that value at segment-link time.

.skip

This pseudo-op expects a single expression as an operand. This expression must evaluate to an absolute value. The indicated number of bytes will be skipped in the current segment.

.align

This instruction will insert 0, 1, 2, or 3 bytes into the current segment as necessary to bring the location up to an even multiple of 4. No operand is used with .align.

=

Symbols may be given values with a line of the following format:

symbol = expression

For example:

mov MyStrLen,r1

.data

MyStr: .ascii "hello, world"

MyStrEnd:

MyStrLen = MyStrEnd-MyStr

These are called “equates”. Equates will be processed during the first pass, if possible. If not, they will be processed after the program has been completely read in. The expression may use symbols that are defined later in the file, but this may cause the equate to be given a value slightly later in the assembly. After the first pass, an attempt will be made to evaluate all the equates. At this time, errors may be generated. After the equates have been processed, the machine code can be generated in the final pass.

Segments

This assembler is capable of assembling BLITZ instructions and data and placing them in one of three “segments”:

.text

.data

.bss

At run-time, the bytes placed in the .text segment will be read-only. At run-time, the bytes places in the .data segment will be read-write. At run-time, the bytes places in the .bss segment will be read-write. The read-only nature of the bytes in the .text segment may or may not be enforced by the operating system at run-time.

Instructions and data may be placed in either the .text or .data segment. No instructions or data may be placed in the .bss segment. The only things that may follow the .bss pseudo-op are the following pseudo-ops:

.skip

.align

The assembler may reserve bytes in the .bss segment but no initial values may be placed in these locations. Instead, all bytes of the .bss segment will be initialized to zeros at program-load time. These addresses may be initialized and modified during program execution.

Segment control is done using the following pseudo-ops:

.text

.data

.bss

After any one of these pseudo-ops, all following instructions and data will be placed in the named segment. A separate “location counter” for each of the three segments is maintained by the assembler. If, for example, a .text pseudo-op has been used to switch to the “.text” segment, then all subsequent instructions will be placed in the “.text” segment. Any labels encountered will be given values relative to the “.text” segment. As each instruction is encountered, the location counter for the “.text” segment will be incremented. If a .data pseudo-op is the encountered, all subsequent instructions will be placed in the “.data” segment. The location counters are not reset; if a .text pseudo-op is again encountered, subsequent instructions will be placed in the “.text” segment following the instructions encountered earlier, before the .data pseudo-op was seen. Thus, we can “pick up” in the .text segment where we left off.

Symbols

The assembler builds a symbol table, mapping identifiers to values. Each symbol is given exactly one value; there is no notion of scope or lexical nesting levels, as in high-level languages.

Each symbol is given a 32-bit integer value, although the assembler may not know the exact value. In some cases, the value cannot be computed until the linker is invoked and code is relocated to its final position in memory. In other cases, the assembler can determine the symbol’s value.

Symbols may either be defined within the file being assembled or externally, in some other .s file. If the symbol is defined in this file, it will either be given an absolute value that can be determined during assembly, or it will be defined relative to values that will not be known until the linker is run.

Thus, each symbol used in a given .s file will be either

external

absolute

relative

An external symbol will have its value assigned in some other assembly source file so its value will not be available to the code in this file until segment-linking time. In other words, the assembler will not know the value, but the value will be determined later by the linker. An external symbol may be used in expressions within this file. However, the actual value will not be computed and the data will not be filled in until segment-linking time.

An absolute symbol has its value defined within the file being assembled. This quantity will be computed by the assembler and its value will be known while this file is assembled.

A relative symbol is defined relative to some other value that the assembler does not know. Just like an external symbol, the value of a relative symbol cannot be determined until the linker runs. The value of a relative symbol is an offset relative to some memory location or to an external symbol, neither of which can be determined until link time.

If a symbol is used in this file, but not defined in this file, then the symbol must be “imported” using the .import pseudo-op.

If a symbol is defined in this file and used in other files, then it must be “exported” using an .export pseudo-op. If a symbol is not exported, then its value will not be known to the linker; if this same symbol is imported in other files, then an “undefined symbol” error will be generated by the linker at segment-linking time. In other words, if a symbol is ever imported by any .s file, then it must be exported by exactly one .s file.

More precisely, absolute symbols must be defined within this file, possibly as a function of other absolute symbols and constant values, but not in terms of external or relative symbols. External symbols are defined, not in the file being assembled, but in some other file. Any symbol defined within this file will be “relative” if it is defined in terms of an external symbol, or if it is defined relative to some position in the .text, .data, or .bss segments, or if it is defined as a function of another relative symbol.

Symbols may be defined in either of two ways:

labels

= equates

If a symbol is defined by being used as a label, then it is given a value which consists of an offset relative to the beginning of whichever segment is current when the label is encountered. This is determined by whether a .text, .data, or .bss pseudo-op was seen last, before the label was encountered.

Each label occurs in a segment and names a location in memory. At segment-link time, the segments are placed in their final positions in memory. Only at segment-link time does the actual address of the location in memory become known. At this time, the label is assigned an absolute value.

Expression Evaluation

Some instructions and pseudo-ops may contain expressions in their operands. Expressions have the form given by the following Context-Free Grammar.

(In this grammar, the following meta-notation is used: characters enclosed in double quotes are terminals, and appear exactly as shown. The braces { } are used to mean “zero or more” occurrences. The vertical bar | is used to mean alternation. Parentheses are used for grouping. The start symbol is “expr”.)

expr ::= expr1 { “|” expr1 }

expr1 ::= expr2 { “^” expr2 }

expr2 ::= expr3 { “&” expr3 }

expr3 ::= expr4 { ( “<<” | “>>” | “>>>” ) expr4 }

expr4 ::= expr5 { ( “+” | “-” ) expr5 }

expr5 ::= expr6 { ( “*” | “/” | “%” ) expr6 }

expr6 ::= “+” expr6 | “-” expr6 | “~” expr6

| ID | INTEGER | STRING | “(“ expr “)”

This syntax results in the following precedences and associativities:

highest: unary+ unary- ~ (right associative)

* / % (left associative)

+ - (left associative)

<< >> >>> (left associative)

& (left associative)

^ (left associative)

lowest: | (left associative)

If a string is used in an expression, it must have exactly 4 characters. The string will be interpreted as a 32 bit integer, based on the ASCII values of the 4 characters. (“Big Endian” order is used: the first character will determine the most significant byte.)

The following operators are recognized in expressions:

unary + nop

unary - 32-bit signed arithmetic negation

~ 32-bit logical negation (NOT)

* 32-bit multiplication

/ 32-bit integer division with 32-bit integer result

% 32-bit modulo, with 32-bit result

binary + 32-bit signed addition

binary - 32-bit signed subtraction

<< left shift logical (i.e., zeros shifted in from right)

>> right shift logical (i.e., zeros shifted in from left)

>>> right shift arithmetic (i.e., sign bit shifted in on left)

& 32-bit logical AND

^ 32-bit logical Exclusive-OR

| 32-bit logical OR

With the shift operators (<<, >>, and >>>) the second operand must evaluate to an integer between 0 and 31. With the division operators (/ and %), the first operand must be non-negative and the second operand must be positive, since these operators are implemented with “C” operators, which are machine-dependent with negative operands.

All operators except addition and subtraction require both operands to evaluate to absolute values. All arithmetic is done with signed 32-bit values. The addition operator + requires that at least one of the operands evaluates to an absolute value. If one operand is relative, then the result will be relative to the same location. The subtraction operator requires that the second operand evaluates to an absolute value. If the first operand is relative, then the result will be relative to the same location. Only absolute values can be negated.

All expressions are evaluated at assembly-time. An expression may evaluate to either an absolute 32-bit value, or may evaluate to a relative value. A relative value is a 32-bit offset relative to some symbol. The offset will be relative to the beginning of the .text segment, the .data segment, or the .bss segment, or the offset will be relative to some external symbol. If the expression evaluates to a relative value, its value will not be determined until segment-link time. At this time, the absolute locations of the .text, .data, and .bss segments will be determined and the absolute values of external symbols will be determined. At segment-link time, the final, absolute values of all expressions will be determined by adding the values of the symbols (or locations of the segments) to the offsets.

Expressions may be used in:

.byte

.word

.skip

=

various BLITZ instructions

The .skip pseudo-op requires the expression to evaluate to an absolute value. In the case of an = (equate) pseudo-op, the expression may evaluate to either a relative or absolute value. In either case, the equated symbol will be given a relative or absolute value (respectively). At segment-linking time, when the actual value is determined, the value will be filled in in the byte, word, or appropriate field in the instruction.

Instruction Syntax

Each line in the assembly source file has the following general syntax:

[ label: ] [ opcode operands ] [ “!” comment ] EOL

The label is optional. It need not begin in column one. The label must be followed by a colon token. A label may be on a line by itself. If so, it will be given an offset from the current value of the location counter, relative to the current segment.

The opcode must be a legal BLITZ instruction. The opcode is given in lowercase. The exact format of the operands depends on the instruction; some BLITZ instructions take no operands while some require several operands. Operands are separated by commas.

A comment is optional and extends to the end of the line if present.

Each line is independent. The end-of-line (EOL) is a separate token. An instruction must be on only one line, although lines may be arbitrarily long.

Assembler pseudo-ops have the same general syntax. Some permit labels and others forbid labels.

The following formatting and spacing conventions are recommended:

• Labels should begin in column 1.

• The op-code should be indented by 1 tab stop.

• The operands, if any, should be indented by 1 additional tab stop.

• Each BLITZ instruction should be commented.

• The comment should be indented by 2 additional tab stops.

• A single space should follow the ! comment character.

• Block comments should occur before each routine.

• Comments should be indented with 2 spaces to show logical organization.

Here is an example of the recommended style for BLITZ assembly code. (The first line shows standard tab stops.)

1 t t t t t t

! main ()

!

! This routine does such and such.

!

.text

.export main

main: push r1 ! Save registers

push r2 ! .

loop: ! LOOP

cmp r1,10 ! IF r1>10 THEN

ble endif ! .

sub r2,1,r2 ! r2--

endif: ! ENDIF

sub r1,r2,r3 ! r3 := r1-r2

...

Labels

A label must be followed by a colon token, but the colon is not part of the label. A label may appear on a line by itself or the label may appear on a line containing a BLITZ instruction or one of the following pseudo-ops:

.ascii

.byte

.word

.double

.skip

When an instruction is labeled, the value of the label will be the address of the first byte of the instruction. This address will be determined later by the linker, when the segments are placed in memory.

When the label applies to an .ascii, .byte, .word, or .double pseudo-op, the value will be the address of the first byte of the data. When the label applies to a .skip pseudo-op, the value will be the address of the first byte of the uninitialized data.

For example, consider the following code:

Lab1: add r1,0x1234,r2

Lab2: .skip 2

Lab3: .ascii "abc"

Assume that the linker places this material at address 0x00010000. Note that the add instruction is assembled to 0x80211234 and that "abc" is 0x616263 in ASCII.

The linker would load memory with the following data:

address data

00010000 80 ¬ Lab1

00010001 21

00010002 12

00010003 34

00010004 00 ¬ Lab2

00010005 00

00010006 61 ¬ Lab3

00010007 62

00010008 63

Addresses would be assigned as follows:

Lab1 = 00010000

Lab2 = 00010004

Lab3 = 00010006

Each label definition will define a new symbol, and the symbol will be given an offset relative to the beginning of the current segment. Labels defined in the current file may be exported and labels defined in other files may be imported. A label will name an address in memory, and as such a label cannot be given a final value until segment-linking time. During the assembly of the current file, labels defined in the file are given offsets relative to either the beginning of the .text, .data, or .bss segments.

Note that labels are not allowed on the following pseudo-ops:

.text

.data

.bss

.export

.import

.align

The .text, .data, and .bss segments are not named, therefore these pseudo-ops permit neither a label nor any operands. The .export and .import pseudo-ops refer to symbols, but these symbols are specified in the operand field, not as labels. Finally, the .align pseudo-op may or may not place bytes in memory; it makes no sense to label these padding bytes, especially if there are zero of them.

Operand Syntax

See the BLITZ instruction reference manual for details about what operands each instruction requires. Operands are separated by commas. Registers are specified in lowercase (e.g., r4). A memory reference may be in one of the following forms, although not all forms are allowed in all instructions. (Here “Reg” stands for any register and “Expr” stands for any expression.)

[ Reg]

[ Reg + Reg ]

[ Reg + Expr ]

[ Expr ]

[ --Reg ]

[ Reg++ ]

Some instructions allow data to be included directly; in such cases the operand will consist of an expression. The expression may evaluate to an absolute or relative value. Certain instructions (like jmp, call, and the branch instructions) require the operand to be relative to the segment in which the instruction occurs.

Here are several sample instructions to illustrate operand syntax:

add r3,r4,r5

mul r7,size,r7

sub r1, ((x*23) << (y+1)), r1

call foo

push r6,[--r14]

pop [r14++],r6

load [r3],r9

load [r3+r4],r9

load [r3+arrayBase],r9

load [x],r9

jmp r3

bne loop

set 0x12ab34cd,r8

syscall 3

reti

tset [r4],r9

ldptbr r5

Note that whenever an instruction reads or writes memory, brackets are used.

An Example Program

Below is a example program written in BLITZ assembly code:

.text

!

! Imported Symbols:

!

.import putChar

!

! Exported Symbols:

!

.export main

!

! main

!

! This routine prints "Hello, world!"

!

main: set hello,r1 ! print message

call putString ! .

ret ! return

!

! putString

!

! This routine is passed r1, a pointer to a string

! of characters, terminated by '\0'. It sends all

! of them except the final '\0' to the output by

! calling 'putChar' repeatedly.

!

! Registers modified: none

!

putString:

push r1 ! save registers

push r2 ! .

mov r1,r2 ! r2 := ptr into string

putStLoop: ! loop

loadb [r2],r1 ! r1 := next char

add r2,1,r2 ! incr ptr

cmp r1,0 ! if (r1 == '\0')

be putStExit ! then break

call putChar ! putChar (r1)

jmp putStLoop ! end

putStExit: ! .

pop r2 ! restore regs

pop r1 ! .

ret ! return

!

! The data area

!

.data

hello: .ascii "Hello, world!\n\0"

Listings

If the above program is assembled with using the “-l” command line option:

asm MyProgram.s -l

then the following “listing” will be printed on stdout.

000000 .text

!

! Imported Symbols:

!

.import putChar

!

! Exported Symbols:

!

.export main

!

! main

!

! This routine prints "Hello, world!"

!

000000 c0100000 main: set hello,r1 ! print message

000004 c1100000

000008 a0000008 call putString ! .

00000c 09000000 ret ! return

!

! putString

!

! This routine is passed r1, a pointer to a string

! of characters, terminated by '\0'. It sends all

! of them except the final '\0' to the output by

! calling 'putChar' repeatedly.

!

! Registers modified: none

!

000010 putString:

000010 541f0000 push r1 ! save registers

000014 542f0000 push r2 ! .

000018 67210000 mov r1,r2 ! r2 := ptr into string

00001c putStLoop: ! loop

00001c 6c120000 loadb [r2],r1 ! r1 := next char

000020 80220001 add r2,1,r2 ! incr ptr

000024 81010000 cmp r1,0 ! if (r1 == '\0')

000028 a200000c be putStExit ! then break

00002c a0000000 call putChar ! putChar (r1)

000030 a1ffffec jmp putStLoop ! end

000034 putStExit: ! .

000034 552f0000 pop r2 ! restore regs

000038 551f0000 pop r1 ! .

00003c 09000000 ret ! return

!

! The data area

!

000000 .data

000000 48656c6c hello: .ascii "Hello, world!\n\0"

In the leftmost column, you see the addresses and in the next column you see the data to be placed in memory. Finally, the actual corresponding line from the source file is shown. Notice that the addresses are all relative, with the .text and .data segments (and the .bss segment) beginning at zero.

If the above program is assembled with using the “-s” command line option:

asm MyProgram.s -s

then the following information about the symbols will be printed:

STRING IMPORT EXPORT OFFSET RELATIVE-TO

=========== ====== ====== ====== ===========

putStLoop 28 .text

hello 0 .data

putString 16 .text

putStExit 52 .text

Hello, world!\n\0 0

main export 0 .text

_entry 0

putChar import 0

The symbol information shows all strings and symbols appearing in the program, as well as information about whether they are imported or exported. For each symbol we also see an offset. This value is always 0 for imported symbols. For relative symbols, the last column shows what this offset is relative to. For absolute symbols, the final column is blank and the offset column shows the absolute value.

Warnings and Error Messages

Warnings are printed in the form:

Warning on line <number>: <message>

Below is a list of all the warning messages that may be produced. Each one almost certainly indicates a programmer error.

Immediate value (0xHHHHHHHH) exceeds 16-bit limit.

In SETLO, the data exceeds 16 bits in length

In SETHI, the data appears to be in the form 0x1234 instead

of 0x12340000 as expected

Instruction not on aligned address

Relative branch offset (HHHHHHHH) exceeds 24-bit limit.

Errors are printed in the form:

Error on line <number>: <message>

Here, in alphabetical order, are all the error messages that may be produced:

.align takes no operands

.bss takes no operands

.data takes no operands

.skip expression may not use symbols defined after it

.text takes no operands

A label is not allowed on .align

A label is not allowed on .bss

A label is not allowed on .data

A label is not allowed on .export

A label is not allowed on .import

A label is not allowed on .text

A lone < is not a valid token

A lone > is not a valid token

At least one digit is required after decimal

Attempt to export a symbol which is not defined in this file: <XXXXX>

Attempt to import a symbol which is also defined in this file

Both operands to binary + may not be relative

Call, jump, or branch has an absolute value as an operand

EOF encountered within a string

End-of-file encountered after a \\ escape

End-of-file encountered after a \\x escape

End-of-file encountered within a comment

End-of-line (CR) encountered after a \\ escape

End-of-line (CR) encountered after a \\x escape

End-of-line (CR) encountered within a string

End-of-line (NL) encountered after a \\ escape

End-of-line (NL) encountered after a \\x escape

End-of-line (NL) encountered within a string

Expecting ')' in expression")) return NULL;

Expecting + after reg Ra

Expecting + or ]

Expecting ++ in [Ra++],Rc

Expecting -- in Rc,[--Ra]

Expecting Ra or Ra+Rc

Expecting Rc or Rc+data16

Expecting Register Fa

Expecting Register Fb

Expecting Register Fc

Expecting Register Ra

Expecting Register Rb

Expecting Register Rc

Expecting [ after comma

Expecting [ after op-code

Expecting [ in Rc,[--Ra]

Expecting [ in [Ra],Rc

Expecting ]

Expecting ] in Rc,[--Ra]

Expecting ] in Rc,[Ra+data16]

Expecting ] in [Ra++],Rc

Expecting ] in [Ra+data16],Ra

Expecting ] in [Ra],Rc

Expecting ] or + after Rc,[Ra...

Expecting ] or + after [Ra...

Expecting a floating point constant

Expecting closing quote in character constant

Expecting comma

Expecting comma after expression

Expecting comma after reg Fc

Expecting comma after reg Rc

Expecting comma in Fc,Ra

Expecting comma in Ra,Rb

Expecting comma in Ra,Rb or Ra,data16

Expecting comma in Ra,Rc

Expecting comma in Ra,Rc or [Ra+data16],Rc

Expecting comma in Rb,Rc

Expecting comma in Rc,Ra or Rc,[Ra+data16]

Expecting comma in [Ra++],Rc

Expecting comma in [Ra],Rc

Expecting comma in data16,Rb

Expecting comma in data16,Rc

Expecting comma in data32,Rc

Expecting either Rc or Rc,[--Ra]

Expecting exponent numerals

Expecting expression

Expecting string after .ascii

Expecting symbol after .export

Expecting symbol after .import

Exponent is out of range

Hex constants must be 8 or fewer digits

Illegal escape (only \\0, \\a, \\b, \\t, \\n, \\v, \\f, \\r, \\\", \\\', \\\\,

and \\xHH allowed)

Integer out of range (0..2147483647); use 0x80000000 for -2147483648

Invalid op-code or missing colon after label

Invalid or missing op-code

Maximum string length exceeded

Must have a hex digit after 0x

Must have a hex digit after \\x

Must have two hex digits after \\x

No legal instructions encountered

Not currently in a .text, .data, or .bss segment

Not in .text, .data, or .bss segment

Operands to % must be positive

Operands to / must be positive

Operands to binary - are relative to different symbols

Real number is out of range

Shift amount must be within 0..31

The % operator requires operands to be absolute values

The .skip expression must evaluate to an absolute value

The / operator requires operands to be absolute values

The << operator requires operands to be absolute values

The >> operator requires operands to be absolute values

The >>> operator requires operands to be absolute values

The ^ operator requires operands to be absolute values

The unary - operator requires operand to be an absolute value

The | operator requires operands to be absolute values

The ~ operator requires its operand to be an absolute value

This symbol is already defined

Undefined symbol: <XXXXX>

Unexpected material after [Ra],Rc

Unexpected material after op-code

Unexpected material after operand Rc

Unexpected material after operands

Unexpected period within identifier

Unexpected tokens after expression

Unexpected tokens after floating constant

Unexpected tokens after operands

Unexpected tokens after string

Unexpected tokens after symbol

We are not currently in the .text or .data segment

When strings are used in places expecting an integer, the string must be

exactly 4 chars long

"_entry" is not in the .text segment

"_entry" not at beginning of .text segment

When errors are detected, no object file will be created.