mov eax,-5

why it is -5 and not 11111111111111111111111111111100 b <===Very huge number.

if i load -5 or 11111111111111111111111111111100 b how the program know what i wont to have in eax.

how can i make |-5| = 5 if i do not know that ^:eek:

why it is -5 and not 11111111111111111111111111111100 b <===Very huge number.

if i load -5 or 11111111111111111111111111111100 b how the program know what i wont to have in eax.

how can i make |-5| = 5 if i do not know that ^:eek:

answer:

when u refer to -5, its really a very long binary number as u pointed out.

ITS THE SAME NUMBER !!!

You can put it in binary, hex, decimal or any other number system u want, its the Same Number. k?

when u refer to -5, its really a very long binary number as u pointed out.

ITS THE SAME NUMBER !!!

You can put it in binary, hex, decimal or any other number system u want, its the Same Number. k?

how can i make |-5| = 5 if i do not know that ^:eek:

Absolute:

```
mov eax, [number]
```

mov ecx, [number]

sar ecx, 31

xor eax, ecx

sub eax, ecx

not eax

add eax 001b ; || or was it >> inc eax ?

?

Just guessing here :) I did that once for an trackbar...

add eax 001b ; || or was it >> inc eax ?

?

Just guessing here :) I did that once for an trackbar...

Or just:

NEG EAX

:)

NEG EAX

:)

```
```

xor eax,eax

mov ecx, [number]

cmp eax,ecx

ja out

neg ecx

out:

Weird... somehow I thought neg didn't change the sign if the op was already negative...

Well, it does.. Good to know :stupid:

Well, it does.. Good to know :stupid:

```
[size=12] mov eax, [number]
```

cdq

add eax, edx

xor eax, edx[/size]

Yup, NEG is short for NEGate. Makes positive numbers negative, and negative numbers positive, by subtracting from 0. :)

```
```

xor eax,eax

mov ecx, [number]

cmp eax,ecx

ja out

neg ecx

out:

perhaps "out" might not be the best label name... might confuse some assemblers!

My mistake, I could not think of any better label at that point of time :grin:

Hello all.....

Let me clear you all about negative number storage.

suppose you want to store -5 , then what processor do it calculate it's 2's complement and then store it or do any operation after that.

By saying 2's complement I mean.

to represent -5 we do.

5 ===> 0000 0000 0000 0000 0000 0000 0000 0101 ( this is 5 )

1111 1111 1111 1111 1111 1111 1111 1010 ( after complement )

-5 ==> 1111 1111 1111 1111 1111 1111 1111 1011 ( add 1 )

so if you write

mov eax, 11111111111111111111111111111011b

you will this instruction at run time as in any debugger ( like SoftIce )

mov eax, FFFFFFFB <===== that is -5

hope this help you

cya

Let me clear you all about negative number storage.

suppose you want to store -5 , then what processor do it calculate it's 2's complement and then store it or do any operation after that.

By saying 2's complement I mean.

to represent -5 we do.

5 ===> 0000 0000 0000 0000 0000 0000 0000 0101 ( this is 5 )

1111 1111 1111 1111 1111 1111 1111 1010 ( after complement )

-5 ==> 1111 1111 1111 1111 1111 1111 1111 1011 ( add 1 )

so if you write

mov eax, 11111111111111111111111111111011b

you will this instruction at run time as in any debugger ( like SoftIce )

mov eax, FFFFFFFB <===== that is -5

hope this help you

cya

i've seen a snipplet to get the absolute of a number:

```
```

mov eax,[number]

@@:

neg eax

js @b ; if the sign flag is set after negating, negate again, cuz it WAS already a positive number

That snippet has hiden bug. If eax = 80000000h it goes to endless loop!!!

Use

If you have to compare signed value you can do this:

If you don't do this masm will treat value in eax as unsigned.

So say not -5, but 0FFFFFFFBh.

And 0FFFFFFFBh is > 0.

Use

**jl**instead of**js**.```
abs MACRO r:REQ
```

@@: neg r

jl @B

ENDM

If you have to compare signed value you can do this:

```
.if SDWORD PTR eax < 0
```

; do something

.endif

or```
assume eax:SDWORD
```

.if eax < 0

; do something

.endif

assume eax:nothing

If you don't do this masm will treat value in eax as unsigned.

So say not -5, but 0FFFFFFFBh.

And 0FFFFFFFBh is > 0.

mov eax,-5

why it is -5 and not 11111111111111111111111111111100 b <===Very huge number.

if i load -5 or 11111111111111111111111111111100 b how the program know what i wont to have in eax.

how can i make |-5| = 5 if i do not know that ^:eek:

There is no short answer but I give you some hints to

understand this your problem and many others simular to

this.

(In details I'm going to discuss it in "Position numeric system for lowlevel programmers")

Keep in mind that

1. Any numeric format exist not just a rules how to represent value in this

format but also by rules how this representation is used in math operations.

For example if you studied in scool how to divide or multiply numbers in

decimal numeric system using just pen and paper you learnt those algos

only for this system and can not apply them to make calculation with Romen

numeric system (format)

2. Doing math in computer you deal not only with value of operand, but

also in discretion of those values, in other words each operand has size

(particular number of digits (bits) it can have)

For better understanding the following info let's call it not "size" but

limits.

For example byte is limited by 0000 0000 to 1111 1111.

In any positioning numeric system base x (radix x)

number of digits can tell us

1. Number of values that can be represented in this number of digits

This number of values = redix in power of number of digits

for example in binary system radix = 2

number of digits in byte = 8

so that byte can have 2^8=256 different values (from 0 to 255)

2. Max value = (radix in power of number of digits)-1

in byte

2^8 - 1 = 255.

Example: in 3 bit operand

number of values = 2^3=8

max number = 2^3-1=7

Now important note to understand the whole thing of

negative number representaion in integers in computer:

What if number of digits in result of operation exceed the upper

limit?

Let's say we add to bytes and result we write in a byte also:

1111 1111

+

0000 0001

------------------

10000 0000

Result has 9 digits but operant of result limited to 8 digits.

So it will have only lower 8 digits and they represent 0, not 10000 0000b

Now we store this effect in our mind and go to next thing

important for our understanding:

If we have 7 bit operand the number of values in can represent = 2^7 = 128

If 8 bit operand number of values = 2^8 = 256.

Suppose we need to devide all values in 8 bit operand in two groups, each group having

the same number of values.

2^8=256/2 + 256/2 = 128 + 128 = 2^7+2^7 = 2 (2^7)

You can see that if we need to represent only one of the group

we need just 7 bits cause number of values in each group = 2^7

But we have 2 groups and we also have one extra bit.

It can have only 2 values 1 or 0. That means that number of

values of bit is equal to numbers of our groups.

Let us use this extra bit to destinct whether value

belongs to group 1 or group 2.

We use upper bit in 8 bit operand for this destinction.

So values from 0 000 0000 to 0 111 1111 belong to first group

And those from 1 000 0000 to 1 111 1111 belong to second group.

As you can see both groups freely use low 7 bits and have that for

the same number of values.

Now let's try to find a way to use first group (with upper bit = 0) as

positive numbers and second group (with upper bit = 1) as negative.

(0 this way is finding its place in positive numbers though it is

nor positive neither negative.)

Then we can call this upper bit (bit[7] in byte in zero based enumaration)

sign bit, and if this bit is =1 then we have negative number, if = 0 - positive.

But its not enough just to separate 256 possible values by some rules -

those rules must allow up to find some algos to do math operations

and have right results.

Now we close to end of this introduction, and possible understanding

of positive\negative int values representation in computers.

(So to called "complimentary 2 code")

Let's up recall two things

1. All 4 math operation can be represented as just one - addition

a+b=a+b

a-b =a+(-b)

a*b=a+a+a.. b times or b+b+b... a times

a/b=times of a-b untill reminder < b = times a+(-b) untill reminder < b

So if we can find way how find corresponence between representation of positive x in first

group and negative x in second group so that result of addition will produce right result

we can use the system.

2. x + (-x) =0

Now remember example when add 1111 1111 + 0000 0001 and get in used 8 bits

of result 0000 0000 ? Cause upper bit was out of size of our operand?

Then if corresponding to positive 0000 0001 we assign as -1 1111 1111 we've got

the right answer for x+(-x)=0 in bits that is used in 8 bits operands.

Let's check this "-1" about addition of other positive values:

-1+2=1

1111 1111 + 0000 0010 = 1 | 0000 0001 (in meaningfull low 8 bits = 0000 0001 = 1)

-1+5=4

1111 1111 + 0000 0101 = 1 | 0000 0100 (in meaningfull low 8 bits = 0000 0100 = 4)

So what binary number would be for -2? -120? etc.

We added to 0000 0001 number 1111 1111 and got 1 0000 0000.

So for any x from positive group (0000 0000 to 0111 1111) 0??? ????

as -x will serve binary number so that

0??? ???? + 1??? ???? = 1 0000 0000

For example positive 5 = 0000 0101

negative 5 = 1 0000 0000 - 0000 0101 = 11111011b

and low 8 bits in 1111 1011b+0000 0101 = 1| 0000 0000 = 0

So that we can have in byte 128 values from -1 to -128 with sign bit.

And 128 values from 0 to 127 with sign bit = 0

In byte we don't have corresponding positive value for -128 as

well there is no - 0 too.

As I said before in computers there is no such things as

add some value to othervalue

there are always add two values of SPECIFIED SIZE.

What if our operand is 16 bits or 32 or xx.. bits?

The rule of format is the same.

All values of with high bit =1 are negative and high (let us now call it "sign") bit = 0 are

positive.

And corresponding values are found the same way, the only difference

is that in 32bits operands sum of them equal lowest 33 bit value

in 16 bits = lowest 17bits value

For example in 32 bit -1 = 11111111 11111111 11111111 11111111b

in 16bits 11111111 1111111b

How comp knows size? :)

It is in opcode. Opcode always specifys size of operands in operations.

If you write push -5 it pushes dword FFFFFFFBh

if you write mov al,-5 it mov FBh in al 'cause al is 8 bits operand.

Now if we use the same operator for both sign and unsign values

how we ensure right result?

FFh can be treated as -1 sign and 255 unsign byte value?

That's is what CF,SF and OF flags for.

CF = 1 if bits in result is 1 more then operand size.

SF = 1 if highest (sign bit) in result is 1

OF treat SF as another carry flag and if CARRY FROM SF to CF <> to SF

it is set to 1.

If you need explonations why - I'll try to write examples to understand.

Anyway I will post materials about the issue to the board in more details

and you can wait untill it happens.

There are actually 3 very important things for lowlevel programming

that don't have good explonation in current asm books:

1. Operations in positioning numeric system in details

2. Understanding machine code specifics

3. Machine code algorithm in details.

Most questions I read on the board would have never been asked

if somewere it were explained in details with examples and exersizes.

It usually was different in old books, but instead of expanding the practice

in good old books contemporary books mostly look like reference of

recepies books and don't teach understanding of the very important basics.

I've decided to fill the gap, but I can not be sure for now that I'll be capable

to carry the task.

Nice explanation :grin:

mov al,-5 <=== for example but i can also dont know if it is -5 or sth else

mov ebx,eax

;ebx !=-5

What can i do with this problem if i do not know if the al was -5 or some positive number:confused:

mov ebx,eax

;ebx !=-5

What can i do with this problem if i do not know if the al was -5 or some positive number:confused:

*Originally posted by drakoforma*

mov al,-5 <=== for example but i can also dont know if it is -5 or sth else

**movsx eax, al ; conversion to 32-bit signed!**

mov ebx,eax

; ebx =-5

mov al,-5 <=== for example but i can also dont know if it is -5 or sth else

mov ebx,eax

;ebx !=-5

What can i do with this problem if i do not know if the al was -5 or some positive number:confused:

I'm absolutly buffled by code you posted

and your questions :(

Where this code did come from?

Is it from your app or what?

al and eax have different operand size.

why if you need to add ebx and eax

you load -5 in al not in eax?

Anyway from your code there is absolutly

no way to predict what could be in eax after all

mov al,-5

equal to

mov al,0FBh

and after that we don't know what is in eax

if before mov al,0FBh we have in eax ???? ????h

then after mov al,0FBh we have in eax ???? ??FBh

but what is in upper 24 bits? - God knows.

Read my post again - I wrote several times there

in computers there is no ABSOLUTE number representation

each number in particular format is formated for size of operand.

For 8 bit operand (al) it is FBh for 32 bit format it is FFFFFFFBh.

Rules are explained in my post.

I repeat - I wrote it several times and yet you are giving examples

were you load -5 in 8 bit operand and waiting that 32 bit register

that in addition to bits in al has also more 24 bits will magically

to be converted to something.

If you are going to use value in 8 bit operand now with 32 bit operand

you need to convert it to 32 bit operand first.

I'll give you the same stupid example.

eax is 32 bit and have 4 bytes as digits.

Now let I have some number in deciamal -

I also as you in your example - have know idea what the

number is and what digits it has. So this number is ????

I put in last digit - 5. Guess what number is now?

???-5.

If you load in AL - 5 (FBh) and add it with 8(!!!!!!!!!!!!!!!!!!!!) bit operand

then you don't need to know anything, it will work correctly.

Numbers in computers represented depending on 3 things

1. Value

2. Format

3. Operand size.

Not only integer compliment code.

0.1 in float also formatted differently according to OPERAND SIZE.

Pretend al = some 8 bit signed number

Now ebx = al, except ebx is a signed 32 bit version of it.

`[size=12]movsx ebx, al[/size]`

Now ebx = al, except ebx is a signed 32 bit version of it.