CPUID : DES INFORMATIONS SUR VOTRE PROCESSEUR (INTEL ET AMD)

//ce code n'est pas la totalité de la source
// ProcessorInfo.cpp : définit le point d'entrée pour l'application DLL.
//

//#include "stdio.h"
#include "ProcessorInfo.h"

//Teste si CPUID est présent
BOOL WINAPI IsCPUIDAvailable()
{
	//premiere méthode
	/*__asm {
		PUSH EBX
		PUSHFD
		POP EAX
		MOV EBX,EAX
		XOR EAX,0x00200000
		PUSH EAX
		POPFD
		PUSHFD
		POP EAX
		CMP EAX,EBX
		JE unsupported
		XOR EAX,EAX
		MOV EAX,1
		JMP fin
		
unsupported:
		XOR EAX,EAX

fin:
		POP EBX
	}*/
	//seconde méthode
	__try
	{
		__asm{
			XOR EAX,EAX
			XOR EBX,EBX
			XOR ECX,ECX
			XOR EDX,EDX
			CPUID
		}
	}
	__except(EXCEPTION_EXECUTE_HANDLER)
	{
		return FALSE;
	}
	return TRUE;
}

//retourne la valeur max de EAX pour CPUID
//ou 0 si CPUID n'est pas présent
_declspec(naked) DWORD WINAPI GetMaxCPUIDValue()
{
	//DWORD dwMaxCPUIDValue=0;
	//if (IsCPUIDAvailable()==TRUE)
	//{
		__asm {
			PUSH EBP
			MOV EBP,ESP
			CALL IsCPUIDAvailable
			TEST EAX,EAX
			JE No_CPUID

			PUSH EBX
			XOR EAX,EAX
			XOR EBX,EBX
			XOR ECX,ECX
			XOR EDX,EDX
			CPUID //0
			//MOV dwMaxCPUIDValue,EAX
			POP EBX
			POP EBP
			RET
No_CPUID:
			XOR EAX,EAX
			POP EBP
			RET
	}
	//}
	//return dwMaxCPUIDValue;
}

//retourne la valeur maximum de EAX pour CPUID extended
//ou 0 si CPUID n'est pas présent
_declspec(naked) DWORD WINAPI GetMaxCPUIDExtendedValue()
{
	//DWORD dwMaxCPUIDExValue=0;
	//if (IsCPUIDAvailable()==TRUE)
	//{
		__asm {
			PUSH EBP
			MOV EBP,ESP
			CALL IsCPUIDAvailable
			TEST EAX,EAX
			JE No_CPUID

			PUSH EBX
			XOR EAX,EAX
			XOR EBX,EBX
			XOR ECX,ECX
			XOR EDX,EDX
			MOV EAX,0x80000000
			CPUID //0x80000000
			//MOV dwMaxCPUIDExValue,EAX
			POP EBX
			POP EBP
			RET
No_CPUID:
			XOR EAX,EAX
			POP EBP
			RET
	}
	//}
	//return dwMaxCPUIDExValue;
}

_declspec(naked) BOOL WINAPI GetCPUVendorID(char* lpszVendorID,DWORD* lpdwMaxCPUIDValue)
{
//	DWORD REGEBX,REGECX,REGEDX;
//	if (IsCPUIDAvailable()==TRUE)
//	{
		__asm {
			PUSH EBP
			MOV EBP,ESP
			CALL IsCPUIDAvailable
			TEST EAX,EAX
			JE No_CPUID

			PUSH EBX
			XOR EAX,EAX
			XOR EBX,EBX
			XOR ECX,ECX
			XOR EDX,EDX
			CPUID //0
			//copie les données
			PUSH EDI
			MOV EDI,[lpdwMaxCPUIDValue]
			MOV [EDI],EAX
			//MOV REGEBX,EBX
			//MOV REGECX,ECX
			//MOV REGEDX,EDX
			CMP [lpszVendorID],0
			JE No_CPUID
			MOV EDI,[lpszVendorID]
			MOV [EDI],EBX
			MOV [EDI+4],EDX
			MOV [EDI+8],ECX
			MOV [EDI+12],0
			MOV EAX,1
			POP EDI
			POP EBX
			POP EBP
			RET 8
No_CPUID:
			XOR EAX,EAX
			POP EBP
			RET 8
	}
		//si le tampon passé à la fontion est correcte
		//if (lpszVendorID)
		//{
			//on copie la chaine
			//CopyMemory(lpszVendorID,&REGEBX,4);
			//CopyMemory(lpszVendorID+4,&REGEDX,4);
			//CopyMemory(lpszVendorID+8,&REGECX,4);
			//lpszVendorID[12]=0;
		//}
		//return TRUE;
	//}
	//else
	//{
	//	return FALSE;
	//}
}
//renvoie les caractéristiques standards
_declspec(naked) BOOL WINAPI GetProcessorStdFeatures(DWORD* FeatureFlags)
{
	//if (IsCPUIDAvailable()==TRUE)
	//{
		//CPUID 1
		//if (GetMaxCPUIDValue() >= 1)
		//{
			__asm {
				PUSH EBP
				MOV EBP,ESP
				CALL IsCPUIDAvailable
				TEST EAX,EAX
				JE No_CPUID
				
				CALL GetMaxCPUIDValue
				CMP EAX,1
				JB No_CPUID

				PUSH EBX
				XOR EAX,EAX
				XOR EBX,EBX
				XOR ECX,ECX
				XOR EDX,EDX
				MOV EAX,1
				CPUID //1
				//on copie les données
				MOV EAX,[FeatureFlags]
				MOV [EAX],EDX
				POP EBX
			MOV EAX,1
			POP EBP
			RET 4
No_CPUID:
			XOR EAX,EAX
			POP EBP
			RET 4
			}
/*			return TRUE;
		}
		else
		{
			return FALSE;
		}
	}
	else
	{
		return FALSE;
	}*/
}

//renvoie la signature du prcesseur
BOOL WINAPI GetProcessorSignature(Signature* ProcSignature)
{
//#pragma warning (disable : 4244)
	DWORD REGEAX,REGEBX;
	if (IsCPUIDAvailable()==TRUE)
	{
		//CPUID 1
		if (GetMaxCPUIDValue() >= 1)
		{
			__asm {
				PUSH EBX
				XOR EAX,EAX
				XOR EBX,EBX
				XOR ECX,ECX
				XOR EDX,EDX
				MOV EAX,1
				CPUID //1
				//on copie les données
				MOV REGEAX,EAX
				MOV REGEBX,EBX
				POP EBX
			}
			//si le tampon passé est correct
			if (ProcSignature)
			{
				//on met en forme les données
				ProcSignature->SteppingID = (REGEAX & 0x0000000F);
				ProcSignature->ModelNumber = ((REGEAX>>4) & 0x0000000F);
				ProcSignature->FamilyCode = ((REGEAX>>8) & 0x0000000F);
				ProcSignature->INTELProcessorType = ((REGEAX>>12) & 0x00000003);
				ProcSignature->ExtendedModel = ((REGEAX>>16) & 0x0000000F);
				ProcSignature->ExtendedFamily = ((REGEAX>>20) & 0x000000FF);

				ProcSignature->BrandID = (REGEBX & 0xF);
				ProcSignature->CLFLUSHLineSize = ((REGEBX>>8) & 0xF);
				ProcSignature->CountOfLogicalProcessors = ((REGEBX>>16) & 0xF);
				ProcSignature->APICID = ((REGEBX>>24) & 0xF);
			}

				return TRUE;
		}
		else
		{
			return FALSE;
		}
	}
	else
	{
		return FALSE;
	}
}

//renvoie le nom du processeur
BOOL WINAPI GetProcessorNameString(char* lpszProcName)
{
	DWORD REGEAX,REGEBX,REGECX,REGEDX;
	if (IsCPUIDAvailable()==TRUE)
	{
		//CPUID 0x80000004
		if (GetMaxCPUIDExtendedValue() >=4)
		{
			for (DWORD i=2;i<4;i++)
			{
				_asm {
					PUSH EBX
					XOR EAX,EAX
					XOR EBX,EBX
					XOR ECX,ECX
					XOR EDX,EDX
					MOV EAX,0x80000000
					OR EAX,i
					CPUID //0x80000004
					//on copie les données
					MOV REGEAX,EAX
					MOV REGEBX,EBX
					MOV REGECX,ECX
					MOV REGEDX,EDX
					POP EBX
				}
				//si le tampon est correcte
				if (lpszProcName)
				{
					//on copie le nom dans le tampon
					CopyMemory(lpszProcName + (i-2) * 16,&REGEAX,4);
					CopyMemory(lpszProcName + (i-2) * 16 + 4,&REGEBX,4);
					CopyMemory(lpszProcName + (i-2) * 16 + 8,&REGECX,4);
					CopyMemory(lpszProcName + (i-2) * 16 + 12,&REGEDX,4);
					REGEAX=REGEBX=REGECX=REGEDX=0;
				}
			}
			return TRUE;
		}
		else
		{
			return FALSE;
		}
	}
	else
	{
		return FALSE;
	}
}

//permet de connaitre les résultats dans les registres du processeur suite à un CPUID
_declspec(naked) BOOL WINAPI GetCPUIDResult(DWORD* REGEAX,DWORD* REGEBX,DWORD* REGECX,DWORD* REGEDX)
{
/*	if (IsCPUIDAvailable() == TRUE)
	{*/
		_asm {
			PUSH EBP
			MOV EBP,ESP
			CALL IsCPUIDAvailable
			TEST EAX,EAX
			XOR EAX,EAX
			JE No_CPUID

			PUSH EBX
			PUSH EDI
			XOR EAX,EAX
			XOR EBX,EBX
			XOR ECX,ECX
			XOR EDX,EDX
			//on copie REGEAX dans EAX
			MOV EAX,[REGEAX]
			MOV EAX,[EAX]
			//on execute CPUID
			CPUID
			//on copie l'adresse de *REGEAX
			MOV EDI,[REGEAX]
			//si le pointeur est nul
			TEST EDI,EDI
			JE Fin
			//on copie EAX dans REGEAX
			MOV [EDI],EAX
			//pareil pour EBX,ECX,EDX
			MOV EDI,[REGEBX]
			TEST EDI,EDI
			JE Fin
			MOV [EDI],EBX
			MOV EDI,[REGECX]
			TEST EDI,EDI
			JE Fin
			MOV [EDI],ECX
			MOV EDI,[REGEDX]
			TEST EDI,EDI
			JE Fin
			MOV [EDI],EDX
FIN:
			MOV EAX,1
No_CPUID:
			POP EDI
			POP EBX
			POP EBP
			RET 16
		}
/*		return TRUE;
	}
	else
	{
		return FALSE;
	}*/
}