I am getting an unwanted answer from the above assembler call.
I am using MASM and Visual Studio 2019 Community Edition.
; assembler code
Tester2 proc
mov ax, -100
cwd
mov cx, 3
idiv cx
ret
Tester2 endp
end
// c++ code
#include <iostream>
extern "C" int Tester2();
int main() {
auto rr = Tester2();
std::cout << rr;
return 0;
}
You’ve declared Tester2 as returning an int, but that is most likely a short since you’re only filling in ax and ignoring the rest of eax. If you declare your function as returning a short, the problem should go away.
When proc Tester2 returns, the ax register does indeed contain the value -11. This register is 16 bits long, and the number -11 expressed in 16-bit hexadecimal is 0xFFF5.
However:
You have declared Tester2() as returning an int.
You are using the [masm64] tag, so you are presumably targeting x64.
In C and C++ code compiled for 64-bit architectures an int is 32 bits long. (Same as in 32-bit architectures.)
So, here is where the problem begins: your assembly is returning a 16-bit value but your C++ is expecting a 32-bit value.
When the result of invoking Tester2() is assigned to rr, the entire 32-bit long eax register gets stored in rr.
The lower half of eax is ax, which is 0xFFF5, but the upper half is zero1, so rr receives the value 0x0000FFF5.
0x0000FFF5 is 65503 in decimal, and that is what you observe.
To fix this, you have three options:
Switch your tooling to target a 16-bit architecture instead of a 64-bit (or 32-bit) architecture. Then, your int will be 16-bits wide.
Declare Tester2() as returning a 16-bit value by using #include <cstdint> and replacing int with int16_t.
Write Tester2() to use 32-bit arithmetic, so that it returns a 32-bit result in register eax.
Needless to say, Option #3 is the best option.
32-bit operand-size typically has the smallest machine-code size (no prefixes necessary), and is at least as fast as other operand-sizes for math instructions. That's one reason why it was a good choice for int on x86-64, as well as being the same size as in 32-bit C and C++ implementations.
1 The upper half of eax is zero most probably due to coincidence. I am saying this because modifying the ax register is known to leave the upper part of eax unmodified. This means that your idiv instruction left the upper part of eax unchanged, which means that eax must have been zero before your main() was invoked, which is just pure luck.
