flat assembler
Message board for the users of flat assembler.
 Home   FAQ   Search   Register 
 Profile   Log in to check your private messages   Log in 
flat assembler > Programming Language Design > [FASMG] Writing Intel Instructions

Author
Thread Post new topic Reply to topic
codestar



Joined: 25 Dec 2014
Posts: 254
[FASMG] Writing Intel Instructions
Is Register?

Code:
;;;;;;;;;;;;;;;;;;; REGISTERS ;;;;;;;;;;;;;;;;;;;;

numeric alcldlblahchdhbh
numeric axcxdxbxspbpsidi
numeric eaxecxedxebxespebpesiedi

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

macro is_in isnamep&
  is=0
  irp qp
    match =nameq
      is=1
      its_index=%-1
      break
    end match
  end irp
end macro

macro is_r isname
  local n
  n=0
  is=0
  its_size=0
  its_half=0
  name_length namen
  if n=3
    is_in isnameeaxecxedxebx,\
      espebpesiedi
    if is
      is=4
    end if
  else if n=2
    is_in isnamealcldlbl
    if is
      is=1
      its_half='l'
    else
      is_in isnameahchdhbh
      if is
        is=1
        its_half='h'
      else
        is_in isnameaxcxdxbx,\
          spbpsidi
        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 1or s_bit)
end macro

macro get_type p&
  local is,\
    typesizeindex
  is=0
  type=0
  size=0
  index=0
  match [m], p
    type='m'
  else match t[m], p
    type='m'
    get_size_t sizet
  else match namep
    is_r isname
    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 typesizeindexp&
  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+dp
    redefine the_mode '+*+'
    redefine the_base a
    redefine the_index b
    redefine the_scale c
    redefine the_number d
  else match a+b*cp
    redefine the_base a
    redefine the_index b
    redefine the_scale c
    is_r isa
    if is
      redefine the_mode '+*'
    else
      redefine the_mode '&+*'
    end if
  else match a+bp
    redefine the_base a
    redefine the_index b
    is_r isb
    if is
      redefine the_mode '+r'
    else
      redefine the_mode '+i'
    end if
  else match a-bp
    redefine the_mode '-i'
    redefine the_base a
    redefine the_index b
  else match a*bp
    redefine the_mode '*'
    redefine the_base a
    redefine the_scale b
  else match namep
    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 ist
    its_size=is
  else match namep ; '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 abc
  db ((a shl 6or (b shl 3or 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 nmode
  n=0
  mode=0
  if the_mode='rm'
    if the_base<>ebp
      put_mode 00bathe_base
    else
      put_mode 01bathe_base
      db 0
    end if
  else if the_mode='im'
    put_mode 00ba101b
    dd the_base
  else if the_mode='+r'
    put_mode 00ba100b
    put_mode 00bthe_indexthe_base
  else if the_mode='+*'
    put_mode 00ba100b
    get_scale mode
    put_mode modethe_indexthe_base
  else if the_mode='&+*' ; = r*s+i
    put_mode 00ba100b
    get_scale mode
    put_mode modethe_index101b
    dd the_base
  else if the_mode='+*+'
    n=the_number
    if n>=-$80 & n<$80
      mode=01b
    else
      mode=10b
    end if
    put_mode modea100b
    get_scale mode
    put_mode modethe_indexthe_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 modeathe_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 ab,\
  type1size1index1,\
  type2size2index2
  get_type_x type1size1index1a
  get_type_x type2size2index2b
  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,$37aas,$3Fcbw,$98clc,$F8,\
  cld,$FCcli,$FAcmc,$F5cmpsb,$A6,\
  cmps,$A7cwd,$99daa,$27das,$2F,\
  hlt,$F4int3,$CClodsb,$AClods,$DC,\
  movsb,$A4movs,$A5popf,$9Dpushf,$9C,\
  sahf,$9Escasb,$AEscas,$AFstc,$F9,\
  std,$FDsti,$FBstosb,$AA,\
  stos,$ABxlat,$D7
  macro name
    db value
  end macro
end irp

irp <name,value>,\
  aso,$67lock,$F0oso,$66,\
  rep,$F3repne,$F2wait,$9B
  macro name p&
    db value
    match nextp
      next
    end match
  end macro
end irp

macro aam i:10
  db $D4i
end macro

macro aad i:10
  db $D5i
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,$70jno,$71jc,$72jb,$72,\
  jnae,$72jnc,$73jnb,$73jae,$73,\
  jz,$74je,$74jnz,$75jne,$75,\
  jna,$76jbe,$76ja,$77jnbe,$77,\
  js,$78jns,$79jp,$7Ajpe,$7A,\
  jnp,$7Bjpo,$7Bjl,$7Cjnge,$7C,\
  jnl,$7Djge,$7Djng,$7Ejle,$7E,\
  jg,$7Fjnle,$7F
  macro name i
    local n
    n=(i-$)
    if n<$80 & n>=-$80
      db opcode
      jxx i1
    else
      db $0F, (opcode+$10)
      jxx i4
    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 $6Ax
    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 xp
    push x
  end irp
end macro

macro pushr p&
  irp xp
    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 xp
    pop x
  end irp
end macro

macro popr p&
  irp xp
    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 ab
  local opcodei_sizeext,\
    type1type2size1size2,\
    index1index2
  d_bit=0
  s_bit=0
  opcode=0
  i_size=0
  get_operands ab,\
    type1size1index1,\
    type2size2index2
  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 11bab
  else if type1='r' & type2='i'
    put_code $C7
    put_mode 11b0a
    put_dx bi_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 bi_size
  end if
end macro

macro test_mov
  mov eaxecx
  mov edx$12345678
  mov ahcl
  mov cxbx
  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 signab
  local opcodei_sizeext,\
    type1type2size1size2,\
    index1index2
  d_bit=0
  s_bit=0
  i_size=0
  get_operands ab,\
    type1size1index1,\
    type2size2index2
  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 11bab
  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 ab
  movx 1ab
end macro

macro movzx ab
  movx 0ab
end macro

macro test_movx
  movzx espword [ecx+edx*4]
  movzx ediword [edx+ebx*8+$CAFEBABE]
  movzx eaxcx
  movsx ecxbyte [edi]
  movsx edxbyte [ebp+8]
  movsx ebxah
end macro

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

; lea rx,m ; oso 8D /r

macro lea rm
  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 opcodeab
  local i_sizeext,\
    type1type2size1size2,\
    index1index2
  d_bit=0
  s_bit=0
  i_size=0
  ext=((opcode shr 3and 111b)
  get_operands ab,\
    type1size1index1,\
    type2size2index2
  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 11bab
  else if type1='r' & type2='i'
    put_code $80
    put_mode 11bexta
    put_dx bi_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 bi_size
  end if
end macro

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

macro test_basic
  add eaxecx
  adc cldl
  sub dhbh
  sbb cxdx
  cmp bxdx
  and eaxesi
  or ecxedx
  xor espedi
  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 namep
  local typeopcodedigit
  type=0
  opcode=$40
  digit=0
  match =decname
    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 incp
end macro

macro dec p
  inc_dec decp
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 namep&
  local typeopcodedigit
  type=0
  opcode=$F6
  digit=3
  match =notname
    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 11bdigitp
  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 negx
end macro

macro not x
  neg_not notx
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)

0x4015CC50                     PUSH        EAX                
0x4015CD6A77                   PUSH        0x77               
0x4015CF6878563412             PUSH        0x12345678         
0x4015D4FF32                   PUSH        DWORD PTR [EDX]    
0x4015D6FF36                   PUSH        DWORD PTR [ESI]    
0x4015D8FF7500                 PUSH        DWORD PTR [EBP]    
0x4015DBFF3578563412           PUSH        DWORD PTR [0x12345678]
0x4015E1FF7708                 PUSH        DWORD PTR [EDI+0x8]
0x4015E4FFB7BEBAFECA           PUSH        DWORD PTR [EDI+0xCAFEBABE]
0x4015EAFF3411                 PUSH        DWORD PTR [ECX+EDX]
0x4015EDFF344E                 PUSH        DWORD PTR [ESI+ECX*2]
0x4015F0FF3491                 PUSH        DWORD PTR [ECX+EDX*4]
0x4015F3FF749177               PUSH        DWORD PTR [ECX+EDX*4+0x77]
0x4015F7FFB4D13412BEBA         PUSH        DWORD PTR [ECX+EDX*8+0xBABE1234]
0x4015FE59                     POP         ECX                
0x4015FF8F4708                 POP         DWORD PTR [EDI+0x8]
0x4016028F87BEBAFECA           POP         DWORD PTR [EDI+0xCAFEBABE]
0x4016088BC1                   MOV         EAX,ECX            
0x40160AC7C278563412           MOV         EDX,0x12345678     
0x4016108AE1                   MOV         AH,CL
0x401612668BCB                 MOV         CX,BX              
0x4016158B0F                   MOV         ECX,DWORD PTR [EDI]
0x4016178B5508                 MOV         EDX,DWORD PTR [EBP+0x8]
0x40161A8B5FE0                 MOV         EBX,DWORD PTR [EDI-0x20]
0x40161D8B2491                 MOV         ESP,DWORD PTR [ECX+EDX*4]
0x4016208BBCDABEBAFECA         MOV         EDI,DWORD PTR [EDX+EBX*8+0xCAFEBABE]
0x4016278B0E                   MOV         ECX,DWORD PTR [ESI]
0x4016298B5500                 MOV         EDX,DWORD PTR [EBP]
0x40162C8B3D78563412           MOV         EDI,DWORD PTR [0x12345678]
0x4016328B4708                 MOV         EAX,DWORD PTR [EDI+0x8]
0x4016358B8FBEBAFECA           MOV         ECX,DWORD PTR [EDI+0xCAFEBABE]
0x40163B8B0411                 MOV         EAX,DWORD PTR [ECX+EDX]
0x40163E8B0C4E                 MOV         ECX,DWORD PTR [ESI+ECX*2]
0x4016418B1491                 MOV         EDX,DWORD PTR [ECX+EDX*4]
0x4016448B5C9177               MOV         EBX,DWORD PTR [ECX+EDX*4+0x77]
0x4016488BBCD13412BEBA         MOV         EDI,DWORD PTR [ECX+EDX*8+0xBABE1234]
0x40164F668B02                 MOV         AX,WORD PTR [EDX]  
0x401652668B1D78563412         MOV         BX,WORD PTR [0x12345678]
0x4016598AAF565555FF           MOV         CH,BYTE PTR [EDI-0xAAAAAA]
0x40165F8A84D13412BEBA         MOV         AL,BYTE PTR [ECX+EDX*8+0xBABE1234]
0x4016668821                   MOV         BYTE PTR [ECX],AH  
0x40166866890C11               MOV         WORD PTR [ECX+EDX],CX
0x40166C891C91                 MOV         DWORD PTR [ECX+EDX*4],EBX
0x40166FC600FF                 MOV         BYTE PTR [EAX],0xFF
0x40167266C70411FFFF           MOV         WORD PTR [ECX+EDX],0xFFFF
0x401678C704D13412CDAB         MOV         DWORD PTR [ECX+EDX*8],0xABCD1234
0x40167F8B0CFDBEBAFECA         MOV         ECX,DWORD PTR [0xCAFEBABE+EDI*8]
0x4016860FB72491               MOVZX       ESP,WORD PTR [ECX+EDX*4]
0x40168A0FB7BCDABEBAFECA       MOVZX       EDI,WORD PTR [EDX+EBX*8+0xCAFEBABE]
0x4016920FB7C1                 MOVZX       EAX,CX             
0x4016950FBE0F                 MOVSX       ECX,BYTE PTR [EDI
0x4016980FBE5508               MOVSX       EDX,BYTE PTR [EBP+0x8]
0x40169C0FBEDC                 MOVSX       EBX,AH             
0x40169F8D0F                   LEA         ECX,[EDI]          
0x4016A18D5508                 LEA         EDX,[EBP+0x8]      
0x4016A48D5FE0                 LEA         EBX,[EDI-0x20]     
0x4016A78D2491                 LEA         ESP,[ECX+EDX*4]    
0x4016AA8DBCDABEBAFECA         LEA         EDI,[EDX+EBX*8+0xCAFEBABE]
0x4016B1EB12                   JMP         0x4016C5           ; (*+0x14)  
0x4016B3E80D000000             CALL        0x4016C5           
0x4016B8740B                   JZ          0x4016C5           ; (*+0xD)  
0x4016BA7509                   JNZ         0x4016C5           ; (*+0xB)  
0x4016BCE804000000             CALL        0x4016C5           
0x4016C17D02                   JGE         0x4016C5           ; (*+0x4)  
0x4016C37300                   JAE         0x4016C5           ; (*+0x2)  
0x4016C5C3                     RET
0x4016C6C20800                 RET         0x8                
0x4016C9E8F7FFFFFF             CALL        0x4016C5           
0x4016CE40                     INC         EAX                
0x4016CFFF02                   INC         DWORD PTR [EDX]    
0x4016D1FE0578563412           INC         BYTE PTR [0x12345678]
0x4016D7FF048F                 INC         DWORD PTR [EDI+ECX*4]
0x4016DA4B                     DEC         EBX                
0x4016DBFE8880000000           DEC         BYTE PTR [EAX+0x80]
0x4016E166FF0F                 DEC         WORD PTR [EDI]     
0x4016E4FF0CCF                 DEC         DWORD PTR [EDI+ECX*8]
0x4016E7F7D8                   NEG         EAX                
0x4016E9F71A                   NEG         DWORD PTR [EDX]    
0x4016EBF61D78563412           NEG         BYTE PTR [0x12345678]
0x4016F1F71C8F                 NEG         DWORD PTR [EDI+ECX*4]
0x4016F4F7D3                   NOT         EBX                
0x4016F6F69080000000           NOT         BYTE PTR [EAX+0x80]
0x4016FC66F717                 NOT         WORD PTR [EDI]     
0x4016FFF714CF                 NOT         DWORD PTR [EDI+ECX*8]
0x401702D3E0                   SHL         EAX,CL             
0x401704D3EB                   SHR         EBX,CL             
0x401706D3C7                   ROL         EDI,CL             
0x401708C1EA18                 SHR         EDX,0x18           
0x40170BC13F04                 SAR         DWORD PTR [EDI],0x4
0x40170EC1C010                 ROL         EAX,0x10           
0x401711D30B                   ROR         DWORD PTR [EBX],CL 
0x401713D3A0BEBAFECA           SHL         DWORD PTR [EAX+0xCAFEBABE],CL
0x40171903C1                   ADD         EAX,ECX            
0x40171B12CA                   ADC         CL,DL              
0x40171D2AF7                   SUB         DH,BH              
0x40171F661BCA                 SBB         CX,DX              
0x401722663BDA                 CMP         BX,DX              
0x40172523C6                   AND         EAX,ESI            
0x4017270BCA                   OR          ECX,EDX            
0x40172933E7                   XOR         ESP,EDI            
0x40172B81C178563412           ADD         ECX,0x12345678     
0x40173181EA3412CDAB           SUB         EDX,0xABCD1234     
0x40173781D3BEBAFECA           ADC         EBX,0xCAFEBABE     
0x40173D6681D93412             SBB         CX,0x1234          
0x4017426681FACDAB             CMP         DX,0xABCD          
0x4017476681E3BEBA             AND         BX,0xBABE          
0x40174C80CC77                 OR          AH,0x77            
0x40174F80F177                 XOR         CL,0x77            
0x401752030E                   ADD         ECX,DWORD PTR [ESI]
0x401754135500                 ADC         EDX,DWORD PTR [EBP]
0x4017572B3D78563412           SUB         EDI,DWORD PTR [0x12345678]
0x40175D1B4708                 SBB         EAX,DWORD PTR [EDI+0x8]
0x4017603B8FBEBAFECA           CMP         ECX,DWORD PTR [EDI+0xCAFEBABE]
0x401766230411                 AND         EAX,DWORD PTR [ECX+EDX]
0x4017690B0C4E                 OR          ECX,DWORD PTR [ESI+ECX*2]
0x40176C331491                 XOR         EDX,DWORD PTR [ECX+EDX*4]
0x40176F035C9177               ADD         EBX,DWORD PTR [ECX+EDX*4+0x77]
0x40177313BCD13412BEBA         ADC         EDI,DWORD PTR [ECX+EDX*8+0xBABE1234]
0x40177A662B02                 SUB         AX,WORD PTR [EDX]  
0x40177D661B1D78563412         SBB         BX,WORD PTR [0x12345678]
0x4017843AAF565555FF           CMP         CH,BYTE PTR [EDI-0xAAAAAA]
0x40178A2284D13412BEBA         AND         AL,BYTE PTR [ECX+EDX*8+0xBABE1234]
0x4017910821                   OR          BYTE PTR [ECX],AH  
0x40179366310C11               XOR         WORD PTR [ECX+EDX],CX
0x401797011C91                 ADD         DWORD PTR [ECX+EDX*4],EBX
0x40179A8010FF                 ADC         BYTE PTR [EAX],0xFF
0x40179D66812C11FFFF           SUB         WORD PTR [ECX+EDX],0xFFFF
0x4017A3811CD13412CDAB         SBB         DWORD PTR [ECX+EDX*8],0xABCD1234
0x4017AA3B0CFDBEBAFECA         CMP         ECX,DWORD PTR [0xCAFEBABE+EDI*8]
0x4017B190                     NOP



Description: Macros, Example, Tests
Download
Filename: intelg.zip
Filesize: 11.86 KB
Downloaded: 58 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: 6676
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


Powered by phpBB © 2001-2005 phpBB Group.

Main index   Download   Documentation   Examples   Message board
Copyright © 2004-2016, Tomasz Grysztar.