We help IT Professionals succeed at work.

We've partnered with Certified Experts, Carl Webster and Richard Faulkner, to bring you a podcast all about Citrix Workspace, moving to the cloud, and analytics & intelligence. Episode 2 coming soon!Listen Now

x

# if i need in assembler to use bigger varibles than the maximum i know

on
Medium Priority
351 Views
I KNOW THAT THE BIG REGISTER/VARIBLE THAT I CAN USE IN MY ASSEMBLER PROGRAMS IS 0FFFFH BUT IF I WNAT TO USE A BIGGER
REGISTER/VARIBLE IN ASSEMBLER WHAT I NEED??
AND HOW CAN I PRINT ON THE SCREEN THE NUMBERS THAT IN THE REGISTERS??
SEND ME AN EXAMPLE!!
Comment
Watch Question

## View Solution Only

Commented:
For bigger registers variables you can
2 * Split 2 16-bit vars up

like

mov ax, word ptr [xxxx]  // addr of first 32-bit var
mov bx, word ptr [xxxx + 2]
adc bx, word ptr [yyyy + 2]
mov word ptr [zzzz], ax // addr of third 32 -bit var
mov word ptr [zzzz + 2], bx

adds var at xxxx to yyyy and writes the result to zzzz
you can have similar code for substracting, xoring, ...

Commented:
Odie is right.
However, it is possible to write 32bit code under TP by using inline assembler.
If you want to make some calculation over big numbers, you can also use the FPU even if the numbers are integer.

Commented:
That's true and multiplying on a Pentium in Floating Point can be faster.

If you want I can give you instructions on that too.
Commented:
For Printing  the content from a registry try assigning to a variable the content of the register
xc:=dx
and dx is declared as byte
ten print the variable.
If not convinced try to dl a program called XRAY who makes a tracing off line the program possible.

Not the solution you were looking for? Getting a personalized solution is easy.

Commented:
If you want to use the Floating Point Unit:

It has 8 registers which are "stacked" - that means you can't access whatever register you like, but only the topmost.

and write it to 64-bit int C at address zzzz

fild QWord Ptr [xxxx] // Float Integer LoaD: A loaded to Register 0
// Reg0: A, Reg1: Empty, Reg2: Empty, ...
fild QWord Ptr [yyyy] // Float Integer LoaD: B loaded to Register 0
// A moved to register 1 (stack)
// Reg0: B, Reg1: A, Reg2: Empty, Reg3: Empty, ...
faddp ST(1), ST // Add Reg1 (= ST(1)) (B) to Reg0 (= ST(0) or ST) (A)
// Reg0: A + B, Reg1: Empty, Reg2: Empty, ...
// the p means the source reg is emptied
fistp QWord Ptr [zzzz] // the contents of the topmost register (ST) or written to zzzz
// Float Integere STore
// Reg0: Empty, Reg1: Empty, Reg2: Empty, ...
// if the p is left out Reg0 (ST) would still be A + B

Some other usefull instructions:
fmul(p) // Multiplying
fsub(p) // Substraction
fdiv(p) // Division
fxch // exchanges the contents of two registers

You can of course also work with real floating point values (doubles, long doubles, ...) or 32-bit integers

For a complete reference search Intel's Literature Centre.

Commented:
You can use my routine to write the content of a 32 bit variable, put the desired value in mem (mov eax,1234h    mov mem,eax    call affiche), the affisub sub routine is not included but is easy to make using Bios or Direct memory write.
affiche:
pusha
mov flag,0
mov cx,10
reset:
mov bx,cx
dec bx
mov number+bx,0
loop reset
mov eax,0
mov ebx,0
mov ecx,0
mov edx,0
mov eax,mem
cmp mem,0
je zero
mov tempo,1000000000
mov cx,10
calculus:
mov bx,cx
neg bx
push bx
push cx
mov edx,tempo
jump:
cmp eax,edx
jb finished
mov flag,edx
inc number+bx
jmp jump
finished:
sub eax,flag
mov flag,0
finit
fild tempo
fild cons
fdiv
fist tempo
pop cx
pop bx
loop calculus
mov flag,0
mov cx,10
display:
mov bx,cx
neg bx
mov dl,number+bx
mov dh,0
mov eax,flag
cmp eax,1
je noend
cmp dx,0
je dispend
noend:
call affisub
mov flag,1
dispend:
loop display
jmp nozero
zero:
mov dl,"0"
call affi1
nozero:
mov flag,0
popa
ret

##### Thanks for using Experts Exchange.

• View three pieces of content (articles, solutions, posts, and videos)
• Ask the experts questions (counted toward content limit)
• Customize your dashboard and profile