debugger/stack.c

   1 /*
   2  * Debugger stack handling
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  * Copyright 1996 Eric Youngdale
   6  */
   7
   8 #include <stdio.h>
   9 #include <malloc.h>
  10 #include "xmalloc.h"
  11 #include "windows.h"
  12 #include "debugger.h"
  13
  14
  15 /*
  16  * We keep this info for each frame, so that we can
  17  * find local variable information correctly.
  18  */
  19 struct bt_info
  20 {
  21   unsigned int       eip;
  22   unsigned int       ebp;
  23   struct name_hash * frame;
  24 };
  25
  26 static int nframe;
  27 static struct bt_info * frames = NULL;
  28 int curr_frame;
  29 static char * reg_name[] =
  30 {
  31   "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi"
  32 };
  33
  34 typedef struct
  35 {
  36     WORD bp;
  37     WORD ip;
  38     WORD cs;
  39 } FRAME16;
  40
  41 typedef struct
  42 {
  43     DWORD bp;
  44     DWORD ip;
  45     WORD cs;
  46 } FRAME32;
  47
  48
  49
  50 /***********************************************************************
  51  *           DEBUG_InfoStack
  52  *
  53  * Dump the top of the stack
  54  */
  55 void DEBUG_InfoStack(void)
  56 {
  57     DBG_ADDR addr;
  58
  59     fprintf(stderr,"Stack dump:\n");
  60     if ((SS_reg(DEBUG_context) == WINE_DATA_SELECTOR) ||
  61         (GET_SEL_FLAGS(SS_reg(DEBUG_context)) & LDT_FLAGS_32BIT))
  62     {  /* 32-bit mode */
  63         addr.seg = 0;
  64         addr.off = ESP_reg(DEBUG_context);
  65         DEBUG_ExamineMemory( &addr, 24, 'x' );
  66     }
  67     else  /* 16-bit mode */
  68     {
  69         addr.seg = SS_reg(DEBUG_context);
  70         addr.off = SP_reg(DEBUG_context);
  71         DEBUG_ExamineMemory( &addr, 24, 'w' );
  72     }
  73     fprintf(stderr,"\n");
  74 }
  75
  76
  77 /***********************************************************************
  78  *           DEBUG_BackTrace
  79  *
  80  * Display a stack back-trace.
  81  */
  82 void DEBUG_BackTrace(void)
  83 {
  84     DBG_ADDR addr;
  85     int frameno = 0;
  86
  87     fprintf(stderr,"Backtrace:\n");
  88     if (SS_reg(DEBUG_context) == WINE_DATA_SELECTOR)  /* 32-bit mode */
  89     {
  90         addr.seg = 0;
  91         addr.off = EBP_reg(DEBUG_context);
  92         nframe = 1;
  93         while (addr.off)
  94         {
  95             FRAME32 *frame = (FRAME32 *)addr.off;
  96             if (!DBG_CHECK_READ_PTR( &addr, sizeof(FRAME32) )) return;
  97             if (!frame->ip) break;
  98             addr.off = frame->bp;
  99             nframe++;
 100         }
 101         if( frames != NULL )
 102           {
 103             free(frames);
 104           }
 105
 106         frames = (struct bt_info *) xmalloc(nframe
 107                                               * sizeof(struct bt_info) );
 108         fprintf(stderr,"%s%d ",(curr_frame == 0 ? "=>" : "  "), frameno++);
 109         addr.off = EIP_reg(DEBUG_context);
 110         frames[0].eip = addr.off;
 111         frames[0].frame = DEBUG_PrintAddress( &addr, 32, TRUE );
 112         fprintf( stderr, "\n" );
 113         addr.off = EBP_reg(DEBUG_context);
 114
 115         frames[0].ebp = addr.off;
 116
 117         while (addr.off)
 118         {
 119             FRAME32 *frame = (FRAME32 *)addr.off;
 120             if (!DBG_CHECK_READ_PTR( &addr, sizeof(FRAME32) )) return;
 121             if (!frame->ip) break;
 122             fprintf(stderr,"%s%d ", (frameno == curr_frame ? "=>" : "  "),
 123                     frameno);
 124             addr.off = frame->ip;
 125             frames[frameno].eip = addr.off;
 126             frames[frameno].ebp = frame->bp;
 127             frames[frameno].frame = DEBUG_PrintAddressAndArgs( &addr, 32,
 128                                                         frame->bp, TRUE );
 129             frameno++;
 130             fprintf( stderr, "\n" );
 131             addr.off = frame->bp;
 132         }
 133     }
 134     else  /* 16-bit mode */
 135     {
 136       WORD ss = SS_reg(DEBUG_context), cs = CS_reg(DEBUG_context);
 137       if (GET_SEL_FLAGS(ss) & LDT_FLAGS_32BIT)
 138       {
 139           fprintf( stderr, "Not implemented: 32-bit backtrace on a different stack segment.\n" );
 140           return;
 141       }
 142       fprintf( stderr,"%d ", frameno++ );
 143       addr.seg = cs;
 144       addr.off = IP_reg(DEBUG_context);
 145       DEBUG_PrintAddress( &addr, 16, TRUE );
 146       fprintf( stderr, "\n" );
 147       addr.seg = ss;
 148       addr.off = BP_reg(DEBUG_context) & ~1;
 149       for (;;)
 150       {
 151           FRAME16 *frame = (FRAME16 *)DBG_ADDR_TO_LIN(&addr);
 152           if (!DBG_CHECK_READ_PTR( &addr, sizeof(FRAME16) )) return;
 153           if (!frame->bp) break;
 154           if (frame->bp & 1) cs = frame->cs;
 155           fprintf( stderr,"%d ", frameno++ );
 156           addr.seg = cs;
 157           addr.off = frame->ip;
 158           DEBUG_PrintAddress( &addr, 16, TRUE );
 159           fprintf( stderr, "\n" );
 160           addr.seg = ss;
 161           addr.off = frame->bp & ~1;
 162       }
 163   }
 164   fprintf( stderr, "\n" );
 165 }
 166
 167 /***********************************************************************
 168  *           DEBUG_GetSymbolValue
 169  *
 170  * Get the address of a named symbol from the current stack frame.
 171  */
 172 BOOL32 DEBUG_GetStackSymbolValue( const char * name, DBG_ADDR *addr )
 173 {
 174   struct name_hash * curr_func;
 175   int                i;
 176
 177   /*
 178    * If we don't have a valid backtrace, then just return.
 179    */
 180   if( frames == NULL )
 181     {
 182       return FALSE;
 183     }
 184
 185   curr_func = frames[curr_frame].frame;
 186
 187   /*
 188    * If we don't know what the current function is, then we also have
 189    * nothing to report here.
 190    */
 191   if( curr_func == NULL )
 192     {
 193       return FALSE;
 194     }
 195
 196   for(i=0; i < curr_func->n_locals; i++ )
 197     {
 198       /*
 199        * Test the range of validity of the local variable.  This
 200        * comes up with RBRAC/LBRAC stabs in particular.
 201        */
 202       if(    (curr_func->local_vars[i].pc_start != 0)
 203           && ((frames[curr_frame].eip - curr_func->addr.off)
 204               < curr_func->local_vars[i].pc_start) )
 205         {
 206           continue;
 207         }
 208
 209       if(    (curr_func->local_vars[i].pc_end != 0)
 210           && ((frames[curr_frame].eip - curr_func->addr.off)
 211               > curr_func->local_vars[i].pc_end) )
 212         {
 213           continue;
 214         }
 215
 216       if( strcmp(name, curr_func->local_vars[i].name) == 0 )
 217         {
 218           /*
 219            * OK, we found it.  Now figure out what to do with this.
 220            */
 221           if( curr_func->local_vars[i].regno != 0 )
 222             {
 223               /*
 224                * Register variable.  We don't know how to treat
 225                * this yet.
 226                */
 227               return FALSE;
 228             }
 229
 230           addr->seg = 0;
 231           addr->off = frames[curr_frame].ebp + curr_func->local_vars[i].offset;
 232
 233           return TRUE;
 234         }
 235     }
 236   return FALSE;
 237 }
 238
 239 int
 240 DEBUG_SetFrame(int newframe)
 241 {
 242   int           rtn = FALSE;
 243   /*
 244    * Nothing for now.  Add support later.
 245    */
 246
 247   curr_frame = newframe;
 248   if( curr_frame < 0 )
 249     {
 250       curr_frame = 0;
 251     }
 252
 253   if( curr_frame >= nframe )
 254     {
 255       curr_frame = nframe - 1;
 256     }
 257
 258   rtn = TRUE;
 259   return (rtn);
 260 }
 261
 262 int
 263 DEBUG_InfoLocals()
 264 {
 265   struct name_hash * curr_func;
 266   int                i;
 267   int           rtn = FALSE;
 268   unsigned      int * ptr;
 269
 270   /*
 271    * If we don't have a valid backtrace, then just return.
 272    */
 273   if( frames == NULL )
 274     {
 275       return FALSE;
 276     }
 277
 278   curr_func = frames[curr_frame].frame;
 279
 280   /*
 281    * If we don't know what the current function is, then we also have
 282    * nothing to report here.
 283    */
 284   if( curr_func == NULL )
 285     {
 286       return FALSE;
 287     }
 288
 289   for(i=0; i < curr_func->n_locals; i++ )
 290     {
 291       /*
 292        * Test the range of validity of the local variable.  This
 293        * comes up with RBRAC/LBRAC stabs in particular.
 294        */
 295       if(    (curr_func->local_vars[i].pc_start != 0)
 296           && ((frames[curr_frame].eip - curr_func->addr.off)
 297               < curr_func->local_vars[i].pc_start) )
 298         {
 299           continue;
 300         }
 301
 302       if(    (curr_func->local_vars[i].pc_end != 0)
 303           && ((frames[curr_frame].eip - curr_func->addr.off)
 304               > curr_func->local_vars[i].pc_end) )
 305         {
 306           continue;
 307         }
 308
 309       if( curr_func->local_vars[i].offset == 0 )
 310         {
 311           fprintf(stderr, "%s:%s optimized into register $%s \n",
 312                   curr_func->name, curr_func->local_vars[i].name,
 313                   reg_name[curr_func->local_vars[i].regno]);
 314         }
 315       else
 316         {
 317           ptr = (unsigned int *) (frames[curr_frame].ebp
 318                                    + curr_func->local_vars[i].offset);
 319           fprintf(stderr, "%s:%s == 0x%8.8x\n",
 320                   curr_func->name, curr_func->local_vars[i].name,
 321                   *ptr);
 322         }
 323     }
 324
 325   rtn = TRUE;
 326
 327   return (rtn);
 328 }