（汇编源代码 ）侦测CPU型号

核心提示：_PROCESSOR DETECTION SCHEMES_by Richard C. Leinecker[LISTING ONE];;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Detect the Process

　　_PROCESSOR DETECTION SCHEMES_
by Richard C. Leinecker
　　[LISTING ONE]
　　;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;　Detect the Processor Type -- by Richard C. Leinecker　　　　　　　　 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
　　_PTEXT　　　SEGMENT PARA PUBLIC 'CODE'
　　　　ASSUME　CS:_PTEXT, DS:_PTEXT
　　public　_Processor
; This routine returns the processor type as an integer value.
; C Prototype
; int Processor( void );
; Returns: 0 == 8088, 1 == 8086, 2 == 80286, 3 == 80386, 4 == 80486
; Code assumes es, ax, bx, cx, and dx can be altered. If their contents
; must be preserved, then you'll have to push and pop them.
_Processor　proc　　far
　　push　　bp　　　　　; Preserve bp
　　　　mov bp,sp　　　　　 ; bp = sp
　　push　　ds　　　　　; Preserve ds
　　　　push　　di　　　　　; and di
　　mov ax,cs　　　　　 ; Point ds
　　　　mov ds,ax　　　　　 ; to _PTEXT
　　call　　IsItAn8088　　　; Returns 0 or 2
　　cmp al,2　　　　　　; 2 = 286 or better
　　　　jge AtLeast286　　　; Go to 286 and above code
　　call　　IsItAn8086　　　; Returns 0 or 1
　　jmp short ExitProcessor ; Jump to exit code
AtLeast286:
　　　　call　　IsItA286　　　　; See if it's a 286
　　cmp al,3　　　　　　; 4 and above for 386 and up
　　　　jl　short ExitProcessor ; Jump to exit code
AtLeast386:
　　　　call　　IsItA386　　　　; See if it's a 386
ExitProcessor:
　　　　pop di　　　　　; Restore di,
　　　　pop ds　　　　　; ds,
　　　　pop bp　　　　　; and bp
　　ret　　　　　　 ; Return to caller
_Processor　endp
　　; Is It an 8088?
; Returns ax==0 for 8088/8086, ax==2 for 80286 and above
IsItAn8088　proc
　　　　pushf　　　　　　　 ; Preserve the flags
　　pushf　　　　　　　 ; Push the flags so
　　　　pop bx　　　　　; we can pop them into bx
　　and bx,00fffh　　　 ; Mask off bits 12-15
　　　　push　　bx　　　　　; and put it back on the stack
　　popf　　　　　　　　; Pop value back into the flags
　　　　pushf　　　　　　　 ; Push it back. 8088/8086 will
　　　　　　　　　　　　　　　　　　　　　　　　; have bits 12-15 set
　　　　pop bx　　　　　; Get value into bx
　　　　and bx,0f000h　　　 ; Mask all but bits 12-15
　　sub ax,ax　　　　　 ; Set ax to 8088 value
　　　　cmp bx,0f000h　　　 ; See if the bits are still set
　　　　je　Not286　　　　　; Jump if not
　　mov al,2　　　　　　; Set for 286 and above
Not286:
　　　　popf　　　　　　　　; Restore the flags
　　ret　　　　　　 ; Return to caller
IsItAn8088　endp
　　; Is It an 8086?
; Returns ax==0 for 8088, ax==1 for 8086
; Code takes advantage of the 8088's 4-byte prefetch queues and 8086's
; 6-byte prefetch queues. By self-modifying the code at a location exactly 5
; bytes away from IP, and determining if the modification took effect,
; you can differentiate between 8088s and 8086s.
IsItAn8086　proc
　　mov ax,cs　　　　　; es == code segment
　　　　mov es,ax
　　std　　　　　　; Cause stosb to count backwards
　　mov dx,1　　　　　 ; dx is flag and we'll start at 1
　　　　mov di,OFFSET EndLabel ; di==offset of code tail to modify
　　　　mov al,090h　　　　; al==nop instruction opcode
　　　　mov cx,3　　　　　 ; Set for 3 repetitions
　　　　REP stosb　　　　　; Store the bytes
　　cld　　　　　　; Clear the direction flag
　　　　nop　　　　　　; Three nops in a row
　　　　nop　　　　　　; provide dummy instructions
　　　　nop
　　　　dec dx　　　　 ; Decrement flag (only with 8088)
　　　　nop　　　　　　; dummy instruction--6 bytes
EndLabel:
　　　　nop
　　mov ax,dx　　　　　; Store the flag in ax
　　ret　　　　　　; Back to caller
IsItAn8086　endp
　　; Is It an 80286?
; Determines whether processor is a 286 or higher. Going into subroutine ax = 2
; If the processor is a 386 or higher, ax will be 3 before returning. The
; method is to set ax to 7000h which represent the 386/486 NT and IOPL bits
; This value is pushed onto the stack and popped into the flags (with popf).
; The flags are then pushed back onto the stack (with pushf). Only a 386 or 486
; will keep the 7000h bits set. If it's a 286, those bits aren't defined and
; when the flags are pushed onto stack these bits will be 0. Now, when ax is
; popped these bits can be checked. If they're set, we have a 386 or 486.
IsItA286　　proc
　　　　pushf　　　　　　　 ; Preserve the flags
　　　　mov ax,7000h　　　　; Set the NT and IOPL flag
　　　　　　　　　　　　; bits only available for
　　　　　　　　　　　　; 386 processors and above
　　　　push　　ax　　　　　; push ax so we can pop 7000h
　　　　　　　　　　　　; into the flag register
　　　　popf　　　　　　　　; pop 7000h off of the stack
　　　　pushf　　　　　　　 ; push the flags back on
　　　　pop ax　　　　　; get the pushed flags
　　　　　　　　　　　　; into ax
　　　　and ah,70h　　　　　; see if the NT and IOPL
　　　　　　　　　　　　; flags are still set
　　　　mov ax,2　　　　　　; set ax to the 286 value
　　　　jz　YesItIsA286　　 ; If NT and IOPL not set
　　　　　　　　　　　　; it's a 286
　　　　inc ax　　　　　; ax now is 4 to indicate
　　　　　　　　　　　　; 386 or higher
YesItIsA286:
　　　　popf　　　　　　　　; Restore the flags
　　ret　　　　　　 ; Return to caller
IsItA286　　endp
　　; Is It an 80386 or 80486?
; Determines whether processor is a 386 or higher. Going into subroutine ax=3
; If the processor is a 486, ax will be 4 before leaving. The method is to set
; the AC bit of the flags via EAX and the stack. If it stays set, it's a 486.
IsItA386　　proc
　　　　mov di,ax　　　　　 ; Store the processor value
　　　　mov bx,sp　　　　　 ; Save sp
　　　　and sp,0fffch　　　 ; Prevent alignment fault
.386
　　　　pushfd　　　　　　　; Preserve the flags
　　pushfd　　　　　　　; Push so we can get flags
　　　　pop eax　　　　 ; Get flags into eax
　　　　or　eax,40000h　　　; Set the AC bit
　　　　push　　eax　　　　 ; Push back on the stack
　　　　popfd　　　　　　　 ; Get the value into flags
　　　　pushfd　　　　　　　; Put the value back on stack
　　　　pop eax　　　　 ; Get value into eax
　　　　test　　eax,40000h　　　; See if the bit is set
　　　　jz　YesItIsA386　　 ; If not we have a 386
　　add di,2　　　　　　; Increment to indicate 486
YesItIsA386:
　　　　popfd　　　　　　　 ; Restore the flags
.8086
　　　　mov sp,bx　　　　　 ; Restore sp
　　　　mov ax,di　　　　　 ; Put processor value into ax
　　ret　　　　　　 ; Back to caller
IsItA386　　endp
　　_PTEXT　　　ENDS
　　　　END
[LISTING TWO]
　　.586
; Pentium detect routine. Call only after verifying processor is an i486 or
; later. Returns 4 if on i486, 5 if Pentium, 6 or greater for future
; Intel processors.
EF_IDequ200000h　; ID bit in EFLAGS register
Pentium proc near
　　; Check for Pentium or later by attempting to toggle the ID bit in EFLAGS reg;
; if we can't, it's an i486.
pushfd　; get current flags
popeax　;
movebx,eax　;
xoreax,EF_ID; attempt to toggle ID bit
pusheax　;
popfd　　;
pushfd　; get new EFLAGS
popeax　;
pushebx　; restore original flags
popfd　　;
andeax,EF_ID; if we couldn't toggle ID, it's an i486
andebx,EF_ID　;
cmpeax,ebx　;
jeshort Is486　;
　　; It's a Pentium or later. Use CPUID to get processor family.
moveax,1　; get processor info form of CPUID
cpuid　　;
shrax,8　; get Family field;　5 means Pentium.
andax,0Fh　;
ret
Is486:
movax,4　; return 4 for i486
ret
pentium endp
[LISTING THREE]
　　#pragma inline
main()
{
　　long　　start1;
　　long end1;
　　long　　start2;
　　long end2;
　　start1 = clock();
asm　　 P386
asm　　 mov eax,10000000
asm　　 lea ebx,loop1
asm　　 loop1:　
asm　　 dec eax
asm　　 jz　loop1e
asm　　 jmp ebx
loop1e:
　　start2 = end1 = clock();
asm　　 mov eax,10000000
asm　　 lea ebx,loop2
asm　　 nop
asm　　 loop2:
asm　　 dec eax
asm　　 jz　loop2e
asm　　 jmp ebx
loop2e:
　　end2 = clock();
　　 printf("misaligned loop time = %d, aligned loop time =%d
",
　　(int)(end1-start1), (int)(end2-start2));
　　return;
}