rom/debug/decodelocation.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6 */
   7
   8 #define DEBUG 0
   9 #define DSEGS(x)
  10
  11 #include <aros/debug.h>
  12 #include <dos/bptr.h>
  13 #include <libraries/debug.h>
  14 #include <proto/exec.h>
  15 #include <proto/kernel.h>
  16
  17 #include <inttypes.h>
  18
  19 #include "debug_intern.h"
  20
  21 /* Binary search over sorted array of segments */
  22 static struct segment * FindSegmentInModule(void *addr, module_t *mod)
  23 {
  24     LONG idx, minidx = 0, maxidx = mod->m_segcnt - 1;
  25
  26     while(TRUE)
  27     {
  28         idx = (maxidx + minidx) / 2;
  29
  30         if (mod->m_segments[idx]->s_lowest <= addr)
  31         {
  32             if (mod->m_segments[idx]->s_highest >= addr)
  33             {
  34                 return mod->m_segments[idx];
  35             }
  36             else
  37             {
  38                 /* cut off segments with lower addresses */
  39                 minidx = idx + 1;
  40             }
  41         }
  42         else
  43         {
  44             /* cut off segments with higher addresses */
  45             maxidx = idx - 1;
  46         }
  47
  48         /* Not found, aborting */
  49         if (maxidx < minidx)
  50             return NULL;
  51     }
  52
  53     return NULL;
  54 }
  55
  56 static struct segment * FindSegment(void *addr, struct Library *DebugBase)
  57 {
  58     module_t * mod;
  59
  60     ForeachNode(&DBGBASE(DebugBase)->db_Modules, mod)
  61     {
  62         DSEGS(bug("[Debug] Checking module 0x%p - 0x%p, %s\n", mod->m_lowest, mod->m_highest, mod->m_name));
  63
  64         /* if address suits the module bounds, you got a candidate */
  65         if (!((mod->m_gaplowest <= addr) && (mod->m_gaphighest >= addr)) &&
  66                 ((mod->m_lowest <= addr) && (mod->m_highest >= addr)))
  67         {
  68             struct segment *seg = FindSegmentInModule(addr, mod);
  69             if (seg)
  70                 return seg;
  71         }
  72     }
  73
  74     return NULL;
  75 }
  76
  77 static BOOL FindSymbol(module_t *mod, char **function, void **funstart, void **funend, void *addr)
  78 {
  79     dbg_sym_t *sym = mod->m_symbols;
  80     unsigned int i;
  81
  82     /* Caller didn't care about symbols? */
  83     if (!addr)
  84         return TRUE;
  85
  86     *function = NULL;
  87     *funstart = NULL;
  88     *funend   = NULL;
  89
  90     for (i = 0; i < mod->m_symcnt; i++)
  91     {
  92         APTR highest = sym[i].s_highest;
  93
  94         /* Symbols with zero length have zero in s_highest */
  95         if (!highest)
  96             highest = sym[i].s_lowest;
  97
  98         if (sym[i].s_lowest <= addr && highest >= addr) {
  99             *function = sym[i].s_name;
 100             *funstart = sym[i].s_lowest;
 101             *funend   = sym[i].s_highest;
 102
 103             return TRUE;
 104         }
 105     }
 106
 107     /* Indicate that symbol not found */
 108     return FALSE;
 109 }
 110
 111 /*****************************************************************************
 112
 113     NAME */
 114 #include <proto/debug.h>
 115
 116         AROS_LH2(int, DecodeLocationA,
 117
 118 /*  SYNOPSIS */
 119         AROS_LHA(void *, addr, A0),
 120         AROS_LHA(struct TagItem *, tags, A1),
 121
 122 /*  LOCATION */
 123         struct Library *, DebugBase, 7, Debug)
 124
 125 /*  FUNCTION
 126         Locate the given address in the list of registered modules and return
 127         information about it.
 128
 129     INPUTS
 130         addr - An address to resolve
 131         tags - An optional taglist. ti_Tag can be one of the following tags and
 132                ti_Data is always a pointer to a storage of specified type.
 133                Resulting values will be placed into specified locations if the
 134                function succeeds.
 135
 136             DL_ModuleName     (char *) - Module name
 137             DL_SegmentName    (char *) - Segment name. Can be NULL if there were
 138                                          no segment names provided for the module.
 139             DL_SegmentPointer (BPTR)   - DOS pointer to the corresponding segment.
 140                                          Note that it will be different from
 141                                          KDL_SegmentStart value
 142
 143             DL_SegmentNumber  (unsigned int) - Order number of the segment in the
 144                                                module
 145             DL_SegmentStart   (void *) - Start address of actual segment contents
 146                                          in memory.
 147             DL_SegmentEnd     (void *) - End address of actual segment contents
 148                                          in memory.
 149             DL_FirstSegment   (BPTR) - DOS pointer to the first segment.
 150
 151             The following tags may return NULL values if there was no corresponding
 152             information provided for the module:
 153
 154             DL_SymbolName     (char *) - Symbol name (function or variable name)
 155             DL_SymbolStart    (void *) - Start address of contents described by this
 156                                          symbol.
 157             DL_SymbolEnd      (void *) - End address of contents described by this
 158                                          symbol.
 159
 160     RESULT
 161         Zero if lookup failed and no corresponding module found, nonzero
 162         otherwise.
 163
 164     NOTES
 165         If the function fails values pointed to by taglist will not be changed.
 166
 167     EXAMPLE
 168
 169     BUGS
 170
 171     SEE ALSO
 172
 173     INTERNALS
 174
 175 ******************************************************************************/
 176 {
 177     AROS_LIBFUNC_INIT
 178
 179     struct segment *seg;
 180     void *dummy;
 181     char **module   = (char **)&dummy;
 182     char **segment  = (char **)&dummy;
 183     char **function = (char **)&dummy;
 184     void **secstart = &dummy;
 185     void **secend   = &dummy;
 186     void **funstart = &dummy;
 187     void **funend   = &dummy;
 188     BPTR  *secptr   = (BPTR *)&dummy;
 189     BPTR  *secfirst = (BPTR *)&dummy;
 190     unsigned int *secnum = (unsigned int *)&dummy;
 191     struct TagItem *tag, *tstate = tags;
 192     void *symaddr = NULL;
 193     int ret = 0;
 194     int super;
 195
 196     D(bug("[Debug] DecodeLocationA(0x%p)\n", addr));
 197
 198     /* Parse TagList */
 199     while ((tag = LibNextTagItem(&tstate)))
 200     {
 201         switch (tag->ti_Tag)
 202         {
 203         case DL_ModuleName:
 204             module = (char **)tag->ti_Data;
 205             break;
 206
 207         case DL_SegmentName:
 208             segment = (char **)tag->ti_Data;
 209             break;
 210
 211         case DL_SegmentPointer:
 212             secptr = (BPTR *)tag->ti_Data;
 213             break;
 214
 215         case DL_SegmentNumber:
 216             secnum = (unsigned int *)tag->ti_Data;
 217             break;
 218
 219         case DL_SegmentStart:
 220             secstart = (void **)tag->ti_Data;
 221             break;
 222
 223         case DL_SegmentEnd:
 224             secend = (void **)tag->ti_Data;
 225             break;
 226
 227         case DL_FirstSegment:
 228             secfirst = (BPTR *)tag->ti_Data;
 229             break;
 230
 231         case DL_SymbolName:
 232             function = (char **)tag->ti_Data;
 233             symaddr = addr;
 234             break;
 235
 236         case DL_SymbolStart:
 237             funstart = (void **)tag->ti_Data;
 238             symaddr = addr;
 239             break;
 240
 241         case DL_SymbolEnd:
 242             funend = (void **)tag->ti_Data;
 243             symaddr = addr;
 244             break;
 245         }
 246     }
 247
 248     /* We can be called in supervisor mode. No semaphores in the case! */
 249     super = KrnIsSuper();
 250     if (!super)
 251         ObtainSemaphoreShared(&DBGBASE(DebugBase)->db_ModSem);
 252
 253     seg = FindSegment(addr, DebugBase);
 254     if (seg)
 255     {
 256         D(bug("[Debug] Found module %s, Segment %u (%s, 0x%p - 0x%p)\n", seg->s_mod->m_name, seg->s_num,
 257                seg->s_name, seg->s_lowest, seg->s_highest));
 258
 259         *module   = seg->s_mod->m_name;
 260         *segment  = seg->s_name;
 261         *secptr   = seg->s_seg;
 262         *secnum   = seg->s_num;
 263         *secstart = seg->s_lowest;
 264         *secend   = seg->s_highest;
 265         *secfirst = seg->s_mod->m_seg;
 266
 267         /* Now look up the function if requested */
 268         FindSymbol(seg->s_mod, function, funstart, funend, symaddr);
 269         ret = 1;
 270     }
 271
 272     if (!super)
 273         ReleaseSemaphore(&DBGBASE(DebugBase)->db_ModSem);
 274
 275     return ret;
 276
 277     AROS_LIBFUNC_EXIT
 278 }