src/runtime/parse.c

   1 /* parsing for LDB monitor */
   2
   3 /*
   4  * This software is part of the SBCL system. See the README file for
   5  * more information.
   6  *
   7  * This software is derived from the CMU CL system, which was
   8  * written at Carnegie Mellon University and released into the
   9  * public domain. The software is in the public domain and is
  10  * provided with absolutely no warranty. See the COPYING and CREDITS
  11  * files for more information.
  12  */
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <ctype.h>
  17
  18 #include "sbcl.h"
  19 #if defined(LISP_FEATURE_WIN32) && defined(LISP_FEATURE_SB_THREAD)
  20 #include "pthreads_win32.h"
  21 #else
  22 #include <signal.h>
  23 #endif
  24 #include "runtime.h"
  25
  26 #if defined(LISP_FEATURE_SB_LDB)
  27
  28 #include "globals.h"
  29 #include "vars.h"
  30 #include "parse.h"
  31 #include "os.h"
  32 #include "interrupt.h"
  33 #include "lispregs.h"
  34 #include "monitor.h"
  35 #include "validate.h"
  36 #include "arch.h"
  37 #include "search.h"
  38 #include "thread.h"
  39 #include "pseudo-atomic.h"
  40
  41 #include "genesis/simple-fun.h"
  42 #include "genesis/fdefn.h"
  43 #include "genesis/symbol.h"
  44 #include "genesis/static-symbols.h"
  45
  46 static void skip_ws(char **ptr)
  47 {
  48     while (**ptr <= ' ' && **ptr != '\0')
  49         (*ptr)++;
  50 }
  51
  52 static boolean string_to_long(char *token, uword_t *value)
  53 {
  54     int base, digit;
  55     uword_t num;
  56     char *ptr;
  57
  58     if (token == 0)
  59         return 0;
  60
  61     if (token[0] == '0')
  62         if (token[1] == 'x') {
  63             base = 16;
  64             token += 2;
  65         }
  66         else {
  67             base = 8;
  68             token++;
  69         }
  70     else if (token[0] == '#') {
  71         switch (token[1]) {
  72             case 'x':
  73             case 'X':
  74                 base = 16;
  75                 token += 2;
  76                 break;
  77             case 'o':
  78             case 'O':
  79                 base = 8;
  80                 token += 2;
  81                 break;
  82             default:
  83                 return 0;
  84         }
  85     }
  86     else
  87         base = 10;
  88
  89     num = 0;
  90     ptr = token;
  91     while (*ptr != '\0') {
  92         if (*ptr >= 'a' && *ptr <= 'f')
  93             digit = *ptr + 10 - 'a';
  94         else if (*ptr >= 'A' && *ptr <= 'F')
  95             digit = *ptr + 10 - 'A';
  96         else if (*ptr >= '0' && *ptr <= '9')
  97             digit = *ptr - '0';
  98         else
  99             return 0;
 100         if (digit < 0 || digit >= base)
 101             return 0;
 102
 103         ptr++;
 104         num = num * base + digit;
 105     }
 106
 107     *value = num;
 108     return 1;
 109 }
 110
 111 static boolean lookup_variable(char *name, lispobj *result)
 112 {
 113     struct var *var = lookup_by_name(name);
 114
 115     if (var == NULL)
 116         return 0;
 117     else {
 118         *result = var_value(var);
 119         return 1;
 120     }
 121 }
 122
 123
 124 boolean more_p(char **ptr)
 125 {
 126     skip_ws(ptr);
 127
 128     if (**ptr == '\0')
 129         return 0;
 130     else
 131         return 1;
 132 }
 133
 134 char *parse_token(char **ptr)
 135 {
 136     char *token;
 137
 138     skip_ws(ptr);
 139
 140     if (**ptr == '\0')
 141         return NULL;
 142
 143     token = *ptr;
 144
 145     while (**ptr > ' ')
 146         (*ptr)++;
 147
 148     if (**ptr != '\0') {
 149         **ptr = '\0';
 150         (*ptr)++;
 151     }
 152
 153     return token;
 154 }
 155
 156 uword_t parse_number(char **ptr)
 157 {
 158     char *token = parse_token(ptr);
 159     uword_t result;
 160
 161     if (token == NULL) {
 162         printf("expected a number\n");
 163         throw_to_monitor();
 164     }
 165     else if (string_to_long(token, &result))
 166         return result;
 167     else {
 168         printf("invalid number: ``%s''\n", token);
 169         throw_to_monitor();
 170     }
 171     return 0;
 172 }
 173
 174 char *parse_addr(char **ptr, boolean safely)
 175 {
 176     char *token = parse_token(ptr);
 177     lispobj result;
 178
 179     if (token == NULL) {
 180         printf("expected an address\n");
 181         throw_to_monitor();
 182     }
 183     else if (token[0] == '$') {
 184         if (!lookup_variable(token+1, &result)) {
 185             printf("unknown variable: ``%s''\n", token);
 186             throw_to_monitor();
 187         }
 188         result &= ~7;
 189     }
 190     else {
 191         uword_t value;
 192         if (!string_to_long(token, &value)) {
 193             printf("invalid number: ``%s''\n", token);
 194             throw_to_monitor();
 195         }
 196         result = (value & ~3);
 197     }
 198
 199     if (safely && !is_valid_lisp_addr((os_vm_address_t)result)) {
 200         printf("invalid Lisp-level address: %p\n", (void *)result);
 201         throw_to_monitor();
 202     }
 203
 204     return (char *)result;
 205 }
 206
 207 static boolean lookup_symbol(char *name, lispobj *result)
 208 {
 209     int count;
 210     lispobj *headerptr;
 211
 212     /* Search static space. */
 213     headerptr = (lispobj *)STATIC_SPACE_START;
 214     count =
 215         (lispobj *)SymbolValue(STATIC_SPACE_FREE_POINTER,0) -
 216         (lispobj *)STATIC_SPACE_START;
 217     if (search_for_symbol(name, &headerptr, &count)) {
 218         *result = make_lispobj(headerptr,OTHER_POINTER_LOWTAG);
 219         return 1;
 220     }
 221
 222 #ifdef LISP_FEATURE_IMMOBILE_SPACE
 223     /* Search immobile space. */
 224     headerptr = (lispobj *)IMMOBILE_SPACE_START;
 225     count = IMMOBILE_FIXEDOBJ_SUBSPACE_SIZE / N_WORD_BYTES;
 226     if (search_for_symbol(name, &headerptr, &count)) {
 227         *result = make_lispobj(headerptr,OTHER_POINTER_LOWTAG);
 228         return 1;
 229     }
 230 #endif
 231
 232     /* Search dynamic space. */
 233 #if defined(LISP_FEATURE_GENCGC)
 234     headerptr = (lispobj *)DYNAMIC_SPACE_START;
 235     count = (lispobj *)get_alloc_pointer() - headerptr;
 236 #else
 237     headerptr = (lispobj *)current_dynamic_space;
 238     count = dynamic_space_free_pointer - headerptr;
 239 #endif
 240
 241     if (search_for_symbol(name, &headerptr, &count)) {
 242         *result = make_lispobj(headerptr, OTHER_POINTER_LOWTAG);
 243         return 1;
 244     }
 245
 246     return 0;
 247 }
 248
 249 static int parse_regnum(char *s)
 250 {
 251     if ((s[1] == 'R') || (s[1] == 'r')) {
 252         int regnum;
 253
 254         if (s[2] == '\0')
 255             return -1;
 256
 257         /* skip the $R part and call atoi on the number */
 258         regnum = atoi(s + 2);
 259         if ((regnum >= 0) && (regnum < NREGS))
 260             return regnum;
 261         else
 262             return -1;
 263     } else {
 264         int i;
 265
 266         for (i = 0; i < NREGS ; i++)
 267             if (strcasecmp(s + 1, lisp_register_names[i]) == 0)
 268 #ifdef LISP_FEATURE_X86
 269                 return i*2;
 270 #else
 271         return i;
 272 #endif
 273
 274         return -1;
 275     }
 276 }
 277
 278 lispobj parse_lispobj(char **ptr)
 279 {
 280     struct thread *thread=arch_os_get_current_thread();
 281     char *token = parse_token(ptr);
 282     uword_t pointer;
 283     lispobj result;
 284     uword_t value;
 285
 286     if (token == NULL) {
 287         printf("expected an object\n");
 288         throw_to_monitor();
 289     } else if (token[0] == '$') {
 290         if (isalpha(token[1])) {
 291             int free_ici;
 292             int regnum;
 293             os_context_t *context;
 294
 295             free_ici = fixnum_value(SymbolValue(FREE_INTERRUPT_CONTEXT_INDEX,thread));
 296
 297             if (free_ici == 0) {
 298                 printf("Variable ``%s'' is not valid -- there is no current interrupt context.\n", token);
 299                 throw_to_monitor();
 300             }
 301
 302             context = thread->interrupt_contexts[free_ici - 1];
 303
 304             regnum = parse_regnum(token);
 305             if (regnum < 0) {
 306                 printf("bogus register: ``%s''\n", token);
 307                 throw_to_monitor();
 308             }
 309
 310             result = *os_context_register_addr(context, regnum);
 311         } else if (!lookup_variable(token+1, &result)) {
 312             printf("unknown variable: ``%s''\n", token);
 313             throw_to_monitor();
 314         }
 315     } else if (token[0] == '@') {
 316         if (string_to_long(token+1, &pointer)) {
 317             pointer &= ~3;
 318             if (is_valid_lisp_addr((os_vm_address_t)pointer))
 319                 result = *(lispobj *)pointer;
 320             else {
 321                 printf("invalid Lisp-level address: ``%s''\n", token+1);
 322                 throw_to_monitor();
 323             }
 324         }
 325         else {
 326             printf("invalid address: ``%s''\n", token+1);
 327             throw_to_monitor();
 328         }
 329     }
 330     else if (string_to_long(token, &value))
 331         result = value;
 332     else if (lookup_symbol(token, &result))
 333         ;
 334     else {
 335         printf("invalid Lisp object: ``%s''\n", token);
 336         throw_to_monitor();
 337     }
 338
 339     return result;
 340 }
 341
 342 #endif /* defined(LISP_FEATURE_SB_LDB) */