Changeset 8cb397b2 in rtems for c/src/lib/libbsp/i386


Ignore:
Timestamp:
May 6, 2016, 10:18:28 PM (4 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
master
Children:
c3fd48d0
Parents:
fc138a10
git-author:
Chris Johns <chrisj@…> (05/06/16 22:18:28)
git-committer:
Chris Johns <chrisj@…> (05/11/16 01:45:02)
Message:

i386/pc386: Add x86 debug register support for hardware break points.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/i386/shared/comm/i386-stub.c

    rfc138a10 r8cb397b2  
    103103
    104104/*
     105 * Number of debug registers.
     106 */
     107#define NUM_DEBUG_REGISTERS 4
     108
     109/*
    105110 * Prototypes we need to avoid warnings but not going into public space.
    106111 */
     112void bsp_reset(void);
    107113void breakpoint (void);
    108114void set_debug_traps(void);
     
    159165int i386_gdb_remcomStack[STACKSIZE / sizeof (int)];
    160166int *i386_gdb_stackPtr = &i386_gdb_remcomStack[STACKSIZE / sizeof (int) - 1];
    161 
    162167
    163168static int gdb_connected;
     
    772777
    773778/*
     779 * Get/Set the DR registers.
     780 */
     781static uint32_t getDR7(void)
     782{
     783  uint32_t value = 0;
     784  asm volatile (" movl %%dr7, %0;" : "=r" (value) : : );
     785  return value;
     786}
     787
     788static void setDR7(uint32_t value)
     789{
     790  asm volatile (" movl %0, %%dr7;" : : "r" (value) : );
     791}
     792
     793static uint32_t getDR(int reg)
     794{
     795  uint32_t value = 0;
     796  switch (reg)
     797    {
     798    case 0:
     799      asm volatile (" movl %%dr0, %0;" : "=r" (value) : : );
     800      break;
     801    case 1:
     802      asm volatile (" movl %%dr1, %0;" : "=r" (value) : : );
     803      break;
     804    case 2:
     805      asm volatile (" movl %%dr2, %0;" : "=r" (value) : : );
     806      break;
     807    case 3:
     808      asm volatile (" movl %%dr3, %0;" : "=r" (value) : : );
     809      break;
     810    default:
     811      break;
     812    }
     813  return value;
     814}
     815
     816static void setDR(int reg, uint32_t addr)
     817{
     818  switch (reg)
     819    {
     820    case 0:
     821      asm volatile (" movl %0, %%dr0;" : : "r" (addr) : );
     822      break;
     823    case 1:
     824      asm volatile (" movl %0, %%dr1;" : : "r" (addr) : );
     825      break;
     826    case 2:
     827      asm volatile (" movl %0, %%dr2;" : : "r" (addr) : );
     828      break;
     829    case 3:
     830      asm volatile (" movl %0, %%dr3;" : : "r" (addr) : );
     831      break;
     832    default:
     833      break;
     834    }
     835}
     836
     837/*
    774838 * This function does all command procesing for interfacing to gdb.
    775839 *
     
    9401004          break;
    9411005
     1006        case 'Z':
     1007        case 'z':
     1008          /*
     1009           * Z1 = execute (00b)
     1010           * Z2 = write (01b)
     1011           * Z3 = read (??, need to use 11b))
     1012           * Z4 = read/write (11b)
     1013           */
     1014          ptr = &remcomInBuffer[1];
     1015          reg = *(ptr++);
     1016          if (reg == '0')
     1017            break;
     1018          printk("hbreak\n");
     1019          switch ((char) reg)
     1020            {
     1021            case '1':
     1022              reg = 0;
     1023              break;
     1024            case '2':
     1025              reg = 1;
     1026            case '3':
     1027            case '4':
     1028            default:
     1029              reg = 3;
     1030              break;
     1031            }
     1032          if (*(ptr++) == ',')
     1033            {
     1034              bool insert = remcomInBuffer[0] == 'Z';
     1035              printk("hbreak type\n", insert);
     1036              if (hexToInt (&ptr, &addr))
     1037                {
     1038                  if (*(ptr++) == ',')
     1039                    {
     1040                      uint32_t dr7;
     1041                      int i;
     1042                      hexToInt(&ptr, &length);
     1043                      dr7 = getDR7();
     1044                      for (i = 0; i < NUM_DEBUG_REGISTERS; ++i)
     1045                        {
     1046                          if ((dr7 & (2 << (i * 2))) == 0)
     1047                            {
     1048                              if (insert)
     1049                                {
     1050                                  setDR(i, addr);
     1051                                  dr7 |=
     1052                                    ((length - 1) << ((i * 2) + 18)) |
     1053                                    (reg << ((i * 2) + 16)) |
     1054                                    (2 << (i * 2));
     1055                                  setDR7(dr7);
     1056                                  printk("set DR%i to %08x\n", i, addr);
     1057                                  break;
     1058                                }
     1059                            }
     1060                          else if (!insert)
     1061                            {
     1062                              uint32_t dra = getDR(i);
     1063                              if (dra == addr)
     1064                                {
     1065                                  dr7 &= ~(2 << (i * 2));
     1066                                  setDR7(dr7);
     1067                                  printk("clear DR%i\n", i);
     1068                                  break;
     1069                                }
     1070                            }
     1071                        }
     1072                      if (insert && (i == NUM_DEBUG_REGISTERS))
     1073                        {
     1074                          ptr = 0;
     1075                        }
     1076                    }
     1077                  else
     1078                    {
     1079                      ptr = 0;
     1080                    }
     1081                }
     1082              else
     1083                {
     1084                  ptr = 0;
     1085                }
     1086            }
     1087          else
     1088            {
     1089              ptr = 0;
     1090            }
     1091
     1092          if (ptr)
     1093            strcpy (remcomOutBuffer, "OK");
     1094          else
     1095            strcpy (remcomOutBuffer, "E1");
     1096          break;
     1097
    9421098          /* Detach.  */
    9431099        case 'D':
Note: See TracChangeset for help on using the changeset viewer.