Pointer Arithmetic: *EDI++=*ESI--

Pointer Arithmetic for X86. 32BIT registers only. Alters EBX if M,M.

Example:

Code:

. (i32) *p++=*s++

Output:

Code:

mov ebx,dword [esi] ; X86
add esi,4
mov dword [edi],ebx
add edi,4

ldr r12, [r6], 4      ; ARM
str r12, [r7], 4

move.l (a6)+, (a7)+ ; M68K

Example:

Code:

format pe gui
int3  ; disassemble

include 'pointer.inc'

alias \
 a=eax, c=ecx, p=edi, s=esi

. (i32) a=*s++
. (i32) *p++=c
. (i8) *p--=*s--
. (i16) *p++=c
. (i32) *a++=12345678h

nop

Output:

Code:

00401000 int   3
00401001 mov   eax,dword [esi]
00401003 add   esi,4
00401006 mov   dword [edi],ecx
00401008 add   edi,4
0040100B movsx ebx,byte [esi]
0040100E sub   esi,1
00401011 mov   byte [edi],bl
00401013 sub   edi,1
00401016 mov   word [edi],cx
00401019 add   edi,2
0040101C mov   dword [eax],12345678h
00401022 add   eax,4
00401025 nop

Advantages of register pointers:

* Portability
* Standard address/value syntax: & and *. Resembles C/C++ and 68K ASM.
* Superior optimizations on other CPUs such as ARM that can load/store then add/subtract pointers in one instruction.
* For readability, create alias names for registers. See Magic-ARM Compiler (latest), especially TEXT and DRAW.

POINTER.INC

Code:

;;;;;;;;;;;;;;;;;; POINTER.INC ;;;;;;;;;;;;;;;;;;;

is.i? fix eqtype 0   ; immediate?

is.m? fix eqtype [0] ; memory?

is.r32? fix in \     ; register?
 <eax,ecx,edx,ebx,\
 esp,ebp,esi,edi>
is.r16? fix in <ax,cx,dx,bx>
is.r8? fix in \
 <al,ah,cl,ch,dl,dh,bl,bh>
is.r8l? fix in <al,cl,dl,bl>
is.r8h? fix in <ah,ch,dh,bh>

is.r? fix in \       ; any?
 <eax,ecx,edx,ebx,\
 esp,ebp,esi,edi,\
 ax,cx,dx,bx,\
 al,ah,cl,ch,dl,dh,bl,bh>

macro verify.r a {
 if ~a is.r32?
  'Register expected:' a
 end if
}

macro verify a {
 if ?s eq 0
  'Syntax error:' a
 end if
}

;;;;;;;;;;;;;;;;;; GET SIZE/SIGN ;;;;;;;;;;;;;;;;;

; from t=type name, return s=size and
; i=sign in numeric constants. example:

; size=0
; sign=0
; @gets i32, size, sign ; s=32, i=1

macro @gets t, s, i {
 s=0
 i=0
 if t eq u32 | t eq i32 | t eq dword
  s=32
 else if t eq u16 | t eq i16 | t eq word
  s=16
 else if t eq u8 | t eq i8 | t eq byte
  s=8
 else
  'Unknown type'
 end if
 if t eq i32 | t eq i16 | t eq i8
  i=1
 end if
}

;;;;;;;;;;;;;;;;;; GET/SET VALUE ;;;;;;;;;;;;;;;;;

; helper load/store...

; t=type, r=register, v=value,
; s=size, i=sign

macro @gv t, r, v, s, i {
 if s=32
  mov r, v
 else if s=8
  if i=1
   movsx r, byte v
  else
   movzx r, byte v
  end if
 else if s=16
  if i=1
   movsx r, word v
  else
   movzx r, word v
  end if
 end if
}

macro @get t, r, [v] {
 common
  local s, i              ; get size
  @gets t, s, i           ; and sign
  define ?s 0
  match *a, v \{          ; *p
   match x++, a \\{       ; *p++
    ?a equ x
    ?o equ add
    define ?s 1
   \\}
   match =0 \
    x--, ?s a \\{         ; *p--
    ?a equ x
    ?o equ sub
    define ?s 1
   \\}
   match =0 x, ?s a \\{   ; else, *p
    ?a equ x
    ?o equ                ; no advance
    define ?s 1
   \\}
   if ~ ?a is.r?
    'Error'
   end if
   @gv t, r, [?a], s, i
   if ~ ?o eq             ; advance?
     ?o ?a, s/8           ; add/sub n
   end if
   verify
  \}
  match =0 a, ?s v \{     ; r
   @gv t, r, a, s, i
   define ?s 1
  \}
  verify
  restore ?a, ?o
}

; t=type, r=register, v=value

macro @sv t, r, v {
 if t eq u32 | t eq i32 | t eq dword
  mov dword v, r
 else if t eq u16 | t eq i16 | t eq word
  if r eq eax
   mov v, ax
  else if r eq ecx
   mov v, cx
  else if r eq edx
   mov v, dx
  else if r eq ebx
   mov v, bx
  else             ; assume i
   mov dword v, r
  end if
 else if t eq u8 | t eq i8 | t eq byte
  if r eq eax
   mov v, al
  else if r eq ecx
   mov v, cl
  else if r eq edx
   mov v, dl
  else if r eq ebx
   mov v, bl
  else             ; assume i
   mov dword v, r
  end if
 else
  'Unknown type/size'
 end if
}

macro @set t, r, [v] {
 common
  local s, i              ; get size
  @gets t, s, i           ; and sign
  define ?s 0
  match *a, v \{          ; *p
   match x++, a \\{       ; *p++
    ?a equ x
    ?o equ add
    define ?s 1
   \\}
   match =0 \
    x--, ?s a \\{         ; *p--
    ?a equ x
    ?o equ sub
    define ?s 1
   \\}
   match =0 x, ?s a \\{   ; else, *p
    ?a equ x
    ?o equ                ; no advance
    define ?s 1
   \\}
   if ~ ?a is.r?
    'Error'
   end if
   @sv t, r, [?a]
   if ~ ?o eq             ; advance
    ?o ?a, s/8            ; add/sub n
   end if
   verify
  \}
  match =0 a, ?s v \{     ; r
   @sv t, r, a
   define ?s 1
  \}
  verify
  restore ?a, ?o
}

;;;;;;;;;;;;;;;; POINTER OPERATION ;;;;;;;;;;;;;;;

macro . [p] {
 forward
  define ?s 0
  match \
   (t) a==b, p \{    ; (t) a=b
   match *x, a \\{   ; m,m
    match *y, b \\\{
     @get t, ebx, b  ; use ebx
     @set t, ebx, a
     define ?s 1
    \\\}
   \\}
   if ?s eq 0
    match *y, b \\{  ; source=*
     @get t, a, b
     define ?s 1
    \\}
    if ?s eq 0
     match *x, a \\{ ; destiny=*p
      @set t, b, a
      define ?s 1
     \\}
    end if
   end if
  \}
  if ?s eq 0
   'Error'
  end if
}

;;;;;;;;;;;;;;;;;;;;;; ALIAS ;;;;;;;;;;;;;;;;;;;;;

macro ?list.attach list, item {
 match any, list \{ list equ list, item \}
 match , list \{ list equ item \}
}

; aliases for register names

macro alias [x] {
 forward
  define ?s 0
  match name==r, x \{
   ?list.attach ?alias, name
   name equ r
   define ?s 1
  \}
  verify
}

; restore alias names

macro end.alias {
 match a, ?alias \{ restore a \}
}