Did early versions of DR-DOS preserve more registers than MS-DOS?

Question

The early Amstrad IBM compatible PC the PC1512 initially included DR-DOS, according to its page at Old-Computers.com:

It was sold with MS-DOS 3.2, DR-DOS plus 1.2 (an operating system from Digital Research)

In a recent article in PC Pro Magazine about the early Amstrad PCs, Roland Perry is quoted as saying

Whatever the opinion of the market at the time, DR-DOS was technically superior because it had a certain amount of multitasking and, at a lower level, I think it preserved more registers when doing system calls.

Was this true, and what would have been any advantage of doing this?

Answer 1

TL;DR:

MS_DOS preserved all registers, thus DR-DOS can not have preserved more.

It sounds much like memory blurred by time.

---

Was this true,

Seems hard to believe. Hard to answer as well, as no further data about what versions of DOS (and DR-DOS) this is about. Different versions may have behaved quite differently.

But while early MS-DOS was quite minimalist, it did save all registers. Easy to spot when looking at the MS-DOS 2.0 function scheduler (*1), located in the file MSCODE.ASM:

• After entering via entry point COMMAND (line 96)
• a check for max function number (MAXCOM) is done (line 105)
• if below, label SAVREGS (line 123) is jumped to
• which as very first action calls a procedure named save_world (line 124)
• save_world (line 237) which stores all registers as
  • ES, DS ,BP, DI, SI, DX, CX, BX, AX

The subroutine is used for all other entry points, like CALL CS:5 or some of the other ints. Some use their own method (*2)

and what would have been any advantage of doing this?

Doing what? Saving all registers?

I have a hard time to come up with any reasoning why it should not preserve everything. At least for any system past trivial, which a DOS certainly is.

• It's the very foundation of multitasking (*3)
• It minimizes OS use of user side resources (*4)
• It simplifies function design by having all input registers in a defined structure (*5)
• The same structure can be used for output/return values (*6)

---

*1 - I selected MS-DOS 2.0 here, as it (or even 3.x) would have been contemporary to the mentioned DR DOS Plus 1.2 mentioned in a comment. MS-DOS 1.25 did work exactly the same, at least as far as it's about register saving. See MSDOS.ASM line 228 after the SAVEREGS label

*2 - INT 25h, Direct Disk Read, for example splits this in two parts. The entry point is at ABSDRD (MSDOS.ASM line 508), short after followed by saving all segment registers and then calling DSKREAD, located in DISK.ASM at line 623. This function uses DI, CX and AX as return value, all other registers are preserved. This is different from DOS 1.25 where all registers are saved and restored (except for AX which is modified as return code).

*3 - Which DOS 2.0 was prepared for, see comment at line 140/141

*4 - When for example doing a loop around WriteChar (21h/02h), it's quite handy if the OS would not destroy a string pointer in DI or a character count in CX, wouldn't it?

*5 - After pushing them to the user stack, SS:SP can be saved as a pointer to this structure. Even better, doing so is close to being the most performant way to do so.

*6 - DOS functions can write whatever they return to this structure without any need to care about how it finally gets returned, avoiding complicated register juggling.

Answer 2

For comparison with @Raffzahn's description above, here's how the INT 21h entry point works in DOS Plus.

In the INT 21h handler, the function number is compared with 2Fh. Functions up to 2Fh are handled by a 'DOS 1' handler, functions above by a 'DOS 2' handler.

The 'DOS 1' handler

• If AH is zero, control is passed to the INT 20h handler.
• In all other cases, DS is pushed to the stack. DS, SS and SP are saved to memory; then DS is switched to the DOS emulator data segment, and SP to an internal stack.
• If the system is in an INT 24h handler invoked by DOS Plus: Functions 1-0Ch (console I/O) switch to the stack as it was when INT 24h was invoked. Functions 0Dh and higher call a function to reverse various temporary changes made to the DTA and the mapping of drive P:.
• Interrupts are disabled.
• Registers are pushed to the stack in the order AX,BX,CX,DX,SI,ES,DI,BP.
• A near call is made to the appropriate function handler.
• Registers are retrieved from the stack.
• SS and SP are retrieved from memory. DS is retrieved from the caller's stack.
• Control is returned to the calling program with an IRET.

The 'DOS 2' handler

This handler has only one code path:

• DS, SS and SP are saved to memory.
• SS and SP are set to an internal stack (a different one from those used by the 'DOS 1' handler)
• The registers are saved in the order DX,ES,DI,SI,BP,CX,BX,AX.
• If the system is in an INT 24h handler invoked by DOS Plus, the same function mentioned above is called to unwind temporary DTA / drive P: changes.
• An internal flag is set to say that a 'DOS 2' call is being handled. This allows the Ctrl-Break handler to cope with the different stack layouts of 'DOS 1' and 'DOS 2' calls.
• A near call is made to the appropriate function handler.
• The internal 'DOS 2 call' flag is cleared.
• The registers are retrieved from the stack.
• SS, SP and DS are retrieved from memory.
• Control is returned to the calling program with an IRET.

Therefore it's clear that both DOS Plus 1.2 and MS-DOS 2 preserve all possible registers across system calls. One obvious difference is that MS-DOS 2 saves them on the caller's stack, while DOS Plus saves them to one of its internal stacks. This may be what the Roland Perry quote is referring to; it would require less stack space in the calling program.