[Info-vax] VAX vs. MV/8000 [was Re: Hard links on VMS ODS5 disks]

[Dan Cross]

In article <ucjb5o$1tgf7$1 at dont-email.me>,
Arne Vajhøj  <arne at vajhoej.dk> wrote:
>On 8/27/2023 10:11 PM, Dan Cross wrote:
>[snip]
>>> A 64 bit program cannot use 32 bit libraries.
>> 
>> Again, you are conflating an architectural issue with the
>> implementation of some code-generation system that you are
>> familiar with.  That is, where you are saying, "a 64 bit
>> program cannot use 32 bit libraries" what you really mean is,
>> "that is not done by systems that I am familiar with."
>
>It does not really matter what system.
>
>Some 32 bit instructions produce wrong result when executed
>in 64 bit model and some 32 bit instructions crash when
>executed in 64 bit mode.

Again, you wrote:
|DEC chose to have the VAX switch mode between 32 and
|16 bit instructions (similar to what AMD did a couple
|f decades later).
(https://groups.google.com/g/comp.os.vms/c/k-wizEMeS14/m/M2Ef9LyHAAAJ)

This is what I was responding to: on VAX, you had to switch to
PDP-11 compatibility mode to execute _any_ 16-bit instruction.
This is NOT true on x86.  x86 does essentially what DG did.

>>> If I understand the peoples description of Eclipse MV and AOS/VS
>>> correct then it 32 bit code can call 16 bit code.
>> 
>> The description from Chris Scheers earlier said that "DG's
>> approach allows mixing NOVA, Eclipse, and MV instructions in the
>> same application stream.  Actually, it not only allowed, it is
>> normal to do this."
>
>> In particular, you seem to think that _no_ instruction required
>> special handling on MV, which is almost certainly not the case.
>
>The premise was that DG could do without compatibility
>mode what other did with a compatibility mode.
>
>It was said to be the case.
>
>I don't know personally as I have never used a DG system.
>
>But it seems rather plausible. Because they did not
>offer a compatibility mode.
>
>Either the Eclipse MV could execute at least all
>instructions outputted by Eclipse compilers and
>commonly used by assembler programmers on Eclipse, so
>an Eclipse executable can be expected to run on
>Eclipse MV - or Eclipse MV was not compatible
>with Eclipse.

I posted the reference.  Here is again:
http://www.bitsavers.org/pdf/dg/mv8000/014-00648_MV8000_PrincOps_Apr80.pdf

See appendices C and D, which I quoted in
https://groups.google.com/g/comp.os.vms/c/k-wizEMeS14/m/arX5DixUAQAJ

>x86-64 does not need to be able to execute all
>32 bit instructions in 64 bit mode, because it
>has a 32 bit compatibility mode.

MV couldn't either.  VAX couldn't execute any.  x86 is much
closer to DG in this regard, which was my original point.  You
keep trying to move the goalposts by talking about other
issues, but that's just tedious.

>>> The fact that maybe 98% of the instructions in 32 bit x86
>>> code would work fine interpreted as 64 bit x86-64 code
>>> and only maybe 2% would return wrong results or crash
>>> is about as relevant as the background color used when
>>> running the program.
>> 
>> That's not how it works.
>
>Yes - it is how it works.

Maybe if you get most of your information from Infoworld-quality
articles you find from trivial Google searches you believe that.

>Some 32 bit instructions produce wrong result when
>executed in 64 bit mode and some 32 bit instructions
>crashed when executed in 64 bit mode.
>
>You can try yourself. Code posted in other post.

Why would I bother?  I already pointed out that some
instructions behave differently and never suggested otherwise.
For example, I wrote:
|Of course, the semantics of a few instructions do change (the
|size of words on the stack changes, for example, so the `PUSH`
|instruction behaves differently in 64-bit mode), but in this
|regard, the mechanism is closer to what DG did than what DEC
|did.
(https://groups.google.com/g/comp.os.vms/c/k-wizEMeS14/m/Zx7kwqHEAAAJ)
So that part of what you wrote is objectively true, but I had
already pointed it out, so what's your point?

Where you are incorrect, and seem incapable of admitting error,
is in asserting that the x86 execution mode is exactly like the
PDP-11 compability mode on the VAX-11.  It is not.  It really
truly is much closer to the DG model where 32-bit and 64-bit
instructions can, with care, be intermingled in a single
instruction stream while on VAX where they cannot be so mixed
_at all_.

All of the rest of it, with linking 64-bit binaries against
32-bit libraries and so on, is a strawman; I merely asked you to
clarify your point so I could understand exactly what you were
referring to.  I either got vague allusions to, "what everyone
means" or the non-answer, "yes."

	- Dan C.