man/man1x/as.1x

   1 .so mnx.mac
   2 .TH AS 1x
   3 .\" unchecked (kjb)
   4 .CD "as \(en assembler"
   5 .SE "AS\(emASSEMBLER [IBM]"
   6 .SP 1
   7 .PP
   8 This document describes the language accepted by the 80386 assembler
   9 that is part of the Amsterdam Compiler Kit.  Note that only the syntax is
  10 described, only a few 386 instructions are shown as examples.
  11 .SS "Tokens, Numbers, Character Constants, and Strings"
  12 .PP
  13 The syntax of numbers is the same as in C.
  14 The constants 32, 040, and 0x20 all represent the same number, but are
  15 written in decimal, octal, and hex, respectively.
  16 The rules for character constants and strings are also the same as in C.
  17 For example, \(fma\(fm is a character constant.
  18 A typical string is "string".
  19 Expressions may be formed with C operators, but must use [ and ] for
  20 parentheses.  (Normal parentheses are claimed by the operand syntax.)
  21 .SS "Symbols"
  22 .PP
  23 Symbols contain letters and digits, as well as three special characters:
  24 dot, tilde, and underscore.
  25 The first character may not be a digit or tilde.
  26 .PP
  27 The names of the 80386 registers are reserved.  These are:
  28 .HS
  29 ~~~al, bl, cl, dl
  30 .br
  31 ~~~ah, bh, ch, dh
  32 .br
  33 ~~~ax, bx, cx, dx, eax, ebx, ecx, edx
  34 .br
  35 ~~~si, di, bp, sp, esi, edi, ebp, esp
  36 .br
  37 ~~~cs, ds, ss, es, fs, gs
  38 .HS
  39 The xx and exx variants of the eight general registers are treated as
  40 synonyms by the assembler.  Normally "ax" is the 16-bit low half of the
  41 32-bit "eax" register.  The assembler determines if a 16 or 32 bit
  42 operation is meant solely by looking at the instruction or the
  43 instruction prefixes.  It is however best to use the proper registers
  44 when writing assembly to not confuse those who read the code.
  45 .HS
  46 The last group of 6 segment registers are used for selector + offset mode
  47 addressing, in which the effective address is at a given offset in one of
  48 the 6 segments.
  49 .PP
  50 Names of instructions and pseudo-ops are not reserved.
  51 Alphabetic characters in opcodes and pseudo-ops must be in lower case.
  52 .SS "Separators"
  53 .PP
  54 Commas, blanks, and tabs are separators and can be interspersed freely
  55 between tokens, but not within tokens.
  56 Commas are only legal between operands.
  57 .SS "Comments"
  58 .PP
  59 The comment character is \*(OQ!\*(CQ.
  60 The rest of the line is ignored.
  61 .SS "Opcodes"
  62 .PP
  63 The opcodes are listed below.
  64 Notes: (1) Different names for the same instruction are separated by \*(OQ/\*(CQ.
  65 (2) Square brackets ([]) indicate that 0 or 1 of the enclosed characters
  66 can be included.
  67 (3) Curly brackets ({}) work similarly, except that one of the
  68 enclosed characters \fImust\fR be included.
  69 Thus square brackets indicate an option, whereas curly brackets indicate
  70 that a choice must be made.
  71 .sp
  72 .if t .ta 0.25i 1.2i 3i
  73 .if n .ta 2 10 24
  74 .nf
  75 .B "Data Transfer"
  76 .HS
  77         mov[b]  dest, source    ! Move word/byte from source to dest
  78         pop     dest    ! Pop stack
  79         push    source  ! Push stack
  80         xchg[b] op1, op2        ! Exchange word/byte
  81         xlat            ! Translate
  82         o16             ! Operate on a 16 bit object instead of 32 bit
  83
  84 .B "Input/Output"
  85 .HS
  86         in[b]   source  ! Input from source I/O port
  87         in[b]           ! Input from DX I/O port
  88         out[b]  dest    ! Output to dest I/O port
  89         out[b]          ! Output to DX I/O port
  90
  91 .B "Address Object"
  92 .HS
  93         lds     reg,source      ! Load reg and DS from source
  94         les     reg,source      ! Load reg and ES from source
  95         lea     reg,source      ! Load effect address of source to reg and DS
  96         {cdsefg}seg             ! Specify seg register for next instruction
  97         a16             ! Use 16 bit addressing mode instead of 32 bit
  98
  99 .B "Flag Transfer"
 100 .HS
 101         lahf            ! Load AH from flag register
 102         popf            ! Pop flags
 103         pushf           ! Push flags
 104         sahf            ! Store AH in flag register
 105
 106 .B "Addition"
 107 .HS
 108         aaa             ! Adjust result of BCD addition
 109         add[b]  dest,source     ! Add
 110         adc[b]  dest,source     ! Add with carry
 111         daa             ! Decimal Adjust after addition
 112         inc[b]  dest    ! Increment by 1
 113
 114 .B "Subtraction"
 115 .HS
 116         aas             ! Adjust result of BCD subtraction
 117         sub[b]  dest,source     ! Subtract
 118         sbb[b]  dest,source     ! Subtract with borrow from dest
 119         das             ! Decimal adjust after subtraction
 120         dec[b]  dest    ! Decrement by one
 121         neg[b]  dest    ! Negate
 122         cmp[b]  dest,source     ! Compare
 123
 124 .B "Multiplication"
 125 .HS
 126         aam             ! Adjust result of BCD multiply
 127         imul[b] source  ! Signed multiply
 128         mul[b]  source  ! Unsigned multiply
 129
 130 .B "Division"
 131 .HS
 132         aad             ! Adjust AX for BCD division
 133         o16 cbw         ! Sign extend AL into AH
 134         o16 cwd         ! Sign extend AX into DX
 135         cwde            ! Sign extend AX into EAX
 136         cdq             ! Sign extend EAX into EDX
 137         idiv[b] source  ! Signed divide
 138         div[b]  source  ! Unsigned divide
 139
 140 .B "Logical"
 141 .HS
 142         and[b]  dest,source     ! Logical and
 143         not[b]  dest    ! Logical not
 144         or[b]   dest,source     ! Logical inclusive or
 145         test[b] dest,source     ! Logical test
 146         xor[b]  dest,source     ! Logical exclusive or
 147
 148 .B "Shift"
 149 .HS
 150         sal[b]/shl[b]   dest,CL ! Shift logical left
 151         sar[b]  dest,CL ! Shift arithmetic right
 152         shr[b]  dest,CL ! Shift logical right
 153
 154 .B "Rotate"
 155 .HS
 156         rcl[b]  dest,CL ! Rotate left, with carry
 157         rcr[b]  dest,CL ! Rotate right, with carry
 158         rol[b]  dest,CL ! Rotate left
 159         ror[b]  dest,CL ! Rotate right
 160
 161 .B "String Manipulation"
 162 .HS
 163         cmps[b]         ! Compare string element ds:esi with es:edi
 164         lods[b]         ! Load from ds:esi into AL, AX, or EAX
 165         movs[b]         ! Move from ds:esi to es:edi
 166         rep             ! Repeat next instruction until ECX=0
 167         repe/repz               ! Repeat next instruction until ECX=0 and ZF=1
 168         repne/repnz             ! Repeat next instruction until ECX!=0 and ZF=0
 169         scas[b]         ! Compare ds:esi with AL/AX/EAX
 170         stos[b]         ! Store AL/AX/EAX in es:edi
 171
 172 .fi
 173 .B "Control Transfer"
 174 .PP
 175 \fIAs\fR accepts a number of special jump opcodes that can assemble to
 176 instructions with either a byte displacement, which can only reach to targets
 177 within \(mi126 to +129 bytes of the branch, or an instruction with a 32-bit
 178 displacement.  The assembler automatically chooses a byte or word displacement
 179 instruction.
 180 .PP
 181 The English translation of the opcodes should be obvious, with
 182 \*(OQl(ess)\*(CQ and \*(OQg(reater)\*(CQ for signed comparisions, and
 183 \*(OQb(elow)\*(CQ and \*(OQa(bove)*(CQ for unsigned comparisions.  There are
 184 lots of synonyms to allow you to write "jump if not that" instead of "jump
 185 if this".
 186 .PP
 187 The \*(OQcall\*(CQ, \*(OQjmp\*(CQ, and \*(OQret\*(CQ instructions can be
 188 either intrasegment or
 189 intersegment.  The intersegment versions are indicated with
 190 the suffix \*(OQf\*(CQ.
 191
 192 .if t .ta 0.25i 1.2i 3i
 193 .if n .ta 2 10 24
 194 .nf
 195 .B Unconditional
 196 .HS
 197         jmp[f]  dest    ! jump to dest (8 or 32-bit displacement)
 198         call[f] dest    ! call procedure
 199         ret[f]          ! return from procedure
 200
 201 .B "Conditional"
 202 .HS
 203         ja/jnbe         ! if above/not below or equal (unsigned)
 204         jae/jnb/jnc             ! if above or equal/not below/not carry (uns.)
 205         jb/jnae/jc              ! if not above nor equal/below/carry (unsigned)
 206         jbe/jna         ! if below or equal/not above (unsigned)
 207         jg/jnle         ! if greater/not less nor equal (signed)
 208         jge/jnl         ! if greater or equal/not less (signed)
 209         jl/jnqe         ! if less/not greater nor equal (signed)
 210         jle/jgl         ! if less or equal/not greater (signed)
 211         je/jz           ! if equal/zero
 212         jne/jnz         ! if not equal/not zero
 213         jno             ! if overflow not set
 214         jo              ! if overflow set
 215         jnp/jpo         ! if parity not set/parity odd
 216         jp/jpe          ! if parity set/parity even
 217         jns             ! if sign not set
 218         js              ! if sign set
 219
 220 .B "Iteration Control"
 221 .HS
 222         jcxz    dest    ! jump if ECX = 0
 223         loop    dest    ! Decrement ECX and jump if CX != 0
 224         loope/loopz     dest    ! Decrement ECX and jump if ECX = 0 and ZF = 1
 225         loopne/loopnz   dest    ! Decrement ECX and jump if ECX != 0 and ZF = 0
 226
 227 .B "Interrupt"
 228 .HS
 229         int     n       ! Software interrupt n
 230         into            ! Interrupt if overflow set
 231         iretd           ! Return from interrupt
 232
 233 .B "Flag Operations"
 234 .HS
 235         clc             ! Clear carry flag
 236         cld             ! Clear direction flag
 237         cli             ! Clear interrupt enable flag
 238         cmc             ! Complement carry flag
 239         stc             ! Set carry flag
 240         std             ! Set direction flag
 241         sti             ! Set interrupt enable flag
 242
 243 .fi
 244 .SS "Location Counter"
 245 .PP
 246 The special symbol \*(OQ.\*(CQ is the location counter and its value
 247 is the address of the first byte of the instruction in which the symbol
 248 appears and can be used in expressions.
 249 .SS "Segments"
 250 .PP
 251 There are four different assembly segments: text, rom, data and bss.
 252 Segments are declared and selected by the \fI.sect\fR pseudo-op.  It is
 253 customary to declare all segments at the top of an assembly file like
 254 this:
 255 .HS
 256 ~~~.sect .text; .sect .rom; .sect .data; .sect .bss
 257 .HS
 258 The assembler accepts up to 16 different segments, but
 259 .MX
 260 expects only four to be used.  Anything can in principle be assembled
 261 into any segment, but the
 262 .MX
 263 bss segment may only contain uninitialized data.
 264 Note that the \*(OQ.\*(CQ symbol refers to the location in the current
 265 segment.
 266 .SS "Labels"
 267 .PP
 268 There are two types: name and numeric.  Name labels consist of a name
 269 followed by a colon (:).
 270 .PP
 271 The numeric labels are single digits.  The nearest 0: label may be
 272 referenced as 0f in the forward direction, or 0b backwards.
 273 .SS "Statement Syntax"
 274 .PP
 275 Each line consists of a single statement.
 276 Blank or comment lines are allowed.
 277 .SS "Instruction Statements"
 278 .PP
 279 The most general form of an instruction is
 280 .HS
 281 ~~~label: opcode operand1, operand2    ! comment
 282 .HS
 283 .SS "Expression Semantics"
 284 .PP
 285 .tr ~~
 286 The following operators can be used:
 287 + \(mi * / & | ^ ~ << (shift left) >> (shift right) \(mi (unary minus).
 288 .tr ~
 289 32-bit integer arithmetic is used.
 290 Division produces a truncated quotient.
 291 .SS "Addressing Modes"
 292 .PP
 293 Below is a list of the addressing modes supported.
 294 Each one is followed by an example.
 295 .HS
 296 .ta 0.25i 3i
 297 .nf
 298         constant        mov eax, 123456
 299         direct access   mov eax, (counter)
 300         register        mov eax, esi
 301         indirect        mov eax, (esi)
 302         base + disp.    mov eax, 6(ebp)
 303         scaled index    mov eax, (4*esi)
 304         base + index    mov eax, (ebp)(2*esi)
 305         base + index + disp.    mov eax, 10(edi)(1*esi)
 306 .HS
 307 .fi
 308 Any of the constants or symbols may be replacement by expressions.  Direct
 309 access, constants and displacements may be any type of expression.  A scaled
 310 index with scale 1 may be written without the \*(OQ1*\*(CQ.
 311 .SS "Call and Jmp"
 312 .PP
 313 The \*(OQcall\*(CQ and \*(OQjmp\*(CQ instructions can be interpreted
 314 as a load into the instruction pointer.
 315 .HS
 316 .ta 0.25i 3i
 317 .nf
 318         call _routine   ! Direct, intrasegment
 319         call (subloc)   ! Indirect, intrasegment
 320         call 6(ebp)     ! Indirect, intrasegment
 321         call ebx        ! Direct, intrasegment
 322         call (ebx)      ! Indirect, intrasegment
 323         callf (subloc)  ! Indirect, intersegment
 324         callf seg:offs  ! Direct, intersegment
 325 .HS
 326 .fi
 327 .SP 1
 328 .SS "Symbol Assigment"
 329 .SP 1
 330 .PP
 331 Symbols can acquire values in one of two ways.
 332 Using a symbol as a label sets it to \*(OQ.\*(CQ for the current
 333 segment with type relocatable.
 334 Alternative, a symbol may be given a name via an assignment of the form
 335 .HS
 336 ~~~symbol = expression
 337 .HS
 338 in which the symbol is assigned the value and type of its arguments.
 339 .SP 1
 340 .SS "Storage Allocation"
 341 .SP 1
 342 .PP
 343 Space can be reserved for bytes, words, and longs using pseudo-ops.
 344 They take one or more operands, and for each generate a value
 345 whose size is a byte, word (2 bytes) or long (4 bytes).  For example:
 346 .HS
 347 .if t .ta 0.25i 3i
 348 .if n .ta 2 24
 349         .data1 2, 6     ! allocate 2 bytes initialized to 2 and 6
 350 .br
 351         .data2 3, 0x10  ! allocate 2 words initialized to 3 and 16
 352 .br
 353         .data4 010      ! allocate a longword initialized to 8
 354 .br
 355         .space 40       ! allocates 40 bytes of zeros
 356 .HS
 357 allocates 50 (decimal) bytes of storage, initializing the first two
 358 bytes to 2 and 6, the next two words to 3 and 16, then one longword with
 359 value 8 (010 octal), last 40 bytes of zeros.
 360 .SS "String Allocation"
 361 .PP
 362 The pseudo-ops \fI.ascii\fR and \fI.asciz\fR
 363 take one string argument and generate the ASCII character
 364 codes for the letters in the string.
 365 The latter automatically terminates the string with a null (0) byte.
 366 For example,
 367 .HS
 368 ~~~.ascii "hello"
 369 .br
 370 ~~~.asciz "world\en"
 371 .HS
 372 .SS "Alignment"
 373 .PP
 374 Sometimes it is necessary to force the next item to begin at a word, longword
 375 or even a 16 byte address boundary.
 376 The \fI.align\fR pseudo-op zero or more null byte if the current location
 377 is a multiple of the argument of .align.
 378 .SS "Segment Control"
 379 .PP
 380 Every item assembled goes in one of the four segments: text, rom, data,
 381 or bss.  By using the \fI.sect\fR pseudo-op with argument
 382 \fI.text, .rom, .data\fR or \fI.bss\fR, the programmer can force the
 383 next items to go in a particular segment.
 384 .SS "External Names"
 385 .PP
 386 A symbol can be given global scope by including it in a \fI.define\fR pseudo-op.
 387 Multiple names may be listed, separate by commas.
 388 It must be used to export symbols defined in the current program.
 389 Names not defined in the current program are treated as "undefined
 390 external" automatically, although it is customary to make this explicit
 391 with the \fI.extern\fR pseudo-op.
 392 .SS "Common"
 393 .PP
 394 The \fI.comm\fR pseudo-op declares storage that can be common to more than
 395 one module.  There are two arguments: a name and an absolute expression giving
 396 the size in bytes of the area named by the symbol.
 397 The type of the symbol becomes
 398 external.  The statement can appear in any segment.
 399 If you think this has something to do with FORTRAN, you are right.
 400 .SS "Examples"
 401 .PP
 402 In the kernel directory, there are several assembly code files that are
 403 worth inspecting as examples.
 404 However, note that these files, are designed to first be
 405 run through the C preprocessor.  (The very first character is a # to signal
 406 this.)  Thus they contain numerous constructs
 407 that are not pure assembler.
 408 For true assembler examples, compile any C program provided with
 409 .MX
 410 using the \fB\(enS\fR flag.
 411 This will result in an assembly language file with a suffix with the same
 412 name as the C source file, but ending with the .s suffix.