flat assembler
Message board for the users of flat assembler.

flat assembler > Programming Language Design > [FASMG] Writing Intel Instructions

Author
Thread Post new topic Reply to topic
codestar



Joined: 25 Dec 2014
Posts: 254
Is Register?
Code:
;;;;;;;;;;;;;;;;;;; REGISTERS ;;;;;;;;;;;;;;;;;;;;

numeric al, cl, dl, bl, ah, ch, dh, bh
numeric ax, cx, dx, bx, sp, bp, si, di
numeric eax, ecx, edx, ebx, esp, ebp, esi, edi

its_type=0
its_size=0
its_index=0
its_half=0
its_mode=0

macro is_in is, name, p&
  is=0
  irp q, p
    match =name, q
      is=1
      its_index=%-1
      break
    end match
  end irp
end macro

macro is_r is, name
  local n
  n=0
  is=0
  its_size=0
  its_half=0
  name_length name, n
  if n=3
    is_in is, name, eax, ecx, edx, ebx,\
      esp, ebp, esi, edi
    if is
      is=4
    end if
  else if n=2
    is_in is, name, al, cl, dl, bl
    if is
      is=1
      its_half='l'
    else
      is_in is, name, ah, ch, dh, bh
      if is
        is=1
        its_half='h'
      else
        is_in is, name, ax, cx, dx, bx,\
          sp, bp, si, di
        if is
          is=2
        end if
      end if
    end if
  end if
  its_size=is
end macro    
Get Type, Mode, Operands
Code:
;;;;;;;;;;;;;; OPCODE, TYPE, OPERAND ;;;;;;;;;;;;;

d_bit=0
s_bit=0

macro put_code opcode
  db (opcode or (d_bit shl 1) or s_bit)
end macro

macro get_type p&
  local is,\
    type, size, index
  is=0
  type=0
  size=0
  index=0
  match [m], p
    type='m'
  else match t[m], p
    type='m'
    get_size_t size, t
  else match name, p
    is_r is, name
    if is
      type='r'
      size=its_size
      index=its_index
    else if name eqtype 0
      type='i'
    else
      err 'Unknown type'
    end if
  end match
  its_type=type
  its_size=size
  its_index=index
end macro

macro get_type_x type, size, index, p&
  get_type p
  type=its_type
  size=its_size
  index=its_index
end macro

;;;;;;;;;;;;;;;;;; OPERAND MODE ;;;;;;;;;;;;;;;;;;

; * 'i'   = 0-9, A-F   ; $1234ABCD
; * 'r'   = eax..edi   ; eax
; * 'rm'  = [eax..edi] ; [esi]
; * 'im'  = [#]        ; [$12345678]
; * '+r'  = [r+r]      ; [eax+ecx]
; * '+i'  = [r+i]      ; [ecx+$1234]
; * '-i'  = [r-i]      ; [ebp-16]
; * '*'   = [r*s]      ; [eax*4]
; * '&+*' = [i+r*s]    ; [$ABCD1234+eax*4]
; * '+*'  = [r+r*s]    ; [edi+ecx*4]
; * '+*+' = [r+r*s+i]  ; [edi+ecx*8+$BABE]

define the_mode 0
define the_base 0
define the_index 0
define the_scale 0
define the_number 0

macro get_mode_m p
  local is
  is=0
  match a+b*c+d, p
    redefine the_mode '+*+'
    redefine the_base a
    redefine the_index b
    redefine the_scale c
    redefine the_number d
  else match a+b*c, p
    redefine the_base a
    redefine the_index b
    redefine the_scale c
    is_r is, a
    if is
      redefine the_mode '+*'
    else
      redefine the_mode '&+*'
    end if
  else match a+b, p
    redefine the_base a
    redefine the_index b
    is_r is, b
    if is
      redefine the_mode '+r'
    else
      redefine the_mode '+i'
    end if
  else match a-b, p
    redefine the_mode '-i'
    redefine the_base a
    redefine the_index b
  else match a*b, p
    redefine the_mode '*'
    redefine the_base a
    redefine the_scale b
  else match name, p
    get_type name
    is=its_type
    redefine the_base name
    if is='r'
      redefine the_mode 'rm'
    else if is='i'
      redefine the_mode 'im'
    else
      err ''
    end if
  end match
end macro

macro get_mode p
  local is
  is=0
  redefine the_mode 0
  redefine the_base 0
  redefine the_index 0
  redefine the_scale 0
  redefine the_number 0
  match [m], p
    get_mode_m m
    its_size=0
  else match t[m], p
    get_mode_m m
    get_size_t is, t
    its_size=is
  else match name, p ; 'r', 'i', 'm'
    get_type name    ; (not [memory])
    is=its_type
    redefine the_mode is
    redefine the_base name
  end match
end macro

macro put_mode a, b, c
  db ((a shl 6) or (b shl 3) or c)
end macro

macro write_number n
  if n>=-$80 & n<$80
    db n
  else
    dd n
  end if
end macro

macro get_scale mode
  if the_scale=2
    mode=01b
  else if the_scale=4
    mode=10b
  else if the_scale=8
    mode=11b
  else
    err 'Invalid scale'
  end if
end macro

macro write_mode a
  local n, mode
  n=0
  mode=0
  if the_mode='rm'
    if the_base<>ebp
      put_mode 00b, a, the_base
    else
      put_mode 01b, a, the_base
      db 0
    end if
  else if the_mode='im'
    put_mode 00b, a, 101b
    dd the_base
  else if the_mode='+r'
    put_mode 00b, a, 100b
    put_mode 00b, the_index, the_base
  else if the_mode='+*'
    put_mode 00b, a, 100b
    get_scale mode
    put_mode mode, the_index, the_base
  else if the_mode='&+*' ; = r*s+i
    put_mode 00b, a, 100b
    get_scale mode
    put_mode mode, the_index, 101b
    dd the_base
  else if the_mode='+*+'
    n=the_number
    if n>=-$80 & n<$80
      mode=01b
    else
      mode=10b
    end if
    put_mode mode, a, 100b
    get_scale mode
    put_mode mode, the_index, the_base
    write_number n
  else if the_mode='+i' | the_mode='-i'
    n=the_index
    if the_mode='-i'
      n=-n
    end if
    if n>=-$80 & n<$80
      mode=01b
    else
      mode=10b
    end if
    put_mode mode, a, the_base
    write_number n
  else
    err 'Invalid mode'
  end if
end macro

macro display_mode p
  display '* ', `p, ': '
  get_mode p
  display 'Mode: ', the_mode
  if its_size
    display '. Size=', its_size+'0'
  end if
  display '. Base=', the_base+'0'
  if the_index
    display '. Index=', the_index+'0'
  end if
  if the_scale
    display '. Scale=', the_scale+'0'
  end if
  if the_number
    display '. Number=', the_number+'0'
  end if
  display RET
end macro

macro test_modes
  display RET
  display_mode ecx
  display_mode 8
  display_mode [edi]
  display_mode [8]
  display_mode [ecx+edx]
  display_mode [ebp+8]
  display_mode [ecx-4]
  display_mode [ebx*4]
  display_mode [edi*2+8]
  display_mode [ecx+edx*4]
  display_mode [edi+ebx*4+8]
end macro

macro get_operands a, b,\
  type1, size1, index1,\
  type2, size2, index2
  get_type_x type1, size1, index1, a
  get_type_x type2, size2, index2, b
  if size1 & size2 & size1<>size2
    ; err 'Operands must be same size'
  end if
  if type1='m' & size1=0
    if type2='i'
      err 'Size must be specified'
    end if
    size1=size2
  end if
end macro    
Easy Instructions, Prefixes
Code:
;;;;;;;;;;;;;;;;; INSTRUCTIONS ;;;;;;;;;;;;;;;;;;;

irp <name,value>,\
  aaa,$37, aas,$3F, cbw,$98, clc,$F8,\
  cld,$FC, cli,$FA, cmc,$F5, cmpsb,$A6,\
  cmps,$A7, cwd,$99, daa,$27, das,$2F,\
  hlt,$F4, int3,$CC, lodsb,$AC, lods,$DC,\
  movsb,$A4, movs,$A5, popf,$9D, pushf,$9C,\
  sahf,$9E, scasb,$AE, scas,$AF, stc,$F9,\
  std,$FD, sti,$FB, stosb,$AA,\
  stos,$AB, xlat,$D7
  macro name
    db value
  end macro
end irp

irp <name,value>,\
  aso,$67, lock,$F0, oso,$66,\
  rep,$F3, repne,$F2, wait,$9B
  macro name p&
    db value
    match next, p
      next
    end match
  end macro
end irp

macro aam i:10
  db $D4, i
end macro

macro aad i:10
  db $D5, i
end macro

macro nop n
  match , n
    db $90
  else
    repeat n
      db $90
    end repeat
  end match
end macro    
Branch: JMP, JXX
Code:
;;;;;;;;;;;;;;;;;;;;; BRANCH ;;;;;;;;;;;;;;;;;;;;;

; jcc i8 ; 70+cc i8
; jcc ix ; 0F 80+cc ix

irp <name,opcode>,\
  jo,$70, jno,$71, jc,$72, jb,$72,\
  jnae,$72, jnc,$73, jnb,$73, jae,$73,\
  jz,$74, je,$74, jnz,$75, jne,$75,\
  jna,$76, jbe,$76, ja,$77, jnbe,$77,\
  js,$78, jns,$79, jp,$7A, jpe,$7A,\
  jnp,$7B, jpo,$7B, jl,$7C, jnge,$7C,\
  jnl,$7D, jge,$7D, jng,$7E, jle,$7E,\
  jg,$7F, jnle,$7F
  macro name i
    local n
    n=(i-$)
    if n<$80 & n>=-$80
      db opcode
      jxx i, 1
    else
      db $0F, (opcode+$10)
      jxx i, 4
    end if
  end macro
end irp    
Push, Pop
Code:
;;;;;;;;;;;;;;;;;;;; PUSH, POP ;;;;;;;;;;;;;;;;;;;

; push rx  ; oso 50+r
; push rmx ; oso FF /6
; push i8  ; 6A ib
; push ix  ; oso 68 ix
; pop rx   ; oso 58+r
; pop rmx  ; oso 8F /0

macro push x
  local type
  type=0
  get_type x
  type=its_type
  if type='r'
    db $50+x
  else if type='i'
    if x<$80 & x>=-$80
      db $6A, x
    else
      db $68
      dd x
    end if
  else if type='m'
    db $FF
    get_mode x
    write_mode 6
  end if
end macro

macro push p&
  irp x, p
    push x
  end irp
end macro

macro pushr p&
  irp x, p
    indx (1+%%-%)
    push x
  end irp
end macro

macro pop x
  local type
  type=0
  get_type x
  type=its_type
  if type='r'
    db $58+x
  else if type='m'
    db $8F
    get_mode x
    write_mode 0
  else
    err 'Invalid operand'
  end if
end macro

macro pop p&
  irp x, p
    pop x
  end irp
end macro

macro popr p&
  irp x, p
    indx (1+%%-%)
    pop x
  end irp
end macro

macro test_push_pop
  push eax
  push $77
  push $12345678
  push [edx]
  push [esi]
  push [ebp]
  push [$12345678]
  push [edi+8]
  push [edi+$CAFEBABE]
  push [ecx+edx]
  push [esi+ecx*2]
  push [ecx+edx*4]
  push [ecx+edx*4+$77]
  push [ecx+edx*8+$BABE1234]
  pop ecx
  pop [edi+8]
  pop [edi+$CAFEBABE]
end macro    
Movement: MOV, MOVSX, MOVZX, LEA
Code:
;;;;;;;;;;;;;;;;;;;; MOVEMENT ;;;;;;;;;;;;;;;;;;;;

; mov rm8,r8 ; 88 /r
; mov rmx,rx ; oso 89 /r
; mov r8,rm8 ; 8A /r
; mov rx,rmx ; oso 8B /r
; mov r8,i8  ; B0+r ib
; mov rx,ix  ; oso B8+r ix
; mov rm8,i8 ; C6 /0 ib
; mov rmx,ix ; oso C7 /0 ix

macro mov a, b
  local opcode, i_size, ext,\
    type1, type2, size1, size2,\
    index1, index2
  d_bit=0
  s_bit=0
  opcode=0
  i_size=0
  get_operands a, b,\
    type1, size1, index1,\
    type2, size2, index2
  i_size=size1
  if size1=2 | size2=2
    oso
  end if
  if size1>=2
    s_bit=1
  end if
  if type1='r' & type2='r'
    d_bit=1
    opcode=$88
    put_code opcode
    put_mode 11b, a, b
  else if type1='r' & type2='i'
    put_code $C7
    put_mode 11b, 0, a
    put_dx b, i_size
  else if type1='r' & type2='m'
    d_bit=1
    opcode=$8A
    put_code opcode
    get_mode b
    write_mode a
  else if type1='m' & type2='r'
    opcode=$88
    put_code opcode
    get_mode a
    write_mode b
  else if type1='m' & type2='i'
    put_code $C6
    get_mode a
    write_mode 0
    put_dx b, i_size
  end if
end macro

macro test_mov
  mov eax, ecx
  mov edx, $12345678
  mov ah, cl
  mov cx, bx
  mov ecx, [edi]
  mov edx, [ebp+8]
  mov ebx, [edi-32]
  mov esp, [ecx+edx*4]
  mov edi, [edx+ebx*8+$CAFEBABE]
  mov ecx, [esi]
  mov edx, [ebp]
  mov edi, [$12345678]
  mov eax, [edi+8]
  mov ecx, [edi+$CAFEBABE]
  mov eax, [ecx+edx]
  mov ecx, [esi+ecx*2]
  mov edx, [ecx+edx*4]
  mov ebx, [ecx+edx*4+$77]
  mov edi, [ecx+edx*8+$BABE1234]
  mov ax, [edx]
  mov bx, [$12345678]
  mov ch, [edi-$AAAAAA]
  mov al, [ecx+edx*8+$BABE1234]
  mov [ecx], ah
  mov [ecx+edx], cx
  mov [ecx+edx*4], ebx
  mov byte [eax], $FF
  mov word [ecx+edx], $FFFF
  mov dword [ecx+edx*8], $ABCD1234
  mov ecx, [$CAFEBABE+edi*8]
end macro

;;;;;;;;;;;;;;;;;; MOVZX, MOVSX ;;;;;;;;;;;;;;;;;;

; movzx r32,rm8  ; oso 0F B6 /r
; movzx r32,rm16 ; oso 0F B7 /r
; movsx r32,rm8  ; oso 0F BE /r
; movsx r32,rm16 ; oso 0F BF /r

macro movx sign, a, b
  local opcode, i_size, ext,\
    type1, type2, size1, size2,\
    index1, index2
  d_bit=0
  s_bit=0
  i_size=0
  get_operands a, b,\
    type1, size1, index1,\
    type2, size2, index2
  i_size=size1
  if size2=2
    s_bit=1
  end if
  db $0F
  opcode=$B6
  if sign=1
    opcode=$BE
  end if
  if type1='r' & type2='r'
    d_bit=1
    put_code opcode
    put_mode 11b, a, b
  else if type1='r' & type2='m'
    d_bit=1
    put_code opcode
    get_mode b
    write_mode a
  else
    err 'Invalid operands'
  end if
end macro

macro movsx a, b
  movx 1, a, b
end macro

macro movzx a, b
  movx 0, a, b
end macro

macro test_movx
  movzx esp, word [ecx+edx*4]
  movzx edi, word [edx+ebx*8+$CAFEBABE]
  movzx eax, cx
  movsx ecx, byte [edi]
  movsx edx, byte [ebp+8]
  movsx ebx, ah
end macro

;;;;;;;;;;;;;;;;;;;;;; LEA ;;;;;;;;;;;;;;;;;;;;;;;

; lea rx,m ; oso 8D /r

macro lea r, m
  db $8D
  get_mode m
  write_mode r
end macro

macro test_lea
  lea ecx, [edi]
  lea edx, [ebp+8]
  lea ebx, [edi-32]
  lea esp, [ecx+edx*4]
  lea edi, [edx+ebx*8+$CAFEBABE]
end macro    
Basic Instructions: ADD, SUB, CMP, etc.
Code:
;;;;;;;;; BASIC: ADD, SUB, CMP, XOR, ETC ;;;;;;;;;

; opcode rm8,r8 ; 30 /r
; opcode rmx,rx ; oso 31 /r
; opcode r8,rm8 ; 32 /r
; opcode rx,rmx ; oso 33 /r
; opcode rm8,i8 ; 80 /6 ib
; opcode rmx,ix ; oso 81 /6 ix
; opcode rmx,i8 ; oso 83 /6 ib
; opcode al,i8  ; 34 ib
; opcode eax,ix ; oso 35 ix

macro write_basic opcode, a, b
  local i_size, ext,\
    type1, type2, size1, size2,\
    index1, index2
  d_bit=0
  s_bit=0
  i_size=0
  ext=((opcode shr 3) and 111b)
  get_operands a, b,\
    type1, size1, index1,\
    type2, size2, index2
  i_size=size1
  if size1=2 | size2=2
    oso
  end if
  if size1>=2
    s_bit=1
  end if
  if type1='r' & type2='r'
    d_bit=1
    put_code opcode
    put_mode 11b, a, b
  else if type1='r' & type2='i'
    put_code $80
    put_mode 11b, ext, a
    put_dx b, i_size
  else if type1='r' & type2='m'
    d_bit=1
    put_code opcode
    get_mode b
    write_mode a
  else if type1='m' & type2='r'
    put_code opcode
    get_mode a
    write_mode b
  else if type1='m' & type2='i'
    put_code $80
    get_mode a
    write_mode ext
    put_dx b, i_size
  end if
end macro

irp <name, opcode>,\
  adc,$10, add,0, and,$20, cmp,$38,\
  or,$8, sbb,$18, sub,$28, xor,$30
  macro name a, b
    write_basic opcode, a, b
  end macro
end irp

macro test_basic
  add eax, ecx
  adc cl, dl
  sub dh, bh
  sbb cx, dx
  cmp bx, dx
  and eax, esi
  or ecx, edx
  xor esp, edi
  add ecx, $12345678
  sub edx, $ABCD1234
  adc ebx, $CAFEBABE
  sbb cx, $1234
  cmp dx, $ABCD
  and bx, $BABE
  or ah, $77
  xor cl, $77
  add ecx, [esi]
  adc edx, [ebp]
  sub edi, [$12345678]
  sbb eax, [edi+8]
  cmp ecx, [edi+$CAFEBABE]
  and eax, [ecx+edx]
  or ecx, [esi+ecx*2]
  xor edx, [ecx+edx*4]
  add ebx, [ecx+edx*4+$77]
  adc edi, [ecx+edx*8+$BABE1234]
  sub ax, [edx]
  sbb bx, [$12345678]
  cmp ch, [edi-$AAAAAA]
  and al, [ecx+edx*8+$BABE1234]
  or [ecx], ah
  xor [ecx+edx], cx
  add [ecx+edx*4], ebx
  adc byte [eax], $FF
  sub word [ecx+edx], $FFFF
  sbb dword [ecx+edx*8], $ABCD1234
  cmp ecx, [$CAFEBABE+edi*8]
end macro    
Simple Instructions: INC, DEC, NEG, NOT
Code:
;;;;;;;;;;;;;;;;;;;; INC, DEC ;;;;;;;;;;;;;;;;;;;;

; inc rx  ; oso 40+r
; inc rm8 ; FE /0
; inc rmx ; oso FF /0
; dec rx  ; oso 48+r
; dec rm8 ; FE /1
; dec rmx ; oso FF /1

macro inc_dec name, p
  local type, opcode, digit
  type=0
  opcode=$40
  digit=0
  match =dec, name
    opcode=$48
    digit=1
  end match
  get_type p
  type=its_type
  if its_size=0
    err 'Size must be specified'
  end if
  if its_size=2
    oso
  end if
  s_bit=0
  if its_size>=2
    s_bit=1
  end if
  if type='r'
    db opcode+p
  else if type='m'
    db $FE or s_bit
    get_mode p
    write_mode digit
  else
    err 'Invalid operand'
  end if
end macro

macro inc p
  inc_dec inc, p
end macro

macro dec p
  inc_dec dec, p
end macro

macro test_inc_dec
  inc eax
  inc dword [edx]
  inc byte [$12345678]
  inc dword [edi+ecx*4]
  dec ebx
  dec byte [eax+$80]
  dec word [edi]
  dec dword [edi+ecx*8]
end macro

;;;;;;;;;;;;;;;;;; NEGATE, NOT ;;;;;;;;;;;;;;;;;;;

; neg rm8 ; F6 /3
; neg rmx ; oso F7 /3
; not rm8 ; F6 /2
; not rmx ; oso F7 /2

macro neg_not name, p&
  local type, opcode, digit
  type=0
  opcode=$F6
  digit=3
  match =not, name
    digit=2
  end match
  get_type p
  type=its_type
  if its_size=0
    err 'Size must be specified'
  end if
  if its_size=2
    oso
  end if
  s_bit=0
  if its_size>=2
    s_bit=1
  end if
  if type='r'
    db opcode or s_bit
    put_mode 11b, digit, p
  else if type='m'
    db opcode or s_bit
    get_mode p
    write_mode digit
  else
    err 'Invalid operand'
  end if
end macro

macro neg x
  neg_not neg, x
end macro

macro not x
  neg_not not, x
end macro

macro test_neg_not
  neg eax
  neg dword [edx]
  neg byte [$12345678]
  neg dword [edi+ecx*4]
  not ebx
  not byte [eax+$80]
  not word [edi]
  not dword [edi+ecx*8]
end macro    
Test Intel Instructions:
Code:
DISASSEMBLY OF EXAMPLE.EXE TEST
(PE BROWSE PRO DISASSEMBLER)

EXAMPLE.EXE Section .one (0x00401000)

0x4015CC: 50                     PUSH        EAX                
0x4015CD: 6A77                   PUSH        0x77               
0x4015CF: 6878563412             PUSH        0x12345678         
0x4015D4: FF32                   PUSH        DWORD PTR [EDX]    
0x4015D6: FF36                   PUSH        DWORD PTR [ESI]    
0x4015D8: FF7500                 PUSH        DWORD PTR [EBP]    
0x4015DB: FF3578563412           PUSH        DWORD PTR [0x12345678]
0x4015E1: FF7708                 PUSH        DWORD PTR [EDI+0x8]
0x4015E4: FFB7BEBAFECA           PUSH        DWORD PTR [EDI+0xCAFEBABE]
0x4015EA: FF3411                 PUSH        DWORD PTR [ECX+EDX]
0x4015ED: FF344E                 PUSH        DWORD PTR [ESI+ECX*2]
0x4015F0: FF3491                 PUSH        DWORD PTR [ECX+EDX*4]
0x4015F3: FF749177               PUSH        DWORD PTR [ECX+EDX*4+0x77]
0x4015F7: FFB4D13412BEBA         PUSH        DWORD PTR [ECX+EDX*8+0xBABE1234]
0x4015FE: 59                     POP         ECX                
0x4015FF: 8F4708                 POP         DWORD PTR [EDI+0x8]
0x401602: 8F87BEBAFECA           POP         DWORD PTR [EDI+0xCAFEBABE]
0x401608: 8BC1                   MOV         EAX,ECX            
0x40160A: C7C278563412           MOV         EDX,0x12345678     
0x401610: 8AE1                   MOV         AH,CL
0x401612: 668BCB                 MOV         CX,BX              
0x401615: 8B0F                   MOV         ECX,DWORD PTR [EDI]
0x401617: 8B5508                 MOV         EDX,DWORD PTR [EBP+0x8]
0x40161A: 8B5FE0                 MOV         EBX,DWORD PTR [EDI-0x20]
0x40161D: 8B2491                 MOV         ESP,DWORD PTR [ECX+EDX*4]
0x401620: 8BBCDABEBAFECA         MOV         EDI,DWORD PTR [EDX+EBX*8+0xCAFEBABE]
0x401627: 8B0E                   MOV         ECX,DWORD PTR [ESI]
0x401629: 8B5500                 MOV         EDX,DWORD PTR [EBP]
0x40162C: 8B3D78563412           MOV         EDI,DWORD PTR [0x12345678]
0x401632: 8B4708                 MOV         EAX,DWORD PTR [EDI+0x8]
0x401635: 8B8FBEBAFECA           MOV         ECX,DWORD PTR [EDI+0xCAFEBABE]
0x40163B: 8B0411                 MOV         EAX,DWORD PTR [ECX+EDX]
0x40163E: 8B0C4E                 MOV         ECX,DWORD PTR [ESI+ECX*2]
0x401641: 8B1491                 MOV         EDX,DWORD PTR [ECX+EDX*4]
0x401644: 8B5C9177               MOV         EBX,DWORD PTR [ECX+EDX*4+0x77]
0x401648: 8BBCD13412BEBA         MOV         EDI,DWORD PTR [ECX+EDX*8+0xBABE1234]
0x40164F: 668B02                 MOV         AX,WORD PTR [EDX]  
0x401652: 668B1D78563412         MOV         BX,WORD PTR [0x12345678]
0x401659: 8AAF565555FF           MOV         CH,BYTE PTR [EDI-0xAAAAAA]
0x40165F: 8A84D13412BEBA         MOV         AL,BYTE PTR [ECX+EDX*8+0xBABE1234]
0x401666: 8821                   MOV         BYTE PTR [ECX],AH  
0x401668: 66890C11               MOV         WORD PTR [ECX+EDX],CX
0x40166C: 891C91                 MOV         DWORD PTR [ECX+EDX*4],EBX
0x40166F: C600FF                 MOV         BYTE PTR [EAX],0xFF
0x401672: 66C70411FFFF           MOV         WORD PTR [ECX+EDX],0xFFFF
0x401678: C704D13412CDAB         MOV         DWORD PTR [ECX+EDX*8],0xABCD1234
0x40167F: 8B0CFDBEBAFECA         MOV         ECX,DWORD PTR [0xCAFEBABE+EDI*8]
0x401686: 0FB72491               MOVZX       ESP,WORD PTR [ECX+EDX*4]
0x40168A: 0FB7BCDABEBAFECA       MOVZX       EDI,WORD PTR [EDX+EBX*8+0xCAFEBABE]
0x401692: 0FB7C1                 MOVZX       EAX,CX             
0x401695: 0FBE0F                 MOVSX       ECX,BYTE PTR [EDI] 
0x401698: 0FBE5508               MOVSX       EDX,BYTE PTR [EBP+0x8]
0x40169C: 0FBEDC                 MOVSX       EBX,AH             
0x40169F: 8D0F                   LEA         ECX,[EDI]          
0x4016A1: 8D5508                 LEA         EDX,[EBP+0x8]      
0x4016A4: 8D5FE0                 LEA         EBX,[EDI-0x20]     
0x4016A7: 8D2491                 LEA         ESP,[ECX+EDX*4]    
0x4016AA: 8DBCDABEBAFECA         LEA         EDI,[EDX+EBX*8+0xCAFEBABE]
0x4016B1: EB12                   JMP         0x4016C5           ; (*+0x14)  
0x4016B3: E80D000000             CALL        0x4016C5           
0x4016B8: 740B                   JZ          0x4016C5           ; (*+0xD)  
0x4016BA: 7509                   JNZ         0x4016C5           ; (*+0xB)  
0x4016BC: E804000000             CALL        0x4016C5           
0x4016C1: 7D02                   JGE         0x4016C5           ; (*+0x4)  
0x4016C3: 7300                   JAE         0x4016C5           ; (*+0x2)  
0x4016C5: C3                     RET
0x4016C6: C20800                 RET         0x8                
0x4016C9: E8F7FFFFFF             CALL        0x4016C5           
0x4016CE: 40                     INC         EAX                
0x4016CF: FF02                   INC         DWORD PTR [EDX]    
0x4016D1: FE0578563412           INC         BYTE PTR [0x12345678]
0x4016D7: FF048F                 INC         DWORD PTR [EDI+ECX*4]
0x4016DA: 4B                     DEC         EBX                
0x4016DB: FE8880000000           DEC         BYTE PTR [EAX+0x80]
0x4016E1: 66FF0F                 DEC         WORD PTR [EDI]     
0x4016E4: FF0CCF                 DEC         DWORD PTR [EDI+ECX*8]
0x4016E7: F7D8                   NEG         EAX                
0x4016E9: F71A                   NEG         DWORD PTR [EDX]    
0x4016EB: F61D78563412           NEG         BYTE PTR [0x12345678]
0x4016F1: F71C8F                 NEG         DWORD PTR [EDI+ECX*4]
0x4016F4: F7D3                   NOT         EBX                
0x4016F6: F69080000000           NOT         BYTE PTR [EAX+0x80]
0x4016FC: 66F717                 NOT         WORD PTR [EDI]     
0x4016FF: F714CF                 NOT         DWORD PTR [EDI+ECX*8]
0x401702: D3E0                   SHL         EAX,CL             
0x401704: D3EB                   SHR         EBX,CL             
0x401706: D3C7                   ROL         EDI,CL             
0x401708: C1EA18                 SHR         EDX,0x18           
0x40170B: C13F04                 SAR         DWORD PTR [EDI],0x4
0x40170E: C1C010                 ROL         EAX,0x10           
0x401711: D30B                   ROR         DWORD PTR [EBX],CL 
0x401713: D3A0BEBAFECA           SHL         DWORD PTR [EAX+0xCAFEBABE],CL
0x401719: 03C1                   ADD         EAX,ECX            
0x40171B: 12CA                   ADC         CL,DL              
0x40171D: 2AF7                   SUB         DH,BH              
0x40171F: 661BCA                 SBB         CX,DX              
0x401722: 663BDA                 CMP         BX,DX              
0x401725: 23C6                   AND         EAX,ESI            
0x401727: 0BCA                   OR          ECX,EDX            
0x401729: 33E7                   XOR         ESP,EDI            
0x40172B: 81C178563412           ADD         ECX,0x12345678     
0x401731: 81EA3412CDAB           SUB         EDX,0xABCD1234     
0x401737: 81D3BEBAFECA           ADC         EBX,0xCAFEBABE     
0x40173D: 6681D93412             SBB         CX,0x1234          
0x401742: 6681FACDAB             CMP         DX,0xABCD          
0x401747: 6681E3BEBA             AND         BX,0xBABE          
0x40174C: 80CC77                 OR          AH,0x77            
0x40174F: 80F177                 XOR         CL,0x77            
0x401752: 030E                   ADD         ECX,DWORD PTR [ESI]
0x401754: 135500                 ADC         EDX,DWORD PTR [EBP]
0x401757: 2B3D78563412           SUB         EDI,DWORD PTR [0x12345678]
0x40175D: 1B4708                 SBB         EAX,DWORD PTR [EDI+0x8]
0x401760: 3B8FBEBAFECA           CMP         ECX,DWORD PTR [EDI+0xCAFEBABE]
0x401766: 230411                 AND         EAX,DWORD PTR [ECX+EDX]
0x401769: 0B0C4E                 OR          ECX,DWORD PTR [ESI+ECX*2]
0x40176C: 331491                 XOR         EDX,DWORD PTR [ECX+EDX*4]
0x40176F: 035C9177               ADD         EBX,DWORD PTR [ECX+EDX*4+0x77]
0x401773: 13BCD13412BEBA         ADC         EDI,DWORD PTR [ECX+EDX*8+0xBABE1234]
0x40177A: 662B02                 SUB         AX,WORD PTR [EDX]  
0x40177D: 661B1D78563412         SBB         BX,WORD PTR [0x12345678]
0x401784: 3AAF565555FF           CMP         CH,BYTE PTR [EDI-0xAAAAAA]
0x40178A: 2284D13412BEBA         AND         AL,BYTE PTR [ECX+EDX*8+0xBABE1234]
0x401791: 0821                   OR          BYTE PTR [ECX],AH  
0x401793: 66310C11               XOR         WORD PTR [ECX+EDX],CX
0x401797: 011C91                 ADD         DWORD PTR [ECX+EDX*4],EBX
0x40179A: 8010FF                 ADC         BYTE PTR [EAX],0xFF
0x40179D: 66812C11FFFF           SUB         WORD PTR [ECX+EDX],0xFFFF
0x4017A3: 811CD13412CDAB         SBB         DWORD PTR [ECX+EDX*8],0xABCD1234
0x4017AA: 3B0CFDBEBAFECA         CMP         ECX,DWORD PTR [0xCAFEBABE+EDI*8]
0x4017B1: 90                     NOP    


Description: Macros, Example, Tests
Download
Filename: intelg.zip
Filesize: 11.86 KB
Downloaded: 103 Time(s)

Post 21 May 2015, 07:23
View user's profile Send private message Reply with quote
Tomasz Grysztar
Assembly Artist


Joined: 16 Jun 2003
Posts: 6927
Location: Kraków, Poland
Please try it with the ELEMENT directive (like the 8086 macros I provided as an example), it would allow you to process complex register expressions (for instance "(eax+ebx+1)*2-eax") like fasm 1 does. The use of ELEMENT also allows to process address expressions with register-based labels, also like fasm 1:
Code:
include '8086.inc' ; use my 8086 example macros from "fasm g" package

virtual at bx
  data1 db ?
  data2 db ?
  data3 dw ?
end virtual

        mov     ax,[data3]      ; mov ax,[bx+2]    
And the unified way of processing the ELEMENT-based expressions even allows to do things that were not possible with fasm 1:
Code:
        mov     ax,data1        ; mov ax,bx    

PS I have just discovered I have a bug in my example macros that causes the non-zero displacement added to register operand to be ignored while it should cause an error. I will try to correct it soon. [EDIT] I updated the "fasm g" package with this minor correction. Still no other work on this project, though. [/EDIT]
Post 21 May 2015, 11:44
View user's profile Send private message Visit poster's website Reply with quote
Display posts from previous:
Post new topic Reply to topic

Jump to:  


< Last Thread | Next Thread >
Forum Rules:
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
You cannot attach files in this forum
You can download files in this forum


Copyright © 1999-2018, Tomasz Grysztar.

Powered by rwasa.