If you wrote the instruction inline you probably could use an instruction
size prefix to change to 32 bit registers for the one instruction.

  #include "DOS.H"
        :
   __emit__(0x66);
   __emit__(0x0F);
   __emit__(0x31);

Your example declares 'time', 'time_low' and 'time_high' as unsigned, the
same as an unsigned int.  There are two problems with that.

-time is already the name of a function.  You should use a different name.
-You show an instruction storing the contents of the EAX register into the
variable.  EAX is 32 bits but an unsigned int is 16 bits.  For that to work
the variable should be an unsigned long.

This is something like I would try:

  #include "DOS.H"
        :
  #pragma inline
        :
    unsigned long time_val;

    asm db 0x66     /* same as __emit__(0x66);  */
    asm mov [time_val],ax

Borland C++ 3.1 is ancient, 1992, and has no 32 bit abilities.  Expect a
very hard road trying to do anything like that article you speak of does.

.  Ed

Question: what does the asm db 0x66 do?  I probably could download an Intel
Opcode, just wondering if you know off hand?

Thanks, I found someone else trying to do the same thing RDTSC, except with
Microsoft VC++ 1.52.  I adopted the code for this:
// This compiles under Borland C++ version 3.1 with no eax register.
double PC_Mhz = 450000000;        // This is my Intel CPU clock speed
// array element to contain 64 bit time
unsigned long int r_time[2];              // [0]= lower 64 bits, [1] = upper
64 bits
double r_value;                              // rdtsc 64 bit value

double read_rdtsc(void)
{
    asm db 0x0F, 0x31;
    asm db 0x66;
    asm mov word ptr r_time, ax;
    asm db 0x66;
    asm mov word ptr r_time[+4],dx;
    r_value = ( (double) r_time[1] * pow(2,32)) + r_time[0];
    return r_value;

That changes the the size of the paramters in the next instruction.  The
next instruction is one using 16 bit items so it is changed  to act on 32
bit items.

.  Ed

The program is compiled in Borland C++ 3.1 (16-bit) and it's a DOS program.
I think it's compiled in
large mode, when I execute asm db 0x0F, 0x31, Windows 95 gives me "Illegal
Instruction" and crash
the program.  I can execute it with the Windows 2000 machine right here?

I don't get it!  What is it with Windows 95 that is different than Windows
2000 and is there a work around?

This is dos program, not windows.
Thanks,
Robert
"Ed Mulroy (TeamB)" <e...@mulroy.org> wrote in message
news:3b8c1186$1_2@dnews...

Just guessing:

Win95 may be running the processor in another mode.  If you ran it in full
screen DOS mode, try in a DOS window.  Also try Start|Shutdown|Boot in MSDOS
mode

.  Ed

0x0F 0x31 gives an RDTSC instruction (read time-stamp counter).
This instruction can optionally be disabled by setting the
appropriate flag in CR4. If the flag is set, the instruction
can only be executed at privilege level 0. At any other
privilege level a general protection fault is produced. If the
flag is not set no restriction exists.

Since all user applications run at privilege level 3, setting
the flag would cause the GP fault. It looks like 2000 does not
bother to set the flag, but 95 does - though I can't see why
Microsoft would want to restrict this instruction.

Anyway, the only way to change things is to modify the flag.
Unfortunately, you've guessed it, reading and writing to the
control registers can only be performed at privilege level 0.
So basically, there's nothing you can do.

Thanks, sorry I haven't gotten back to you.

Do I need some kind of Windows 95 device driver to do RDTSC (via assembly),
but how do I
pass the results to a MS-DOS program running under Windows 95?

The only way around it was for me to boot into DOS real mode, but Windows
isn't running in the
background.

I assumed your reading the Intel manual on RDTSC, is there any way to
re-enable
some flag in CR4?  Maybe I can run this before executing RDTSC?  I need to
have a
ring 0 program (device) driver to re-enable some flag in CR4.  Once that is
done,
I can run my MS-DOS program to execute the RDTSC instructions.

Robert