as86(1) 						      General Commands Manual							   as86(1)

NAME

       as86 - Assembler for 8086..80386 processors

SYNOPSIS

       as86 [-0123agjuw] [-lm[list]] [-n name] [-o obj] [-b[bin]] [-s sym] [-t textseg] src

       as86_encap prog.s prog.v [prefix_] [as86 options]

DESCRIPTION

       as86  is an assembler for the 8086..80386 processors, it's syntax is closer to the intel/microsoft form rather than the more normal generic
       form of the unix system assembler.

       The src file can be '-' to assemble the standard input.

       This assembler can be compiled to support the 6809 cpu and may even work.

       as86_encap is a shell script to call as86 and convert the created binary into a C file prog.v to be included in	or  linked  with  programs
       like  boot  block installers.  The prefix_ argument is a prefix to be added to all variables defined by the source, it defaults to the name
       of the source file. The variables defined include prefix_start prefix_size and prefix_data to define and contain the  code,  plus  integers
       containing the values of all exported labels.  Either or both the prog.s and prog.v arguments can be '-' for standard in/out.

OPTIONS

       -0     start with 16-bit code segment, warn for all instructions > 8086

       -1     start with 16-bit code segment, warn for all instructions > 80186

       -2     start with 16-bit code segment, warn for all instructions > 80286

       -3     start with 32-bit code segment, don't warn for any instructions. (not even 486 or 586)

       -a     enable  partial compatibility with Minix asld. This swaps the interpretation of round brackets and square brackets as well as making
	      alterations to the code generation and syntax for 16bit jumps and calls. ("jmp @(bx)" is then a valid instruction)

       -g     only put global symbols in object or symbol file

       -j     replace all short jumps with similar 16 or 32 bit jumps, the 16 bit conditional branches are encoded as a short  conditional  and  a
	      long unconditional branch.

       -O     this causes the assembler to add extra passes to try to use forward references to reduce the bytes needed for some instructions.	If
	      the labels move on the last pass the assembler will keep adding passes until the labels all stabilise (to a maximum  of  30  passes)
	      It's probably not a good idea to use this with hand written assembler use the explicit br bmi bcc style opcodes for 8086 code or the
	      jmp near style for conditional i386 instructions and make sure all variables are defined before they are used.

       -l     produce list file, filename may follow

       -m     print macro expansions in listing

       -n     name of module follows (goes in object instead of source name)

       -o     produce object file, filename follows

       -b     produce a raw binary file, filename may follow.  This is a 'raw' binary file with no header, if there's no -s option the file starts
	      at location 0.

       -s     produce  an  ASCII  symbol  file,  filename follows.  The format of this table is designed to be easy to parse for encapsulation and
	      related activities in relation to binary files created with the -b option.  If a binary file doesn't  start  at  location  zero  the
	      first two items in the table are the start and end addresses of the binary file.

       -u     assume undefined symbols are imported-with-unspecified segment.

       -w-    allow the assembler to print warning messages.

       -t n   move all text segment data in segment n+3.

AS86 SOURCE
       Special characters

       *      Address of the start of the current line.

       ; !    Either  of  these  marks	the  start  of a comment. In addition any 'unexpected' character at the start of a line is assumed to be a
	      comment (but it's also displayed to the terminal).

       $      Prefix for hexadecimal numbers, the 'C' syntax, eg 0x1234, is also accepted.

       %      Prefix for binary numbers.

       #      Prefix for immediate operands.

       [ ]    Specifies an indirect operand.
	      Unlike MASM the assembler has no type information on labels just a segment and offset. This means that the way this operator and the
	      immediate prefix work are like traditional assemblers.

	      Examples:
		   mov	   ax,bx
		   jmp	   bx
	      Direct register addressing, the jump copies BX into PC.

		   mov ax,[bx]
		   jmp [bx]
	      Simple indirect register addressing, the jump moves the contents of the location specified by BX into the PC.

		   mov ax,#1234
	      Immediate value, ax becomes 1234.

		   mov ax,1234
		   mov ax,_hello
		   mov ax,[_hello]
	      Absolute addressing, ax is set to contents of location 1234. Note the third option is not strictly consistant but is in place mainly
	      for asld compatibility.

		   mov ax,_table[bx]
		   mov ax,_table[bx+si]
		   mov eax,_table[ebx*4]

		   mov ax,[bx+_table]
		   mov ax,[bx+si+_table]
		   mov eax,[ebx*4+_table]
	      Indexed addressing, both formats are ok, I think the first is more correct but I tend to used the second. :-)

       Conditionals

       IF, ELSE, ELSEIF, ENDIF
	      Numeric condition

       IFC, ELSEIFC
	      String compare (str1,str2)

       FAIL .FAIL
	      Generate user error.

       Segment related

       .TEXT .ROM .DATA .BSS
	      Set current segment. These can be preceded by the keyword .SECT

       LOC    Set numeric segment 0=TEXT, 3=DATA,ROM,BSS, 14=MAX.  The segment order set  by  the  linker  is  now  0,4,5,6,7,8,9,A,B,C,D,E,1,2,3.
	      Segment  0  and  all  segments  above 3 are assumed to be text segment.  Note the 64k size restrictions are not imposed for segments
	      3-14.

       Label type definition

       EXPORT PUBLIC .DEFINE
	      Export label defined in this object

       ENTRY  Force linker to include the specified label in a.out

       .GLOBL .GLOBAL
	      Define label as external and force import even if it isn't used.

       EXTRN EXTERN IMPORT .EXTERN
	      Import list of externally defined labels
	      NB: It doesn't make sense to use imports for raw binary files.

       .ENTER Mark entry for old binary file (obs)

       Data definition

       DB .DATA1 .BYTE FCB
	      List of 1 byte objects.

       DW .DATA2 .SHORT FDB .WORD
	      List of 2 byte objects.

       DD .DATA4 .LONG
	      List of 4 byte objects.

       .ASCII FCC
	      Ascii string copied to output.

       .ASCIZ Ascii string copied to output with trailing nul byte.

       Space definition

       .BLKB RMB .SPACE
	      Space is counted in bytes.

       .BLKW .ZEROW
	      Space is counted in words. (2 bytes each)

       COMM .COMM LCOMM .LCOMM
	      Common area data definition

       Other useful pseudo operations.

       .ALIGN .EVEN
	      Alignment

       EQU    Define label

       SET    Define re-definable label

       ORG .ORG
	      Set assemble location

       BLOCK  Set assemble location and stack old one

       ENDB   Return to stacked assemble location

       GET INCLUDE
	      Insert new file (no quotes on name)

       USE16 [cpu]
	      Define default operand size as 16 bit, argument is cpu type the  code  is  expected  to  run  on	(86,  186,  286,  386,	486,  586)
	      instructions for cpus later than specified give a warning.

       USE32 [cpu]
	      Define  default  operand	size  as  32  bit,  argument  is  cpu  type  the  code is expected to run on (86, 186, 286, 386, 486, 586)
	      instructions for cpus later than specified give a warning. If the cpu is not mentioned the assembler ensures it is >= 80386.

       END    End of compilation for this file.

       .WARN  Switch warnings

       .LIST  Listings on/off (1,-1)

       .MACLIST
	      Macro listings on/off (1,-1)

       Macros, now working, the general form is like this.

	   MACRO sax
	      mov ax,#?1
	   MEND
	   sax(1)

       Unimplemented/unused.

       IDENT  Define object identity string.

       SETDP  Set DP value on 6809

       MAP    Set binary symbol table map number.

       Registers
	      BP BX DI SI
	      EAX EBP EBX ECX EDI EDX ESI ESP
	      AX CX DX SP
	      AH AL BH BL CH CL DH DL
	      CS DS ES FS GS SS
	      CR0 CR2 CR3 DR0 DR1 DR2 DR3 DR6 DR7
	      TR3 TR4 TR5 TR6 TR7 ST

       Operand type specifiers
	      BYTE DWORD FWORD FAR PTR PWORD QWORD TBYTE WORD NEAR

	      The 'near and 'far' do not allow multi-segment programming, all 'far' operations are specified explicitly through  the  use  of  the
	      instructions:  jmpi,  jmpf,  callf, retf, etc. The 'Near' operator can be used to force the use of 80386 16bit conditional branches.
	      The 'Dword' and 'word' operators can control the size of operands on far jumps and calls.

       General instructions.
	      These are in general the same as the instructions found in any 8086 assembler, the main exceptions being a few 'Bcc' (BCC, BNE, BGE,
	      etc)  instructions  which are shorthands for a short branch plus a long jump and 'BR' which is the longest unconditional jump (16 or
	      32 bit).

       Long branches
	      BCC BCS BEQ BGE BGT BHI BHIS BLE BLO BLOS BLT BMI BNE BPC BPL BPS BVC BVS BR

       Intersegment
	      CALLI CALLF JMPI JMPF

       Segment modifier instructions
	      ESEG FSEG GSEG SSEG

       Byte operation instructions
	      ADCB ADDB ANDB CMPB DECB DIVB IDIVB IMULB INB INCB MOVB MULB NEGB NOTB ORB OUTB RCLB RCRB ROLB RORB SALB SARB SHLB  SHRB	SBBB  SUBB
	      TESTB XCHGB XORB

       Standard instructions
	      AAA  AAD	AAM  AAS  ADC ADD AND ARPL BOUND BSF BSR BSWAP BT BTC BTR BTS CALL CBW CDQ CLC CLD CLI CLTS CMC CMP CMPS CMPSB CMPSD CMPSW
	      CMPW CMPXCHG CSEG CWD CWDE DAA DAS DEC DIV DSEG ENTER HLT IDIV IMUL IN INC INS INSB INSD INSW INT INTO INVD INVLPG INW IRET IRETD  J
	      JA  JAE  JB  JBE JC JCXE JCXZ JE JECXE JECXZ JG JGE JL JLE JMP JNA JNAE JNB JNBE JNC JNE JNG JNGE JNL JNLE JNO JNP JNS JNZ JO JP JPE
	      JPO JS JZ LAHF LAR LDS LEA LEAVE LES LFS LGDT LGS LIDT LLDT LMSW LOCK LODB LODS LODSB LODSD LODSW  LODW  LOOP  LOOPE  LOOPNE  LOOPNZ
	      LOOPZ LSL LSS LTR MOV MOVS MOVSB MOVSD MOVSW MOVSX MOVW MOVZX MUL NEG NOP NOT OR OUT OUTS OUTSB OUTSD OUTSW OUTW POP POPA POPAD POPF
	      POPFD PUSH PUSHA PUSHAD PUSHF PUSHFD RCL RCR REP REPE REPNE REPNZ REPZ RET RETF RETI ROL ROR SAHF SAL SAR SBB SCAB SCAS SCASB  SCASD
	      SCASW SCAW SEG SETA SETAE SETB SETBE SETC SETE SETG SETGE SETL SETLE SETNA SETNAE SETNB SETNBE SETNC SETNE SETNG SETNGE SETNL SETNLE
	      SETNO SETNP SETNS SETNZ SETO SETP SETPE SETPO SETS SETZ SGDT SHL SHLD SHR SHRD SIDT SLDT SMSW STC STD  STI  STOB	STOS  STOSB  STOSD
	      STOSW STOW STR SUB TEST VERR VERW WAIT WBINVD XADD XCHG XLAT XLATB XOR

       Floating point
	      F2XM1  FABS  FADD  FADDP	FBLD  FBSTP FCHS FCLEX FCOM FCOMP FCOMPP FCOS FDECSTP FDISI FDIV FDIVP FDIVR FDIVRP FENI FFREE FIADD FICOM
	      FICOMP FIDIV FIDIVR FILD FIMUL FINCSTP FINIT FIST FISTP FISUB FISUBR FLD FLD1 FLDL2E FLDL2T FLDCW FLDENV FLDLG2  FLDLN2  FLDPI  FLDZ
	      FMUL FMULP FNCLEX FNDISI FNENI FNINIT FNOP FNSAVE FNSTCW FNSTENV FNSTSW FPATAN FPREM FPREM1 FPTAN FRNDINT FRSTOR FSAVE FSCALE FSETPM
	      FSIN FSINCOS FSQRT FST FSTCW FSTENV FSTP FSTSW FSUB FSUBP FSUBR FSUBRP FTST FUCOM FUCOMP	FUCOMPP  FWAIT	FXAM  FXCH  FXTRACT  FYL2X
	      FYL2XP1

Using GASP
       The Gnu assembler preprocessor provides some reasonable implementations of user biased pseudo opcodes.

       It can be invoked in a form similar to:

       gasp   [-a...]  file.s [file2.s] |
	      as86 [...]  - [-o obj] [-b bin]

       Be aware though that Gasp generates an error for .org commands, if you're not using alternate syntax you can use org instead, otherwise use
       block and endb.	The directive export is translated into .global, which forces an import, if you are making a file using -b use	public	or
       .define instead.

       The GASP list options have no support in as86.

SEE ALSO

       as(1), ld86(1), bcc(1)

BUGS

       The 6809 version does not support -0, -3, -a or -j.

       If this assembler is compiled with BCC this is classed as a 'small' compiler, so there is a maximum input line length of 256 characters and
       the instruction to cpu checking is not included.

       The checking for instructions that work on specific cpus is probably not complete, the distinction between 80186 and  80286  is	especially
       problematic.

       The .text and .data pseudo operators are not useful for raw binary files.

       When using the org directive the assembler can generate object files that may break ld86(1).

								     Mar, 1999								   as86(1)