mov edx,1000h
 dec edx
 neg ecx
 or ecx,edx
 xor ecx,edx
 not ecx   
 inc ecx
 ; or simply [b]neg ecx[/b] for [not ecx/inc ecx]
    

add ecx,0xfff
and ecx,not 0xfff    

Code:

add ecx,0xfff
and ecx,not 0xfff    

; mov edx,1000h
; dec edx
 neg ecx
; or ecx,edx
; xor ecx,edx
 and ecx, -1 shl 12
; not ecx
; inc ecx
 ; or simply [b]neg ecx[/b] for [not ecx/inc ecx]
 neg ecx
    

 add ecx, $1000 - 1
 and ecx, -1 shl 12    

dwSize [in]

The size of the region, in bytes. If the lpAddress parameter is NULL, this value is rounded up to the next page boundary. Otherwise, the allocated pages include all pages containing one or more bytes in the range from lpAddress to lpAddress+dwSize. This means that a 2-byte range straddling a page boundary causes both pages to be included in the allocated region.

It must be said that the not 0xffff will be parsed on
preprocessing stage,right ?

But, the commonly used code for achieving what your code does is:

Code:

 add ecx, $1000 - 1
 and ecx, -1 shl 12    

That is just another way of writing the same thing I posted above.

Also, note that VirtualAlloc already rounds up your parameter so you don't have to do it.

hopcode wrote:

It must be said that the not 0xffff will be parsed on
preprocessing stage,right ?

No, it is processed during the assembly stage. The assembly stage deals with numbers, the preprocessing stage deals with strings.

The parser will convert not into a token...
The assembler will decode the not token as...and do the computation

Even though most systems use the standard 1000h page size it's still possible that a system may be using a custom page size.

 
mov edx,1000h ;(1000h as to simplify/and mean, in that fragment the result from a 
              ;SYSTEM_INFO.dwPageSize)
    

..a couple of minutes of pure skepticism on hopcode's code, I started to compose my reply and later pressed "Submit".

do you need to test
it to see what happens ?

add ecx,N-1 
and ecx,0-N    

the round up is automatic and unavoidable.

ceil_mod:
;;; Rounds value up to multiple
;;;
;;; Expects:
;;;     u32 value @ eax -- value to round up
;;;     u32 divisor @ ecx -- round up to multiple of; divisor != 0
;;;
;;; Returns:
;;;     u32 ceil_value @ eax -- value, rounded up to multiple of divisor
;;;
;;; Modifies:
;;;     edx

        lea     edx, [ecx-1]
        ;;; fall through

round_mod:
;;; Rounds value to multiple
;;;
;;; Expects:
;;;     u32 value @ eax -- value to round down
;;;     u32 divisor @ ecx -- round to multiple of; divisor != 0
;;;     u32 threshold @ edx -- specifies rounding threshold (0 <= threshold < divisor)
;;;                         -- round down when 0 <= (value % divisor) < (divisor - threshold);
;;;                         -- round up otherwise
;;;                         -- in other words: when distance to next multiple greater than threshold, round down
;;; Returns:
;;;     u32 round_value @ eax -- value, rounded to multiple of divisor according to threshold
;;;
;;; Modifies:
;;;     edx

        add     eax, edx        ; add threshold
        sbb     edx, edx        ; with carry
        neg     edx             ; to edx
        jmp     @f
        ;;; may be some neutral xx 31 D2 opcode
        ;;; instead of jump over "xor edx, edx"???

floor_mod:
;;; Rounds value down to multiple
;;;
;;; Expects:
;;;     u32 value @ eax -- value to round down
;;;     u32 divisor @ ecx -- round down to multiple of; divisor != 0
;;;
;;; Returns:
;;;     u32 round_value @ eax -- value, rounded down to multiple of divisor
;;;
;;; Modifies:
;;;     edx == 0

        xor     edx, edx
@@:     div     ecx
        mul     ecx
        ret    

Let's round 'em all: