开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
vxShow.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：24k
源码类别：

VxWorks

开发平台：

C/C++

vxShow.c：源码内容
  1. /* vxShow.c - Intel Architecture processor show routines */
  3. /* Copyright 1984-2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01g,12mar02,pai  Add an initialization routine for configuring the show
  10.                  routines into a build configuration (SPR 74103).  Added
  11.                  vxSseShow() routine and updated documentation.
  12. 01f,07mar02,hdn  updated with AP485 rev-019 for HTT (spr 73359)
  13. 01e,20nov01,hdn  doc clean up for 5.5
  14. 01d,07nov01,hdn  added header file vxI86Lib.h to shut off the warning
  15. 01c,01nov01,hdn  added vxDrShow() to see the debug registers
  16. 01b,11oct01,hdn  uncommented out the "Fast System Call" printing
  17. 01a,14aug01,hdn  taken from T31 ver 01h, added PENTIUM4 support
  18. */
  20. /*
  21. DESCRIPTION
  22. This library contains routines for printing various types of information
  23. on Intel Architecture CPUs.
  25. To use these routines, install the library using the vxShowInit()
  26. routine, which is called automatically when either of the following
  27. configuration methods is employed:
  29. .iP
  30. INCLUDE_SHOW_ROUTINES is defined in a BSP config.h file for
  31. command-line builds.
  33. .iP
  34. The INCLUDE_SHOW_ROUTINES Component is selected for Tornado
  35. Project Facility builds.
  36. .LP
  38. Included in this library is a routine for reporting details on Intel
  39. Architecture 80x86 and Pentium generation processors and coprocessors.
  40. This vxCpuShow() routine is essentially a VxWorks implementation of the
  41. code found in the Intel Application Note, "AP-485, Intel Processor
  42. Identification and the CPUID Instruction".  The vxCpuShow() routine may
  43. be useful for determining specific features found on the target processor
  44. upon which VxWorks is running.
  46. In addition to the vxCpuShow() routine, there are routines for showing
  47. processer register contents.  Some of these routines show certain processor
  48. registers independent of any task context, while others show register
  49. values associated with a particular task context.
  51. There is a simple routine for showing the contents of the processor debug
  52. registers.  The debug registers (DR0 through DR7) control, and allow
  53. monitoring of, the processor's debugging operations.
  55. This library provides a routine for showing a task's optional Streaming
  56. SIMD Extension (SSE) register context.  Target-based task information
  57. routines, such as ti(), will display a task's SSE context, if any, when
  58. this library is built into a VxWorks system.
  60. SEE ALSO:
  61. .pG "Configuration"
  62. */
  65. /* includes */
  67. #include "vxWorks.h"
  68. #include "regs.h"
  69. #include "vxLib.h"
  70. #include "stdio.h"
  71. #include "string.h"
  72. #include "taskLib.h"
  73. #include "fioLib.h"
  74. #include "fppLib.h"
  75. #include "arch/i86/pentiumLib.h"
  76. #include "private/funcBindP.h"
  79. /* defines */
  81. #define FPU_FLAG 0x00000001 /* floating point unit on chip */
  82. #define VME_FLAG  0x00000002 /* virtual mode extension */
  83. #define DE_FLAG  0x00000004 /* debugging extension */
  84. #define PSE_FLAG  0x00000008 /* page size extension */
  85. #define TSC_FLAG  0x00000010 /* time stamp counter */
  86. #define MSR_FLAG  0x00000020 /* model specific register */
  87. #define PAE_FLAG  0x00000040 /* physical address extension */
  88. #define MCE_FLAG  0x00000080 /* machine check exception */
  89. #define CX8_FLAG  0x00000100 /* CMPXCHG8 instruction supported */
  90. #define APIC_FLAG  0x00000200 /* on-chip APIC hardware support */
  91. #define SEP_FLAG  0x00000800 /* fast system call */
  92. #define MTRR_FLAG  0x00001000 /* memory type range registers */
  93. #define PGE_FLAG  0x00002000 /* page global enable */
  94. #define MCA_FLAG  0x00004000 /* machine check architecture */
  95. #define CMOV_FLAG  0x00008000 /* conditional move instruction */
  96. #define PAT_FLAG  0x00010000 /* page attribute table */
  97. #define PSE36_FLAG  0x00020000 /* 36-bit page size extension */
  98. #define PSNUM_FLAG  0x00040000 /* processor serial no is enabled */
  99. #define CLFLUSH_FLAG  0x00080000 /* CLFLUSH instruction supported */
  100. #define DTS_FLAG  0x00200000 /* Debug Trace Store */
  101. #define ACPI_FLAG  0x00400000 /* ACPI registers in MSR space */
  102. #define MMX_FLAG  0x00800000 /* IA MMX technology supported */
  103. #define FXSR_FLAG  0x01000000 /* fast floating point save, restore */
  104. #define SSE_FLAG  0x02000000 /* Streaming SIMD Extension */
  105. #define SSE2_FLAG  0x04000000 /* Streaming SIMD Extension 2 */
  106. #define SS_FLAG  0x08000000 /* Self Snoop */
  107. #define TM_FLAG  0x20000000 /* Thermal Monitor */
  108. #define HTT_FLAG  0x10000000 /* Hyper Threading Technology */
  110. #define BRAND_TABLE_SIZE 10 /* brand table size */
  112. typedef struct brand_entry /* brand table entry */
  113. {
  114. long brand_value; /* brand id */
  115. char * brand_string; /* corresponding brand name */
  116. } BRAND_ENTRY;
  119. /* externals */
  121. IMPORT CPUID sysCpuId;
  122. IMPORT int sysProcessor;
  123. IMPORT int sysCoprocessor;
  126. /* locals */
  128. #if FALSE /* Unlike AE, 5.5 does not have TSS per task */
  130. LOCAL const char * tssFmt0 = "n
  131. link : 0x%08xn
  132. esp0 : 0x%08x   ss0 : 0x%08xn
  133. esp1 : 0x%08x   ss1 : 0x%08xn
  134. esp2 : 0x%08x   ss2 : 0x%08xn
  135.  cr3 : 0x%08x   eip : 0x%08x eflags : 0x%08xn
  136.  eax : 0x%08x   ecx : 0x%08x    edx : 0x%08x    ebx : 0x%08xn
  137.  esp : 0x%08x   ebp : 0x%08x    esi : 0x%08x    edi : 0x%08xn
  138.   cs : 0x%08x    ds : 0x%08x     ss : 0x%08xn
  139.   es : 0x%08x    fs : 0x%08x     gs : 0x%08xn
  140.  ldt : 0x%08x tflag : 0x%08x iomapb : 0x%08xn";
  142. #endif
  144. LOCAL char intelId[] = "GenuineIntel";
  146. LOCAL BRAND_ENTRY brand_table [BRAND_TABLE_SIZE] =
  147. {
  148. {0x01, " Genuine Intel Celeron(R) CPU"},
  149. {0x02, " Genuine Intel Pentium(R) III CPU"},
  150. {0x03, " Genuine Intel Pentium(R) III Xeon(TM) CPU"},
  151. {0x04, " Genuine Intel Pentium(R) III CPU"},
  152. {0x06, " Genuine Mobile Intel Pentium(R) III CPU-M"},
  153. {0x07, " Genuine Mobile Intel Celeron(R) CPU"},
  154. {0x08, " Genuine Intel Pentium(R) 4 CPU"},
  155. {0x09, " Genuine Intel Pentium(R) 4 CPU"},
  156. {0x0B, " Genuine Intel Xeon(TM) CPU"},
  157. {0x0E, " Genuine Intel Xeon(TM) CPU"}
  158. };
  160. LOCAL const char * const dregFmt = "n
  161. dr0 : 0x%08x   dr1 : 0x%08x    dr2 : 0x%08x    dr3 : 0x%08xn
  162. dr4 : 0x%08x   dr5 : 0x%08x    dr6 : 0x%08x    dr7 : 0x%08xn";
  165. /* forward declarations */
  167. void vxCpuShow (void);
  168. void vxDrShow (void);
  169. void vxSseShow (int);
  173. /*******************************************************************************
  174. *
  175. * vxShowInit - initialize the Intel 80x86 and Pentium show routines
  176. *
  177. * This routine links Intel 80x86 and Pentium family show routines into
  178. * the VxWorks system.  It is called automatically when the show facility
  179. * is configured into VxWorks using either of the following methods:
  180. *
  181. * .iP
  182. * INCLUDE_SHOW_ROUTINES is defined in a BSP config.h file for
  183. * command-line builds.
  184. *
  185. * .iP
  186. * The INCLUDE_SHOW_ROUTINES Component is selected for Tornado
  187. * Project Facility builds.
  188. * .LP
  189. *
  190. * INTERNAL
  191. * This routine could be called before the RTOS is fully initialized.  The
  192. * routine is used primarilly as a linkage symbol to pull the library into
  193. * a build.  Other initialization should be very simple.  For example, set
  194. * the initial values for file-scope and global variables.  Do not try to
  195. * allocate memory in this routine.  Do not call VxWorks kernel routines.
  196. *
  197. * The <sysCpuId> structure is populated by calling sysCpuProbe().  Thus,
  198. * sysCpuProbe() must be called if there is to be any hope of correctly
  199. * determining whether to bind <_func_sseTaskRegsShow> to the SSE show
  200. * routine.
  201. *
  202. * RETURNS: N/A
  203. */
  205. void vxShowInit (void)
  206.     {
  207.     const int features_edx = sysCpuId.featuresEdx;
  209.     /* Bind the Streaming SIMD register show routine ? */
  211.     if ((features_edx & SSE_FLAG) || (features_edx & SSE2_FLAG))
  212.         {
  213.         _func_sseTaskRegsShow = (FUNCPTR) vxSseShow;
  214.         }
  215.     }
  217. #if FALSE /* Unlike AE, 5.5 does not have TSS per task */
  219. /*******************************************************************************
  220. *
  221. * vxTssShow - show content of the TSS (Task State Segment)
  222. *
  223. * This routine shows content of the TSS (Task State Segment)
  224. *
  225. * RETURNS: N/A
  226. *
  227. * NOMANUAL
  228. */
  230. void vxTssShow
  231.     (
  232.     int  tid                     /* task ID of task */
  233.     )
  234.     {
  235.     WIND_TCB * pTcb; /* pointer to TCB */
  236.     TSS * pTss; /* pointer to TSS */
  238.     if (tid == 0)
  239. pTcb = taskIdCurrent;
  240.     else
  241. pTcb = (WIND_TCB *) tid;
  243.     pTss = pTcb->tss; /* get the address of TSS */
  245.     printf (tssFmt0,     pTss->link,   pTss->esp0,  pTss->ss0,
  246.     pTss->esp1,  pTss->ss1,    pTss->esp2,  pTss->ss2,
  247.     pTss->cr3,   pTss->eip,    pTss->eflags,
  248.     pTss->eax,   pTss->ecx,    pTss->edx,   pTss->ebx,
  249.     pTss->esp,   pTss->ebp,    pTss->esi,   pTss->edi,
  250.     pTss->cs,    pTss->ds,     pTss->ss,
  251.     pTss->es,    pTss->fs,     pTss->gs,
  252.     pTss->ldt,   pTss->tflag,  pTss->iomapb);
  253.     }
  255. #endif
  257. /*******************************************************************************
  258. *
  259. * vxCpuShow - show CPU type, family, model, and supported features.
  260. *
  261. * This routine prints information on Intel Architecture processors
  262. * and coprocessors, including CPU type, family, model, and supported
  263. * features.
  264. *
  265. * INTERNAL
  266. * This source code came from Intel AP-485 and kept as is for ease of
  267. * future upgrade / maintenance.
  268. *
  269. * RETURNS: N/A
  270. */
  272. void vxCpuShow (void)
  273.     {
  274.     char cpu_type = (sysCpuId.signature & CPUID_FAMILY) >> 8; 
  275.     char fpu_type = 0;
  276.     int  cpu_signature = sysCpuId.signature; 
  277.     int  features_ebx = sysCpuId.featuresEbx;
  278. #if FALSE
  279.     int  features_ecx = sysCpuId.featuresEcx;
  280. #endif /* FALSE */
  281.     int  features_edx = sysCpuId.featuresEdx;
  282.     int  cache_eax = sysCpuId.cacheEax;  
  283.     int  cache_ebx = sysCpuId.cacheEbx;
  284.     int  cache_ecx = sysCpuId.cacheEcx;
  285.     int  cache_edx = sysCpuId.cacheEdx;
  286.     char cpuid_flag = (sysCpuId.highestValue != 0); 
  287.     char intel_CPU = FALSE; 
  288.     char vendor_id[12]; 
  289.     int  cache_temp; 
  290.     int  celeron_flag;
  291.     int  pentiumxeon_flag;
  292.     char brand_string[48];
  293.     int  brand_index = 0;
  296.     if (sysProcessor == NONE)
  297.         {
  298. printf ("sysCpuProbe() is not executed.n");
  299. return;
  300. }
  302.     if ((sysCoprocessor == X86FPU_387) || (sysCoprocessor == X86FPU_487))
  303.         fpu_type = 3;
  305.     bcopy ((char *)sysCpuId.vendorId, vendor_id, sizeof (vendor_id));
  306.     bcopy ((char *)sysCpuId.brandString, brand_string, sizeof (brand_string));
  308.     if (strncmp (intelId, (char *)sysCpuId.vendorId, sizeof (vendor_id)) == 0)
  309. intel_CPU = TRUE;
  311.     printf ("This system has a"); 
  312.     if (cpuid_flag == 0) 
  313.         {
  314. switch (cpu_type) 
  315.     { 
  316. #if FALSE
  317.     case 0: 
  318. printf ("n 8086/8088 CPU"); 
  319. if (fpu_type) 
  320.     printf (" and an 8087 math coCPU"); 
  321. break; 
  323.     case 2: 
  324. printf ("n 80286 CPU"); 
  325. if (fpu_type) 
  326.     printf (" and an 80287 math coCPU"); 
  327. break; 
  328. #endif /* FALSE */
  330.     case 3: 
  331. printf ("n 80386 CPU"); 
  332. if (fpu_type == 2) 
  333.     printf (" and an 80287 math coCPU"); 
  334. else if (fpu_type) 
  335.     printf (" and an 80387 math coCPU"); 
  336. break; 
  338.     case 4: 
  339. if (fpu_type) 
  340.     printf ("n 80486DX, 80486DX2 CPU or 80487SX math coCPU"); 
  341. else 
  342.     printf ("n 80486SX CPU"); 
  343. break; 
  345.     default: 
  346. printf ("n unknown CPU"); 
  347.     }
  348.         } 
  349.     else 
  350.         { 
  352. /* using cpuid instruction */ 
  354. if (brand_string[0])
  355.     {
  356.     brand_index = 0;
  357.     while ((brand_string[brand_index] == ' ') && (brand_index < 48))
  358. brand_index++; /* remove leading Space */
  359.     if (brand_index != 48)
  360. printf ("%s", &brand_string[brand_index]);
  361.     }
  363. if (intel_CPU) 
  364.     { 
  365.     if (cpu_type == 4) 
  366.         { 
  367. switch ((cpu_signature >> 4) & 0xf) 
  368.     { 
  369.     case 0: 
  370.     case 1: 
  371. printf (" Genuine Intel486(TM) DX CPU");
  372.         break; 
  374.     case 2: 
  375. printf (" Genuine Intel486(TM) SX CPU"); 
  376. break; 
  378.     case 3: 
  379. printf (" Genuine IntelDX2(TM) CPU"); 
  380. break; 
  382.     case 4: 
  383. printf (" Genuine Intel486(TM) CPU"); 
  384. break; 
  386.     case 5: 
  387. printf (" Genuine IntelSX2(TM) CPU"); 
  388. break; 
  390.     case 7: 
  391. printf (" Genuine WriteBack Enhanced IntelDX2(TM) CPU");
  392. break; 
  394.     case 8: 
  395. printf (" Genuine IntelDX4(TM) CPU"); 
  396. break; 
  398.     default: 
  399. printf (" Genuine Intel486(TM) CPU"); 
  400.     }
  401.         } 
  402.     else if (cpu_type == 5) 
  403. printf (" Genuine Intel Pentium(R) CPU"); 
  404.     else if ((cpu_type == 6) && (((cpu_signature >> 4) & 0xf) == 1)) 
  405. printf (" Genuine Intel Pentium(R) Pro CPU"); 
  406.     else if ((cpu_type == 6) && (((cpu_signature >> 4) & 0xf) == 3)) 
  407. printf (" Genuine Intel Pentium(R) II CPU, model 3"); 
  408.     else if (((cpu_type == 6) && (((cpu_signature >> 4) & 0xf) == 5)) ||
  409.      ((cpu_type == 6) && (((cpu_signature >> 4) & 0xf) == 7)))
  410. { 
  411. celeron_flag = 0; 
  412. pentiumxeon_flag = 0; 
  413. cache_temp = cache_eax & 0xFF000000; 
  414. if (cache_temp == 0x40000000) 
  415.     celeron_flag = 1; 
  416. if ((cache_temp >= 0x44000000) && (cache_temp <= 0x45000000)) 
  417.     pentiumxeon_flag = 1; 
  419. cache_temp = cache_eax & 0xFF0000; 
  420. if (cache_temp == 0x400000) 
  421.     celeron_flag = 1; 
  422. if ((cache_temp >= 0x440000) && (cache_temp <= 0x450000)) 
  423.     pentiumxeon_flag = 1;
  425. cache_temp = cache_eax & 0xFF00; 
  426. if (cache_temp == 0x4000) 
  427.     celeron_flag = 1; 
  428. if ((cache_temp >= 0x4400) && (cache_temp <= 0x4500))
  429.     pentiumxeon_flag = 1; 
  431. cache_temp = cache_ebx & 0xFF000000; 
  432. if (cache_temp == 0x40000000) 
  433.     celeron_flag = 1; 
  434. if ((cache_temp >= 0x44000000) && (cache_temp <= 0x45000000)) 
  435.     pentiumxeon_flag = 1; 
  437. cache_temp = cache_ebx & 0xFF0000; 
  438. if (cache_temp == 0x400000) 
  439.     celeron_flag = 1; 
  440. if ((cache_temp >= 0x440000) && (cache_temp <= 0x450000)) 
  441.     pentiumxeon_flag = 1;
  443. cache_temp = cache_ebx & 0xFF00; 
  444. if (cache_temp == 0x4000) 
  445.     celeron_flag = 1; 
  446. if ((cache_temp >= 0x4400) && (cache_temp <= 0x4500)) 
  447.     pentiumxeon_flag = 1; 
  449. cache_temp = cache_ebx & 0xFF; 
  450. if (cache_temp == 0x40) 
  451.     celeron_flag = 1; 
  452. if ((cache_temp >= 0x44) && (cache_temp <= 0x45)) 
  453.     pentiumxeon_flag = 1;
  455. cache_temp = cache_ecx & 0xFF000000; 
  456. if (cache_temp == 0x40000000) 
  457.     celeron_flag = 1; 
  458. if ((cache_temp >= 0x44000000) && (cache_temp <= 0x45000000)) 
  459.     pentiumxeon_flag = 1; 
  461. cache_temp = cache_ecx & 0xFF0000; 
  462. if (cache_temp == 0x400000) 
  463.     celeron_flag = 1; 
  464. if ((cache_temp >= 0x440000) && (cache_temp <= 0x450000)) 
  465.     pentiumxeon_flag = 1;
  467. cache_temp = cache_ecx & 0xFF00; 
  468. if (cache_temp == 0x4000) 
  469.     celeron_flag = 1; 
  470. if ((cache_temp >= 0x4400) && (cache_temp <= 0x4500)) 
  471.     pentiumxeon_flag = 1; 
  473. cache_temp = cache_ecx & 0xFF; 
  474. if (cache_temp == 0x40) 
  475.     celeron_flag = 1; 
  476. if ((cache_temp >= 0x44) && (cache_temp <= 0x45)) 
  477.     pentiumxeon_flag = 1;
  479. cache_temp = cache_edx & 0xFF000000; 
  480. if (cache_temp == 0x40000000) 
  481.     celeron_flag = 1; 
  482. if ((cache_temp >= 0x44000000) && (cache_temp <= 0x45000000)) 
  483.     pentiumxeon_flag = 1;
  485. cache_temp = cache_edx & 0xFF0000; 
  486. if (cache_temp == 0x400000) 
  487.     celeron_flag = 1; 
  488. if ((cache_temp >= 0x440000) && (cache_temp <= 0x450000)) 
  489.     pentiumxeon_flag = 1; 
  491. cache_temp = cache_edx & 0xFF00; 
  492. if (cache_temp == 0x4000) 
  493.     celeron_flag = 1; 
  494. if ((cache_temp >= 0x4400) && (cache_temp <= 0x4500)) 
  495.     pentiumxeon_flag = 1; 
  497. cache_temp = cache_edx & 0xFF; 
  498. if (cache_temp == 0x40) 
  499.     celeron_flag = 1; 
  500. if ((cache_temp >= 0x44) && (cache_temp <= 0x45)) 
  501.     pentiumxeon_flag = 1;
  503. if (celeron_flag == 1) 
  504.     printf (" Genuine Intel Celeron(R) CPU, model 5"); 
  505. else 
  506.     { 
  507.     if (pentiumxeon_flag == 1) 
  508.         { 
  509. printf (" Genuine Intel Pentium(R) "); 
  510. if (((cpu_signature >> 4) & 0x0f) == 5) 
  511.     printf ("II Xeon(TM) CPU"); 
  512. else 
  513.     printf ("III Xeon(TM) CPU");
  514. printf (" model 7");
  515.         } 
  516.     else 
  517.         { 
  518. if (((cpu_signature >> 4) & 0x0f) == 5)
  519.     { 
  520.     printf (" Genuine Intel Pentium(R) II CPU, "); 
  521.     printf ("model 5 or Intel Pentium(R) II Xeon(TM)");
  522.     printf (" CPU");
  523.     } 
  524. else 
  525.     { 
  526.     printf (" Genuine Intel Pentium(R) III CPU, ");
  527.     printf ("model 7 or Intel Pentium(R) III Xeon(TM)");
  528.     printf (" CPU, model 7");
  529.     }
  530.         }
  531.     }
  532.         }
  533.     else if ((cpu_type == 6) && (((cpu_signature >> 4) & 0xf) == 6))
  534. printf (" Genuine Intel Celeron(R) CPU, model 6");
  535.     else if ((features_ebx & 0xff) != 0) 
  536. {
  537. while ((brand_index < BRAND_TABLE_SIZE) &&
  538.        ((features_ebx & 0xff) != 
  539.        brand_table[brand_index].brand_value))
  540.     brand_index++;
  541. if (brand_index < BRAND_TABLE_SIZE)
  542.     {
  543.     if ((cpu_signature == 0x6B1) &&
  544.         (brand_table[brand_index].brand_value == 0x3))
  545. printf (" Genuine Intel Celeron(R) CPU");
  546.     else
  547.         printf ("%s", brand_table[brand_index].brand_string);
  548.     }
  549. else
  550.     printf ("n unknown Genuine Intel CPU"); 
  551. }
  552.     else 
  553. printf ("n unknown Genuine Intel CPU"); 
  555.     printf ("nProcessor Family: %X", cpu_type);
  556.     if (cpu_type == 0xf)
  557. printf ("n Extended Family: %x",(cpu_signature >> 20) & 0xff);
  558.     printf ("nModel: %X", (cpu_signature>>4) & 0xf); 
  559.     if (((cpu_signature >> 4) & 0xf) == 0xf)
  560. printf ("n Extended Model: %x", (cpu_signature >> 16) & 0xf);
  561.     printf ("nStepping: %Xn", cpu_signature & 0xf); 
  563.     if (cpu_signature & 0x1000) 
  564. printf ("nThe CPU is an OverDrive(R) CPU"); 
  565.     else if (cpu_signature & 0x2000) 
  566. printf ("nThe CPU is the upgrade CPU in a dual CPU system"); 
  567.     if (features_edx & FPU_FLAG) 
  568. printf ("nThe CPU contains an on-chip FPU"); 
  569.     if (features_edx & VME_FLAG) 
  570. printf ("nThe CPU supports Virtual Mode Extensions");
  571.     if (features_edx & DE_FLAG) 
  572. printf ("nThe CPU supports the Debugging Extensions"); 
  573.     if (features_edx & PSE_FLAG) 
  574. printf ("nThe CPU supports Page Size Extensions"); 
  575.     if (features_edx & TSC_FLAG) 
  576. printf ("nThe CPU supports Time Stamp Counter"); 
  577.     if (features_edx & MSR_FLAG) 
  578. printf ("nThe CPU supports Model Specific Registers"); 
  579.     if (features_edx & PAE_FLAG) 
  580. printf ("nThe CPU supports Physical Address Extension");
  581.     if (features_edx & MCE_FLAG) 
  582. printf ("nThe CPU supports Machine Check Exceptions");
  583.     if (features_edx & CX8_FLAG) 
  584. printf ("nThe CPU supports the CMPXCHG8B instruction");
  585.     if (features_edx & APIC_FLAG)
  586. printf ("nThe CPU contains an on-chip APIC");
  587.     if (features_edx & SEP_FLAG)
  588.         { 
  589. if ((cpu_type == 6) && ((cpu_signature & 0xff) < 0x33))
  590.     printf ("nThe CPU does not support the Fast System Call");
  591. else 
  592.     {
  593. #if FALSE /* no system call in T2.2 */
  594.          long long sysenterCs;
  595.          long long sysenterEsp;
  596.          long long sysenterEip;
  598.     printf ("nThe CPU supports the Fast System Call");
  599.     pentiumMsrGet (MSR_SYSENTER_CS, &sysenterCs);
  600.     pentiumMsrGet (MSR_SYSENTER_ESP, &sysenterEsp);
  601.     pentiumMsrGet (MSR_SYSENTER_EIP, &sysenterEip);
  602.     printf (":  CS=0x%x, ESP=0x%x, EIP=0x%x", (int)sysenterCs,
  603.     (int)sysenterEsp, (int)sysenterEip);
  604. #else
  605.     printf ("nThe CPU supports the Fast System Call");
  606. #endif /* FALSE */
  607.     }
  608.         }
  609.     if (features_edx & MTRR_FLAG) 
  610. printf ("nThe CPU supports the Memory Type Range Registers"); 
  611.     if (features_edx & PGE_FLAG) 
  612. printf ("nThe CPU supports Page Global Enable"); 
  613.     if (features_edx & MCA_FLAG) 
  614. printf ("nThe CPU supports the Machine Check Architecture");
  615.     if (features_edx & CMOV_FLAG) 
  616. printf ("nThe CPU supports the Conditional Move Instruction");
  617.     if (features_edx & PAT_FLAG)
  618. printf ("nThe CPU supports the Page Attribute Table");
  619.     if (features_edx & PSE36_FLAG)
  620. printf ("nThe CPU supports 36-bit Page Size Extension");
  621.     if (features_edx & PSNUM_FLAG)
  622. printf ("nThe CPU supports the CPU serial number");
  623.     if (features_edx & CLFLUSH_FLAG)
  624. printf ("nThe CPU supports the CLFLUSH instruction");
  625.     if (features_edx & DTS_FLAG)
  626. printf ("nThe CPU supports the Debug Trace Store feature");
  627.     if (features_edx & ACPI_FLAG)
  628. printf ("nThe CPU supports ACPI registers in MSR space");
  629.     if (features_edx & MMX_FLAG)
  630. printf ("nThe CPU supports Intel Architecture MMX(TM)");
  631.     if (features_edx & FXSR_FLAG)
  632. printf ("nThe CPU supports the Fast FPP save and restore");
  633.     if (features_edx & SSE_FLAG)
  634. printf ("nThe CPU supports the Streaming SIMD Extensions");
  635.     if (features_edx & SSE2_FLAG)
  636. printf ("nThe CPU supports the Streaming SIMD Extensions 2");
  637.     if (features_edx & SS_FLAG)
  638. printf ("nThe CPU supports Self-Snoop");
  639.     if ((features_edx & HTT_FLAG) && 
  640. (((features_ebx >> 16) & 0x0FF) > 1))
  641. printf ("nThe CPU supports the Hyper-Threading Technology");
  642.     if (features_edx & TM_FLAG)
  643. printf ("nThe CPU supports the Thermal Monitor");
  644.     }
  645. else 
  646.     { 
  647.     printf ("t least an 80486 CPU. n"); 
  648.     printf ("It does not contain a Genuine Intel part andn");
  649.     printf ("as a result, the CPUID detection informationn"); 
  650.     printf ("cannot be determined at this time.");
  651.     }
  652.         }
  653.     printf ("n");
  654.     }
  656. /*******************************************************************************
  657. *
  658. * vxDrShow - show content of the Debug Registers 0 to 7
  659. *
  660. * This routine prints the contents of the Debug Registers 0 to 7 (DR0
  661. * through DR7) to the standard output device.  The displayed register
  662. * context is not associated with any particular task context, as this
  663. * routine will simply fetch the current content of each physical debug
  664. * register when it is called.
  665. *
  666. * Note that debug registers DR4 and DR5 are reserved when debug extensions
  667. * are enabled (when the DE flag in control register CR4 is set), and
  668. * attempts to reference the DR4 and DR5 registers cause an invalid-opcode
  669. * exception to be generated.  When debug extensions are not enabled (when
  670. * the DE flag is clear), these registers are aliased to debug registers
  671. * DR6 and DR7.
  672. *
  673. * RETURNS: N/A
  674. */
  676. void vxDrShow (void)
  677.     {
  678.     int dreg[8]; /* debug registers */
  680.     vxDrGet (&dreg[0], &dreg[1], &dreg[2], &dreg[3],
  681.           &dreg[4], &dreg[5], &dreg[6], &dreg[7]);
  683.     printf (dregFmt, dreg[0], dreg[1], dreg[2], dreg[3],
  684.           dreg[4], dreg[5], dreg[6], dreg[7]);
  685.     }
  687. /*******************************************************************************
  688. *
  689. * vxSseShow - print the contents of a task's SIMD registers
  690. *
  691. * This routine prints the contents of a task's Streaming SIMD
  692. * Extension (SSE) register context, if any, to the standard output
  693. * device.
  694. *
  695. * RETURNS: N/A
  696. */
  698. void vxSseShow
  699.     (
  700.     int taskId          /* ID of task to display SSE registers for */
  701.     )
  702.     {
  703.     const int features_edx = sysCpuId.featuresEdx;
  706.     if ((features_edx & SSE_FLAG) || (features_edx & SSE2_FLAG))
  707.         {
  708.         const FP_CONTEXT *     pFpContext;
  710.         const WIND_TCB * const pTcb = taskTcb (taskId);
  713.         if ((pTcb != NULL) && ((pFpContext = pTcb->pFpContext) != NULL))
  714.             {
  715.             const FPX_CONTEXT * const pFpxContext = &(pFpContext->u.x);
  717.             const UINT32 * pInt = (UINT32 *) &(pFpxContext->xmm[0]);
  718.             printf ("nxmm0   = %08x_%08x_%08x_%08xn",
  719.                     pInt[3], pInt[2], pInt[1], pInt[0]);
  721.             pInt = (UINT32 *) &(pFpxContext->xmm[1]);
  722.             printf ("xmm1   = %08x_%08x_%08x_%08xn",
  723.                     pInt[3], pInt[2], pInt[1], pInt[0]);
  725.             pInt = (UINT32 *) &(pFpxContext->xmm[2]);
  726.             printf ("xmm2   = %08x_%08x_%08x_%08xn",
  727.                     pInt[3], pInt[2], pInt[1], pInt[0]);
  729.             pInt = (UINT32 *) &(pFpxContext->xmm[3]);
  730.             printf ("xmm3   = %08x_%08x_%08x_%08xn",
  731.                     pInt[3], pInt[2], pInt[1], pInt[0]);
  733.             pInt = (UINT32 *) &(pFpxContext->xmm[4]);
  734.             printf ("xmm4   = %08x_%08x_%08x_%08xn",
  735.                     pInt[3], pInt[2], pInt[1], pInt[0]);
  737.             pInt = (UINT32 *) &(pFpxContext->xmm[5]);
  738.             printf ("xmm5   = %08x_%08x_%08x_%08xn",
  739.                     pInt[3], pInt[2], pInt[1], pInt[0]);
  741.             pInt = (UINT32 *) &(pFpxContext->xmm[6]);
  742.             printf ("xmm6   = %08x_%08x_%08x_%08xn",
  743.                     pInt[3], pInt[2], pInt[1], pInt[0]);
  745.             pInt = (UINT32 *) &(pFpxContext->xmm[7]);
  746.             printf ("xmm7   = %08x_%08x_%08x_%08xn",
  747.                     pInt[3], pInt[2], pInt[1], pInt[0]);
  749.             return;
  750.             }
  752.         printf ("ntask does not have SIMD contextn");
  753.         return;
  754.         }
  756.     printf ("nCPU does not support SIMDn");
  757.     }