80x86 | 80186 compatible SystemVerilog CPU core and FPGA reference

Three bugs:

• Your arguments to strConcatenation are reversed. As it stands you are concatenating string1 onto the end of string2.

• repne scasb scans for the value in the al register, which you haven't initialized. To scan for nul, zero it out: xor al, al.

• repne scasb terminates when the byte in al is found OR when ecx reaches zero (it is decremented on each iteration). You haven't initialized ecx either. To scan indefinitely until the byte is found, you can set ecx to -1.

Since foo is not declared, the compiler guesses that it's a function. However, foo is not a function, but a variable, so the calling fails.

Before C99 (request for a check), C does not force the user to declare functions before calling them, so there are no warnings or errors from the compiler; What's more, there is really one foo defined, no matter it is a variable or a function, so there are no warnings or errors from the linker. These make this issue hard to find.

However, as found in this SO post, sometimes an implicit function call like this would become a undefined behaviour (UB):

J.2 Undefined behavior

— For call to a function without a function prototype in scope where the function is defined with a function prototype, either the prototype ends with an ellipsis or the types of the arguments after promotion are not compatible with the types of the parameters (6.5.2.2).

The problem is that the MASM 5.10 linker is deficient and doesn't properly handle this kind of 32-bit relocation. As you suspected it is treating the 32-bit relative displacement as a 16-bit value which as you have correctly observed produces the wrong value (notably when calling code at a negative displacement). To test your code I have been using MASM 5.10a and the linker is version 3.64.

You can continue to use MASM.EXE 5.10a, but you will need to replace your linker. The 16-bit Microsoft Overlay Linker (LINK.EXE) that comes with MASM 6.11 does work correctly. You will need to have an expanded memory manager present for the LINK.EXE and/or MASM.EXE to function correctly. MASM 6.11 was the last version of the MASM products that can be run from DOS. MASM 6.11 install disks can be downloaded from here.

If you download and install Borland's Turbo Assembler v2.0x you can assemble your code with TASM and link with TLINK. If you run TLINK on the object file produced by TASM it will actually warn you of this problem! The error will look something like:

32-bit record encountered in module Use "/3" option

If you use the /3 option it enables 32-bit processing and a proper executable should be generated.

To assemble with TASM (it will still work with MASM) a small adjustment must be made to these lines:

Carry flag CF is used when CPU works with unsigned integer numbers (in 8bit registers they can have value between 00h and FFh).

When addition is performed and the result exceeds the maximal value FFh, CF signalizes that it happened, and that number 1 should be added to the register with higher order (ah).

When subtraction is performed and the result is below the minimal value 00h, CF signalizes that it happened and that number 1 should be borrowed (subtracted) from ah.

In your example code the result of subtracting 1h from the 0h in al is below the allowed minimal value, that's why CF is set.

Setting cf=1 CPU indicates unsigned subtraction underflow.

If you look at those numbers as signed integers, their allowed range is -128 to +127 (80h to 7F) and overflow or underflow is signalized with different flag of. In your code the result (treated as signed number) is -1 (FFh) and this is within the allowed range (no overflow), so you should see in emulator that of=0.

One critical bit might be what happens when kmain returns?

The followup question is important: you have to clean up the stack before iret. For this reason alone, it is really cumbersome to point your gates at C functions. Most people make two assembly stubs:

The code that you've indicated by ";CALCULATOR CODE STARTS HERE" is never loaded in memory. You've mistakenly used the wrong function number!

Here

The SEGMENT directive can take the two forms:

It is a dangerous practice to allocate in one place and then free across a DLL boundary. Avoid it unless you know that you're doing it right (same CRT version etc.). Thus spake Microsoft:

When you pass C Run-time (CRT) objects such as file handles, locales, and environment variables into or out of a DLL (function calls across the DLL boundary), unexpected behavior can occur if the DLL, as well as the files calling into the DLL, use different copies of the CRT libraries.

A related problem can occur when you allocate memory (either explicitly with new or malloc, or implicitly with strdup, strstreambuf::str, and so on) and then pass a pointer across a DLL boundary to be freed. This can cause a memory access violation or heap corruption if the DLL and its users use different copies of the CRT libraries.

One solution to this is to expose a free function from your DLL that is turning over an allocated object so the client can call your free function on it, or in C++ you might use a smart pointer with a custom deleter to do it right.