![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to db_sym.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / ddb|
Return to db_sym.c CVS log | Up to [Apple XNU] / XNU / osfmk / ddb |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: */
25: /*
26: * HISTORY
27: *
28: * Revision 1.1.1.1 1998/09/22 21:05:48 wsanchez
29: * Import of Mac OS X kernel (~semeria)
30: *
31: * Revision 1.1.1.1 1998/03/07 02:26:09 wsanchez
32: * Import of OSF Mach kernel (~mburg)
33: *
34: * Revision 1.3.22.8 1996/07/31 09:07:24 paire
35: * Merged with nmk20b7_shared (1.3.47.1)
36: * [96/07/24 paire]
37: *
38: * Revision 1.3.47.1 1996/06/13 12:36:08 bernadat
39: * Do not assume anymore that VM_MIN_KERNEL_ADDRESS
40: * is greater or equal than VM_MAX_ADDRESS.
41: * [96/05/23 bernadat]
42: *
43: * Revision 1.3.22.7 1996/01/09 19:16:15 devrcs
44: * Added db_task_getlinenum() function. (steved)
45: * Make db_maxval & db_minval long int's for Alpha.
46: * Changed declarations of 'register foo' to 'register int foo'.
47: * [1995/12/01 21:42:29 jfraser]
48: *
49: * Merged '64-bit safe' changes from DEC alpha port.
50: * [1995/11/21 18:03:41 jfraser]
51: *
52: * Revision 1.3.22.6 1995/02/28 01:58:46 dwm
53: * Merged with changes from 1.3.22.5
54: * [1995/02/28 01:53:47 dwm]
55: *
56: * mk6 CR1120 - Merge mk6pro_shared into cnmk_shared
57: * remove a couple local protos, now in .h file (for better or worse)
58: * [1995/02/28 01:12:51 dwm]
59: *
60: * Revision 1.3.22.5 1995/02/23 21:43:43 alanl
61: * Move TR_INIT to model_dep.c (MACH_TR and MACH_KDB shouldn't
62: * be bound).
63: * [95/02/16 travos]
64: *
65: * Prepend a "db_" to qsort and qsort_limit_search
66: * (collisions with the real qsort in stdlib.h)
67: * [95/02/14 travos]
68: *
69: * Added X_db_init for object independent formats.
70: * [95/01/24 sjs]
71: *
72: * Merge with DIPC2_SHARED.
73: * [1995/01/05 13:32:53 alanl]
74: *
75: * Revision 1.3.30.2 1994/12/22 20:36:15 bolinger
76: * Fix ri-osc CR881: enable freer use of symbol table of collocated
77: * tasks. No point in requiring task to be named for symbols to be
78: * usable. Also fixed glitch in use of symtab cloning.
79: * [1994/12/22 20:34:55 bolinger]
80: *
81: * Revision 1.3.30.1 1994/11/04 09:53:14 dwm
82: * mk6 CR668 - 1.3b26 merge
83: * add arg to *_db_search_by_addr() from mk6
84: * * Revision 1.3.4.9 1994/05/13 15:57:14 tmt
85: * Add hooks for catching calls to uninstalled symbol tables.
86: * Add XXX_search_by_addr() vectors.
87: * * Revision 1.3.4.8 1994/05/12 21:59:00 tmt
88: * Fix numerous db_sym_t/char * mixups.
89: * Fix and enable db_qualify_ambiguous_names.
90: * Make dif and newdiff unsigned in symbol searches.
91: * * Revision 1.3.4.7 1994/05/06 18:39:52 tmt
92: * Merged osc1.3dec/shared with osc1.3b19
93: * Fix function prototype declarations.
94: * Merge Alpha changes into osc1.312b source code.
95: * String protos.
96: * Handle multiple, coexisting symbol table types.
97: * 64bit cleanup.
98: * Revision 1.3.4.5 1993/10/20 18:58:55 gm
99: * CR9704: Removed symbol load printf.
100: * * End1.3merge
101: * [1994/11/04 08:50:02 dwm]
102: *
103: * Revision 1.3.22.5 1995/02/23 21:43:43 alanl
104: * Move TR_INIT to model_dep.c (MACH_TR and MACH_KDB shouldn't
105: * be bound).
106: * [95/02/16 travos]
107: *
108: * Prepend a "db_" to qsort and qsort_limit_search
109: * (collisions with the real qsort in stdlib.h)
110: * [95/02/14 travos]
111: *
112: * Added X_db_init for object independent formats.
113: * [95/01/24 sjs]
114: *
115: * Merge with DIPC2_SHARED.
116: * [1995/01/05 13:32:53 alanl]
117: *
118: * Revision 1.3.30.2 1994/12/22 20:36:15 bolinger
119: * Fix ri-osc CR881: enable freer use of symbol table of collocated
120: * tasks. No point in requiring task to be named for symbols to be
121: * usable. Also fixed glitch in use of symtab cloning.
122: * [1994/12/22 20:34:55 bolinger]
123: *
124: * Revision 1.3.30.1 1994/11/04 09:53:14 dwm
125: * mk6 CR668 - 1.3b26 merge
126: * add arg to *_db_search_by_addr() from mk6
127: * * Revision 1.3.4.9 1994/05/13 15:57:14 tmt
128: * Add hooks for catching calls to uninstalled symbol tables.
129: * Add XXX_search_by_addr() vectors.
130: * * Revision 1.3.4.8 1994/05/12 21:59:00 tmt
131: * Fix numerous db_sym_t/char * mixups.
132: * Fix and enable db_qualify_ambiguous_names.
133: * Make dif and newdiff unsigned in symbol searches.
134: * * Revision 1.3.4.7 1994/05/06 18:39:52 tmt
135: * Merged osc1.3dec/shared with osc1.3b19
136: * Fix function prototype declarations.
137: * Merge Alpha changes into osc1.312b source code.
138: * String protos.
139: * Handle multiple, coexisting symbol table types.
140: * 64bit cleanup.
141: * Revision 1.3.4.5 1993/10/20 18:58:55 gm
142: * CR9704: Removed symbol load printf.
143: * * End1.3merge
144: * [1994/11/04 08:50:02 dwm]
145: *
146: * Revision 1.3.22.3 1994/09/23 01:21:37 ezf
147: * change marker to not FREE
148: * [1994/09/22 21:10:58 ezf]
149: *
150: * Revision 1.3.22.2 1994/06/26 22:58:24 bolinger
151: * Suppress symbol table range output when table is unsorted, since output
152: * is meaningless in this case.
153: * [1994/06/23 20:19:02 bolinger]
154: *
155: * Revision 1.3.22.1 1994/06/11 21:12:19 bolinger
156: * Merge up to NMK17.2.
157: * [1994/06/11 20:02:31 bolinger]
158: *
159: * Revision 1.3.17.1 1994/02/08 10:58:40 bernadat
160: * Check result of X_db_line_at_pc() before
161: * invoking db_shorten_filename().
162: * [93/11/30 bernadat]
163: *
164: * Installed ddb_init() routine in a symbol-independent file to call
165: * symbol-dependent and machine-dependent initialization routines.
166: * [93/08/27 paire]
167: *
168: * Fixed db_shorten_filename() to gobble the last slash.
169: * Modified db_search_task_symbol_and_line() interface to return
170: * the number of a function arguments.
171: * [93/08/19 paire]
172: *
173: * Added new arguments to db_sym_print_completion() call.
174: * [93/08/18 paire]
175: *
176: * Added db_lookup_incomplete(), db_sym_parse_and_lookup_incomplete(),
177: * db_sym_print_completion() and db_completion_print() for support of
178: * symbol completion.
179: * [93/08/14 paire]
180: * [94/02/07 bernadat]
181: *
182: * Revision 1.3.15.4 1994/06/08 19:11:23 dswartz
183: * Preemption merge.
184: * [1994/06/08 19:10:24 dswartz]
185: *
186: * Revision 1.3.20.2 1994/06/01 21:34:39 klj
187: * Initial preemption code base merge
188: *
189: * Revision 1.3.15.3 1994/02/10 02:28:15 bolinger
190: * Fix db_add_symbol_table() to increase db_maxval if highest-addressed
191: * symbol in new symtab is greater than its current value.
192: * [1994/02/09 21:42:12 bolinger]
193: *
194: * Revision 1.3.15.2 1994/02/03 21:44:23 bolinger
195: * Update db_maxval when a symbol table is cloned for kernel-loaded
196: * server.
197: * [1994/02/03 20:47:22 bolinger]
198: *
199: * Revision 1.3.15.1 1994/02/03 02:41:58 dwm
200: * Add short-term kludge to provide symbolic info on INKServer.
201: * [1994/02/03 02:31:17 dwm]
202: *
203: * Revision 1.3.4.4 1993/08/11 20:38:11 elliston
204: * Add ANSI Prototypes. CR #9523.
205: * [1993/08/11 03:33:59 elliston]
206: *
207: * Revision 1.3.4.3 1993/07/27 18:28:09 elliston
208: * Add ANSI prototypes. CR #9523.
209: * [1993/07/27 18:12:57 elliston]
210: *
211: * Revision 1.3.4.2 1993/06/09 02:20:50 gm
212: * CR9176 - ANSI C violations: trailing tokens on CPP
213: * directives, extra semicolons after decl_ ..., asm keywords
214: * [1993/06/07 18:57:31 jeffc]
215: *
216: * Added to OSF/1 R1.3 from NMK15.0.
217: * [1993/06/02 20:57:10 jeffc]
218: *
219: * Revision 1.3 1993/04/19 16:03:09 devrcs
220: * Protect db_line_at_pc() against null db_last_symtab.
221: * [1993/02/11 15:37:16 barbou]
222: *
223: * Changes from MK78:
224: * Upped MAXNOSYMTABS from 3 to 5. Now there is space for kernel,
225: * bootstrap, server, and emulator symbols - plus one for future
226: * expansion.
227: * [92/03/21 danner]
228: * Changed CHAR arg of db_eqname to UNSIGNED.
229: * Made arg types proper for db_line_at_pc().
230: * [92/05/16 jfriedl]
231: * [92/12/18 bruel]
232: *
233: * Sort large symbol tables to speedup lookup.
234: * Improved symbol lookup (use of max_offset, dichotomic search)
235: * [[email protected]]
236: *
237: * db_add_symbol_table now takes 3 additional arguments. Machine
238: * dependant modules must provide them. [[email protected]]
239: * [92/12/03 bernadat]
240: *
241: * Revision 1.2 1992/11/25 01:04:42 robert
242: * integrate changes below for norma_14
243: * [1992/11/13 19:22:44 robert]
244: *
245: * Revision 1.1 1992/09/30 02:01:25 robert
246: * Initial revision
247: *
248: * $EndLog$
249: */
250: /* CMU_HIST */
251: /*
252: * Revision 2.10.4.1 92/02/18 18:38:53 jeffreyh
253: * Added db_get_sym(). Simple interface to get symbol names
254: * knowing the offset.
255: * [91/12/20 bernadat]
256: *
257: * Do not look for symbol names if address
258: * is to small or to large, otherwise get
259: * random names like INCLUDE_VERSION+??
260: * [91/06/25 bernadat]
261: *
262: * Revision 2.10 91/10/09 16:02:30 af
263: * Revision 2.9.2.1 91/10/05 13:07:27 jeffreyh
264: * Changed symbol table name qualification syntax from "xxx:yyy"
265: * to "xxx::yyy" to allow "file:func:line" in "yyy" part.
266: * "db_sym_parse_and_lookup" is also added for "yyy" part parsing.
267: * Replaced db_search_symbol with db_search_task_symbol, and moved
268: * it to "db_sym.h" as a macro.
269: * Added db_task_printsym, and changed db_printsym to call it.
270: * Added include "db_task_thread.h".
271: * Fixed infinite recursion of db_symbol_values.
272: * [91/08/29 tak]
273: *
274: * Revision 2.9.2.1 91/10/05 13:07:27 jeffreyh
275: * Changed symbol table name qualification syntax from "xxx:yyy"
276: * to "xxx::yyy" to allow "file:func:line" in "yyy" part.
277: * "db_sym_parse_and_lookup" is also added for "yyy" part parsing.
278: * Replaced db_search_symbol with db_search_task_symbol, and moved
279: * it to "db_sym.h" as a macro.
280: * Added db_task_printsym, and changed db_printsym to call it.
281: * Added include "db_task_thread.h".
282: * Fixed infinite recursion of db_symbol_values.
283: * [91/08/29 tak]
284: *
285: * Revision 2.9 91/07/31 17:31:14 dbg
286: * Add task pointer and space for string storage to symbol table
287: * descriptor.
288: * [91/07/31 dbg]
289: *
290: * Revision 2.8 91/07/09 23:16:08 danner
291: * Changed a printf.
292: * [91/07/08 danner]
293: *
294: * Revision 2.7 91/05/14 15:35:54 mrt
295: * Correcting copyright
296: *
297: * Revision 2.6 91/03/16 14:42:40 rpd
298: * Changed the default db_maxoff to 4K.
299: * [91/03/10 rpd]
300: *
301: * Revision 2.5 91/02/05 17:07:07 mrt
302: * Changed to new Mach copyright
303: * [91/01/31 16:19:17 mrt]
304: *
305: * Revision 2.4 90/10/25 14:44:05 rwd
306: * Changed db_printsym to print unsigned.
307: * [90/10/19 rpd]
308: *
309: * Revision 2.3 90/09/09 23:19:56 rpd
310: * Avoid totally incorrect guesses of symbol names for small values.
311: * [90/08/30 17:39:48 af]
312: *
313: * Revision 2.2 90/08/27 21:52:18 dbg
314: * Removed nlist.h. Fixed some type declarations.
315: * Qualifier character is ':'.
316: * [90/08/20 dbg]
317: * Modularized symtab info into a new db_symtab_t type.
318: * Modified db_add_symbol_table and others accordingly.
319: * Defined db_sym_t, a new (opaque) type used to represent
320: * symbols. This should support all sort of future symtable
321: * formats. Functions like db_qualify take a db_sym_t now.
322: * New db_symbol_values() function to explode the content
323: * of a db_sym_t.
324: * db_search_symbol() replaces db_find_sym_and_offset(), which is
325: * now a macro defined in our (new) header file. This new
326: * function accepts more restrictive searches, which are
327: * entirely delegated to the symtab-specific code.
328: * Accordingly, db_printsym() accepts a strategy parameter.
329: * New db_line_at_pc() function.
330: * Renamed misleading db_eqsym into db_eqname.
331: * [90/08/20 10:47:06 af]
332: *
333: * Created.
334: * [90/07/25 dbg]
335: *
336: * Revision 2.1 90/07/26 16:43:52 dbg
337: * Created.
338: *
339: */
340: /* CMU_ENDHIST */
341: /*
342: * Mach Operating System
343: * Copyright (c) 1991,1990 Carnegie Mellon University
344: * All Rights Reserved.
345: *
346: * Permission to use, copy, modify and distribute this software and its
347: * documentation is hereby granted, provided that both the copyright
348: * notice and this permission notice appear in all copies of the
349: * software, derivative works or modified versions, and any portions
350: * thereof, and that both notices appear in supporting documentation.
351: *
352: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
353: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
354: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
355: *
356: * Carnegie Mellon requests users of this software to return to
357: *
358: * Software Distribution Coordinator or [email protected]
359: * School of Computer Science
360: * Carnegie Mellon University
361: * Pittsburgh PA 15213-3890
362: *
363: * any improvements or extensions that they make and grant Carnegie Mellon
364: * the rights to redistribute these changes.
365: */
366: /*
367: */
368: /*
369: * Author: David B. Golub, Carnegie Mellon University
370: * Date: 7/90
371: */
372:
373: #include <machine/db_machdep.h>
374: #include <string.h> /* For strcpy(), strcmp() */
375: #include <mach/std_types.h>
376: #include <kern/misc_protos.h> /* For printf() */
377: #include <ddb/db_sym.h>
378: #include <ddb/db_task_thread.h>
379: #include <ddb/db_command.h>
380: #include <ddb/db_output.h> /* For db_printf() */
381:
382: #include <vm/vm_map.h> /* vm_map_t */
383:
384: /*
385: * Multiple symbol tables
386: *
387: * mach, bootstrap, name_server, default_pager, unix, 1 spare
388: */
389: #define MAXNOSYMTABS 6
390:
391: db_symtab_t db_symtabs[MAXNOSYMTABS] = {{0}};
392: int db_nsymtab = 0;
393:
394: db_symtab_t *db_last_symtab;
395:
396: unsigned long db_maxoff = 0x4000;
397: extern char end;
398: unsigned long db_maxval = (unsigned long)&end;
399: natural_t db_minval = 0x1000;
400:
401: /* Prototypes for functions local to this file. XXX -- should be static!
402: */
403: static char *db_qualify(
404: char *sym,
405: register char *symtabname);
406:
407: boolean_t db_eqname(
408: char *src,
409: char *dst,
410: unsigned c);
411:
412: boolean_t db_symbol_is_ambiguous(char *name);
413:
414: void db_shorten_filename(char **filenamep);
415:
416: void qsort_swap(
417: register int *a,
418: register int *b,
419: register int size);
420:
421: void qsort_rotate(
422: register int *a,
423: register int *b,
424: register int *c,
425: register int size);
426:
427: void qsort_recur(
428: char *left,
429: char *right,
430: int eltsize,
431: int (*compfun)(char *, char *));
432:
433: void qsort_checker(
434: char *table,
435: int nbelts,
436: int eltsize,
437: int (*compfun)(char *, char *));
438:
439: void bubble_sort(
440: char *table,
441: int nbelts,
442: int eltsize,
443: int (*compfun)(char *, char *));
444:
445: int no_print_completion(
446: db_symtab_t *stab,
447: char *symstr );
448: int no_lookup_incomplete(
449: db_symtab_t *stab,
450: char *symstr,
451: char **name,
452: int *len,
453: int *toadd);
454:
455: /*
456: * Initialization routine for ddb.
457: */
458: void
459: ddb_init(void)
460: {
461: X_db_init();
462: db_machdep_init();
463: }
464:
465: /*
466: * Add symbol table, with given name, to list of symbol tables.
467: */
468: boolean_t
469: db_add_symbol_table(
470: int type,
471: char *start,
472: char *end,
473: char *name,
474: char *ref,
475: char *map_pointer,
476: unsigned long minsym,
477: unsigned long maxsym,
478: boolean_t sorted)
479: {
480: register db_symtab_t *st;
481: extern vm_map_t kernel_map;
482:
483: if (db_nsymtab >= MAXNOSYMTABS)
484: return (FALSE);
485:
486: st = &db_symtabs[db_nsymtab];
487: st->type = type;
488: st->start = start;
489: st->end = end;
490: st->private = ref;
491: if (map_pointer == (char *)kernel_map ||
492: (VM_MAX_ADDRESS <= VM_MIN_KERNEL_ADDRESS &&
493: VM_MIN_KERNEL_ADDRESS <= minsym))
494: st->map_pointer = 0;
495: else
496: st->map_pointer = map_pointer;
497: strcpy(st->name, name);
498: st->minsym = minsym;
499: st->maxsym = maxsym;
500: if (maxsym == 0)
501: st->sorted = FALSE;
502: else {
503: st->sorted = sorted;
504: if (db_maxval < maxsym + db_maxoff)
505: db_maxval = maxsym + db_maxoff;
506: }
507: db_nsymtab++;
508:
509: return (TRUE);
510: }
511:
512: /*
513: * db_qualify("vm_map", "ux") returns "ux::vm_map".
514: *
515: * Note: return value points to static data whose content is
516: * overwritten by each call... but in practice this seems okay.
517: */
518: static char *
519: db_qualify(
520: char *symname,
521: register char *symtabname)
522: {
523: static char tmp[256];
524: register char *s;
525:
526: s = tmp;
527: while (*s++ = *symtabname++) {
528: }
529: s[-1] = ':';
530: *s++ = ':';
531: while (*s++ = *symname++) {
532: }
533: return tmp;
534: }
535:
536:
537: boolean_t
538: db_eqname(
539: char *src,
540: char *dst,
541: unsigned c)
542: {
543: if (!strcmp(src, dst))
544: return (TRUE);
545: if (src[0] == c)
546: return (!strcmp(src+1,dst));
547: return (FALSE);
548: }
549:
550: boolean_t
551: db_value_of_name(
552: char *name,
553: db_expr_t *valuep)
554: {
555: db_sym_t sym;
556:
557: sym = db_lookup(name);
558: if (sym == DB_SYM_NULL)
559: return (FALSE);
560: db_symbol_values(0, sym, &name, valuep);
561: return (TRUE);
562: }
563:
564: /*
565: * Display list of possible completions for a symbol.
566: */
567: void
568: db_print_completion(
569: char *symstr)
570: {
571: register int i;
572: int symtab_start = 0;
573: int symtab_end = db_nsymtab;
574: register char *cp;
575: int nsym = 0;
576: char *name = (char *)0;
577: int len;
578: int toadd;
579:
580: /*
581: * Look for, remove, and remember any symbol table specifier.
582: */
583: for (cp = symstr; *cp; cp++) {
584: if (*cp == ':' && cp[1] == ':') {
585: *cp = '\0';
586: for (i = 0; i < db_nsymtab; i++) {
587: if (! strcmp(symstr, db_symtabs[i].name)) {
588: symtab_start = i;
589: symtab_end = i + 1;
590: break;
591: }
592: }
593: *cp = ':';
594: if (i == db_nsymtab)
595: return;
596: symstr = cp+2;
597: }
598: }
599:
600: /*
601: * Look in the specified set of symbol tables.
602: * Return on first match.
603: */
604: for (i = symtab_start; i < symtab_end; i++) {
605: if (X_db_print_completion(&db_symtabs[i], symstr))
606: break;
607: }
608: }
609:
610: /*
611: * Lookup a (perhaps incomplete) symbol.
612: * If the symbol has a qualifier (e.g., ux::vm_map),
613: * then only the specified symbol table will be searched;
614: * otherwise, all symbol tables will be searched.
615: */
616: int
617: db_lookup_incomplete(
618: char *symstr,
619: int symlen)
620: {
621: register int i;
622: int symtab_start = 0;
623: int symtab_end = db_nsymtab;
624: register char *cp;
625: int nsym = 0;
626: char *name = (char *)0;
627: int len;
628: int toadd;
629:
630: /*
631: * Look for, remove, and remember any symbol table specifier.
632: */
633: for (cp = symstr; *cp; cp++) {
634: if (*cp == ':' && cp[1] == ':') {
635: *cp = '\0';
636: for (i = 0; i < db_nsymtab; i++) {
637: if (! strcmp(symstr, db_symtabs[i].name)) {
638: symtab_start = i;
639: symtab_end = i + 1;
640: break;
641: }
642: }
643: *cp = ':';
644: if (i == db_nsymtab)
645: return 0;
646: symstr = cp+2;
647: }
648: }
649:
650: /*
651: * Look in the specified set of symbol tables.
652: * Return on first match.
653: */
654: for (i = symtab_start; i < symtab_end; i++) {
655: nsym = X_db_lookup_incomplete(&db_symtabs[i], symstr,
656: &name, &len, &toadd);
657: if (nsym > 0) {
658: if (toadd > 0) {
659: len = strlen(symstr);
660: if (len + toadd >= symlen)
661: return 0;
662: bcopy(&name[len], &symstr[len], toadd);
663: symstr[len + toadd] = '\0';
664: }
665: break;
666: }
667: }
668: return nsym;
669: }
670:
671: /*
672: * Lookup a symbol.
673: * If the symbol has a qualifier (e.g., ux::vm_map),
674: * then only the specified symbol table will be searched;
675: * otherwise, all symbol tables will be searched.
676: */
677: db_sym_t
678: db_lookup(char *symstr)
679: {
680: db_sym_t sp;
681: register int i;
682: int symtab_start = 0;
683: int symtab_end = db_nsymtab;
684: register char *cp;
685:
686: /*
687: * Look for, remove, and remember any symbol table specifier.
688: */
689: for (cp = symstr; *cp; cp++) {
690: if (*cp == ':' && cp[1] == ':') {
691: *cp = '\0';
692: for (i = 0; i < db_nsymtab; i++) {
693: if (! strcmp(symstr, db_symtabs[i].name)) {
694: symtab_start = i;
695: symtab_end = i + 1;
696: break;
697: }
698: }
699: *cp = ':';
700: if (i == db_nsymtab)
701: db_error("Invalid symbol table name\n");
702: symstr = cp+2;
703: }
704: }
705:
706: /*
707: * Look in the specified set of symbol tables.
708: * Return on first match.
709: */
710: for (i = symtab_start; i < symtab_end; i++) {
711: if (sp = X_db_lookup(&db_symtabs[i], symstr)) {
712: db_last_symtab = &db_symtabs[i];
713: return sp;
714: }
715: }
716: return 0;
717: }
718:
719: /*
720: * Print a symbol completion
721: */
722: void
723: db_sym_print_completion(
724: db_symtab_t *stab,
725: char *name,
726: int function,
727: char *fname,
728: int line)
729: {
730: if (stab != db_symtabs)
731: db_printf("%s::", stab->name);
732: db_printf(name);
733: if (function) {
734: db_putchar('(');
735: db_putchar(')');
736: }
737: if (fname) {
738: db_printf(" [static from %s", fname);
739: if (line > 0)
740: db_printf(":%d", line);
741: db_putchar(']');
742: }
743: db_putchar('\n');
744: }
745:
746: /*
747: * Common utility routine to parse a symbol string into a file
748: * name, a (possibly incomplete) symbol name without line number.
749: * This routine is called from aout_db_print_completion if the object
750: * dependent handler supports qualified search with a file name.
751: * It parses the symbol string, and call an object dependent routine
752: * with parsed file name and symbol name.
753: */
754: int
755: db_sym_parse_and_print_completion(
756: int (*func)(db_symtab_t *,
757: char *),
758: db_symtab_t *symtab,
759: char *symstr)
760: {
761: register char *p;
762: register int n;
763: char *sym_name;
764: char *component[2];
765: int nsym;
766:
767: /*
768: * disassemble the symbol into components: [file_name:]symbol
769: */
770: component[0] = symstr;
771: component[1] = 0;
772: for (p = symstr, n = 1; *p; p++) {
773: if (*p == ':') {
774: if (n == 2)
775: break;
776: *p = 0;
777: component[n++] = p+1;
778: }
779: }
780: if (*p == 0) {
781: if (n == 1) {
782: sym_name = component[0];
783: } else {
784: sym_name = component[1];
785: }
786: nsym = func(symtab, sym_name);
787: } else
788: nsym = 0;
789: if (n == 2)
790: component[1][-1] = ':';
791: return nsym;
792: }
793:
794: /*
795: * Common utility routine to parse a symbol string into a file
796: * name, a (possibly incomplete) symbol name without line number.
797: * This routine is called from X_db_lookup_incomplete if the object
798: * dependent handler supports qualified search with a file name.
799: * It parses the symbol string, and call an object dependent routine
800: * with parsed file name and symbol name.
801: */
802: int
803: db_sym_parse_and_lookup_incomplete(
804: int (*func)(db_symtab_t *,
805: char *,
806: char *,
807: int,
808: db_sym_t*,
809: char **,
810: int *),
811: db_symtab_t *symtab,
812: char *symstr,
813: char **name,
814: int *len,
815: int *toadd)
816: {
817: register char *p;
818: register int n;
819: char *file_name = 0;
820: char *sym_name = 0;
821: char *component[2];
822: int nsym = 0;
823:
824: /*
825: * disassemble the symbol into components: [file_name:]symbol
826: */
827: component[0] = symstr;
828: component[1] = 0;
829: for (p = symstr, n = 1; *p; p++) {
830: if (*p == ':') {
831: if (n == 2)
832: break;
833: *p = 0;
834: component[n++] = p+1;
835: }
836: }
837: if (*p == 0) {
838: if (n == 1) {
839: file_name = 0;
840: sym_name = component[0];
841: } else {
842: file_name = component[0];
843: sym_name = component[1];
844: }
845: nsym = func(symtab, file_name, sym_name, 0, (db_sym_t *)0,
846: name, len);
847: if (nsym > 0)
848: *toadd = *len - strlen(sym_name);
849: }
850: if (n == 2)
851: component[1][-1] = ':';
852: return(nsym);
853: }
854:
855: /*
856: * Common utility routine to parse a symbol string into a file
857: * name, a symbol name and line number.
858: * This routine is called from aout_db_lookup if the object dependent
859: * handler supports qualified search with a file name or a line number.
860: * It parses the symbol string, and call an object dependent routine
861: * with parsed file name, symbol name and line number.
862: */
863: db_sym_t
864: db_sym_parse_and_lookup(
865: int (*func)(db_symtab_t *, char *, char *, int,
866: db_sym_t*, char **, int *),
867: db_symtab_t *symtab,
868: char *symstr)
869: {
870: register char *p;
871: register int n;
872: int n_name;
873: int line_number;
874: char *file_name = 0;
875: char *sym_name = 0;
876: char *component[3];
877: db_sym_t found = DB_SYM_NULL;
878:
879: /*
880: * disassemble the symbol into components:
881: * [file_name:]symbol[:line_nubmer]
882: */
883: component[0] = symstr;
884: component[1] = component[2] = 0;
885: for (p = symstr, n = 1; *p; p++) {
886: if (*p == ':') {
887: if (n >= 3)
888: break;
889: *p = 0;
890: component[n++] = p+1;
891: }
892: }
893: if (*p != 0)
894: goto out;
895: line_number = 0;
896: n_name = n;
897: p = component[n-1];
898: if (*p >= '0' && *p <= '9') {
899: if (n == 1)
900: goto out;
901: for (line_number = 0; *p; p++) {
902: if (*p < '0' || *p > '9')
903: goto out;
904: line_number = line_number*10 + *p - '0';
905: }
906: n_name--;
907: } else if (n >= 3)
908: goto out;
909: if (n_name == 1) {
910: for (p = component[0]; *p && *p != '.'; p++);
911: if (*p == '.') {
912: file_name = component[0];
913: sym_name = 0;
914: } else {
915: file_name = 0;
916: sym_name = component[0];
917: }
918: } else {
919: file_name = component[0];
920: sym_name = component[1];
921: }
922: (void) func(symtab, file_name, sym_name, line_number, &found,
923: (char **)0, (int *)0);
924:
925: out:
926: while (--n >= 1)
927: component[n][-1] = ':';
928: return(found);
929: }
930:
931: /*
932: * Does this symbol name appear in more than one symbol table?
933: * Used by db_symbol_values to decide whether to qualify a symbol.
934: */
935: boolean_t db_qualify_ambiguous_names = TRUE;
936:
937: boolean_t
938: db_symbol_is_ambiguous(char *name)
939: {
940: register int i;
941: register
942: boolean_t found_once = FALSE;
943:
944: if (!db_qualify_ambiguous_names)
945: return FALSE;
946:
947: for (i = 0; i < db_nsymtab; i++) {
948: if (X_db_lookup(&db_symtabs[i], name)) {
949: if (found_once)
950: return TRUE;
951: found_once = TRUE;
952: }
953: }
954: return FALSE;
955: }
956:
957: /*
958: * Find the closest symbol to val, and return its name
959: * and the difference between val and the symbol found.
960: */
961: unsigned int db_search_maxoff = 0x4000;
962: db_sym_t
963: db_search_task_symbol(
964: register db_addr_t val,
965: db_strategy_t strategy,
966: db_addr_t *offp, /* better be unsigned */
967: task_t task)
968: {
969: unsigned long diff, newdiff;
970: register int i;
971: db_symtab_t *sp;
972: db_sym_t ret = DB_SYM_NULL, sym;
973: vm_map_t map_for_val;
974:
975: if (task == TASK_NULL)
976: task = db_current_task();
977: map_for_val = (task == TASK_NULL)? VM_MAP_NULL: task->map;
978: again:
979: newdiff = diff = ~0UL;
980: db_last_symtab = 0;
981: for (sp = &db_symtabs[0], i = 0;
982: i < db_nsymtab;
983: sp++, i++) {
984: if (((vm_map_t)sp->map_pointer == VM_MAP_NULL ||
985: (vm_map_t)sp->map_pointer == map_for_val) &&
986: (sp->maxsym == 0 ||
987: ((unsigned long) val >= sp->minsym &&
988: (unsigned long) val <= sp->maxsym))) {
989: sym = X_db_search_symbol(sp, val, strategy,
990: (db_expr_t *)&newdiff);
991: if (newdiff < diff) {
992: db_last_symtab = sp;
993: diff = newdiff;
994: ret = sym;
995: if (diff <= db_search_maxoff)
996: break;
997: }
998: }
999: }
1000: if (ret == DB_SYM_NULL && map_for_val != VM_MAP_NULL) {
1001: map_for_val = VM_MAP_NULL;
1002: goto again;
1003: }
1004: *offp = diff;
1005: return ret;
1006: }
1007:
1008: /*
1009: * Find the closest symbol to val, and return its name
1010: * and the difference between val and the symbol found.
1011: * Also return the filename and linenumber if available.
1012: */
1013: db_sym_t
1014: db_search_task_symbol_and_line(
1015: register db_addr_t val,
1016: db_strategy_t strategy,
1017: db_expr_t *offp,
1018: char **filenamep,
1019: int *linenump,
1020: task_t task,
1021: int *argsp)
1022: {
1023: unsigned long diff, newdiff;
1024: register int i;
1025: db_symtab_t *sp;
1026: db_sym_t ret = DB_SYM_NULL, sym;
1027: vm_map_t map_for_val;
1028: char *func;
1029: char *filename;
1030: int linenum;
1031: int args;
1032:
1033: if (task == TASK_NULL)
1034: task = db_current_task();
1035: map_for_val = (task == TASK_NULL)? VM_MAP_NULL: task->map;
1036: *filenamep = (char *) 0;
1037: *linenump = 0;
1038: *argsp = -1;
1039: again:
1040: filename = (char *) 0;
1041: linenum = 0;
1042: newdiff = diff = ~0UL;
1043: db_last_symtab = 0;
1044: for (sp = &db_symtabs[0], i = 0;
1045: i < db_nsymtab;
1046: sp++, i++) {
1047: if (((vm_map_t)sp->map_pointer == VM_MAP_NULL ||
1048: (vm_map_t)sp->map_pointer == map_for_val) &&
1049: (sp->maxsym == 0 ||
1050: ((unsigned long) val >= sp->minsym &&
1051: (unsigned long) val <= sp->maxsym))) {
1052: sym = X_db_search_by_addr(sp, val, &filename, &func,
1053: &linenum, (db_expr_t *)&newdiff,
1054: &args);
1055: if (sym && newdiff < diff) {
1056: db_last_symtab = sp;
1057: diff = newdiff;
1058: ret = sym;
1059: *filenamep = filename;
1060: *linenump = linenum;
1061: *argsp = args;
1062: if (diff <= db_search_maxoff)
1063: break;
1064: }
1065: }
1066: }
1067: if (ret == DB_SYM_NULL && map_for_val != VM_MAP_NULL) {
1068: map_for_val = VM_MAP_NULL;
1069: goto again;
1070: }
1071: *offp = diff;
1072: if (*filenamep)
1073: db_shorten_filename(filenamep);
1074: return ret;
1075: }
1076:
1077: /*
1078: * Return name and value of a symbol
1079: */
1080: void
1081: db_symbol_values(
1082: db_symtab_t *stab,
1083: db_sym_t sym,
1084: char **namep,
1085: db_expr_t *valuep)
1086: {
1087: db_expr_t value;
1088: char *name;
1089:
1090: if (sym == DB_SYM_NULL) {
1091: *namep = 0;
1092: return;
1093: }
1094: if (stab == 0)
1095: stab = db_last_symtab;
1096:
1097: X_db_symbol_values(stab, sym, &name, &value);
1098:
1099: if (db_symbol_is_ambiguous(name)) {
1100: *namep = db_qualify(name, db_last_symtab->name);
1101: }else {
1102: *namep = name;
1103: }
1104: if (valuep)
1105: *valuep = value;
1106: }
1107:
1108:
1109: /*
1110: * Print a the closest symbol to value
1111: *
1112: * After matching the symbol according to the given strategy
1113: * we print it in the name+offset format, provided the symbol's
1114: * value is close enough (eg smaller than db_maxoff).
1115: * We also attempt to print [filename:linenum] when applicable
1116: * (eg for procedure names).
1117: *
1118: * If we could not find a reasonable name+offset representation,
1119: * then we just print the value in hex. Small values might get
1120: * bogus symbol associations, e.g. 3 might get some absolute
1121: * value like _INCLUDE_VERSION or something, therefore we do
1122: * not accept symbols whose value is zero (and use plain hex).
1123: */
1124:
1125: void
1126: db_task_printsym(
1127: db_expr_t off,
1128: db_strategy_t strategy,
1129: task_t task)
1130: {
1131: db_addr_t d;
1132: char *filename;
1133: char *name;
1134: db_expr_t value;
1135: int linenum;
1136: db_sym_t cursym;
1137:
1138: if (off >= db_maxval || off < db_minval) {
1139: db_printf("%#n", off);
1140: return;
1141: }
1142: cursym = db_search_task_symbol(off, strategy, &d, task);
1143:
1144: db_symbol_values(0, cursym, &name, &value);
1145: if (name == 0 || d >= db_maxoff || value == 0) {
1146: db_printf("%#n", off);
1147: return;
1148: }
1149: db_printf("%s", name);
1150: if (d)
1151: db_printf("+0x%x", d);
1152: if (strategy == DB_STGY_PROC) {
1153: if (db_line_at_pc(cursym, &filename, &linenum, off)) {
1154: db_printf(" [%s", filename);
1155: if (linenum > 0)
1156: db_printf(":%d", linenum);
1157: db_printf("]");
1158: }
1159: }
1160: }
1161:
1162: /*
1163: * Return symbol name for a given offset and
1164: * change the offset to be relative to this symbol.
1165: * Very usefull for xpr, when you want to log offsets
1166: * in a user friendly way.
1167: */
1168:
1169: char null_sym[] = "";
1170:
1171: char *
1172: db_get_sym(db_expr_t *off)
1173: {
1174: db_sym_t cursym;
1175: db_expr_t value;
1176: char *name;
1177: db_addr_t d;
1178:
1179: cursym = db_search_symbol(*off, DB_STGY_ANY, &d);
1180: db_symbol_values(0, cursym, &name, &value);
1181: if (name)
1182: *off = d;
1183: else
1184: name = null_sym;
1185: return(name);
1186: }
1187:
1188: void
1189: db_printsym(
1190: db_expr_t off,
1191: db_strategy_t strategy)
1192: {
1193: db_task_printsym(off, strategy, TASK_NULL);
1194: }
1195:
1196: int db_short_filename = 1;
1197:
1198: void
1199: db_shorten_filename(char **filenamep)
1200: {
1201: char *cp, *cp_slash;
1202:
1203: if (! *filenamep)
1204: return;
1205: for (cp = cp_slash = *filenamep; *cp; cp++) {
1206: if (*cp == '/')
1207: cp_slash = cp;
1208: }
1209: if (*cp_slash == '/')
1210: *filenamep = cp_slash+1;
1211: }
1212:
1213: int
1214: db_task_getlinenum(
1215: db_expr_t off,
1216: task_t task)
1217: {
1218: db_addr_t d;
1219: char *filename;
1220: char *name;
1221: db_expr_t value;
1222: int linenum;
1223: db_sym_t cursym;
1224: db_strategy_t strategy = DB_STGY_PROC;
1225:
1226: if (off >= db_maxval || off < db_minval) {
1227: db_printf("%#n", off);
1228: return(-1);
1229: }
1230: cursym = db_search_task_symbol(off, strategy, &d, task);
1231:
1232: db_symbol_values(0, cursym, &name, &value);
1233: if (name == 0 || d >= db_maxoff || value == 0) {
1234: return(-1);
1235: }
1236: if (db_line_at_pc(cursym, &filename, &linenum, off))
1237: return(linenum);
1238: else
1239: return(-1);
1240: }
1241:
1242: boolean_t
1243: db_line_at_pc(
1244: db_sym_t sym,
1245: char **filename,
1246: int *linenum,
1247: db_expr_t pc)
1248: {
1249: boolean_t result;
1250:
1251: if (db_last_symtab == 0)
1252: return FALSE;
1253: if (X_db_line_at_pc( db_last_symtab, sym, filename, linenum, pc)) {
1254: if (db_short_filename)
1255: db_shorten_filename(filename);
1256: result = TRUE;
1257: } else
1258: result = FALSE;
1259: return(result);
1260: }
1261:
1262: int qsort_check = 0;
1263:
1264: void
1265: db_qsort(
1266: char *table,
1267: int nbelts,
1268: int eltsize,
1269: int (*compfun)(char *, char *))
1270: {
1271: if (nbelts <= 0 || eltsize <= 0 || compfun == 0) {
1272: printf("qsort: invalid parameters\n");
1273: return;
1274: }
1275: qsort_recur(table, table + nbelts * eltsize, eltsize, compfun);
1276:
1277: if (qsort_check)
1278: qsort_checker(table, nbelts, eltsize, compfun);
1279: }
1280:
1281: void
1282: qsort_swap(
1283: register int *a,
1284: register int *b,
1285: register int size)
1286: {
1287: register int temp;
1288: char *aa, *bb;
1289: char ctemp;
1290:
1291: for (; size >= sizeof (int); size -= sizeof (int), a++, b++) {
1292: temp = *a;
1293: *a = *b;
1294: *b = temp;
1295: }
1296: aa = (char *)a;
1297: bb = (char *)b;
1298: for (; size > 0; size--, aa++, bb++) {
1299: ctemp = *aa;
1300: *aa = *bb;
1301: *bb = ctemp;
1302: }
1303: }
1304:
1305: /* rotate the three elements to the left */
1306: void
1307: qsort_rotate(
1308: register int *a,
1309: register int *b,
1310: register int *c,
1311: register int size)
1312: {
1313: register int temp;
1314: char *aa, *bb, *cc;
1315: char ctemp;
1316:
1317: for (; size >= sizeof (int); size -= sizeof (int), a++, b++, c++) {
1318: temp = *a;
1319: *a = *c;
1320: *c = *b;
1321: *b = temp;
1322: }
1323: aa = (char *)a;
1324: bb = (char *)b;
1325: cc = (char *)c;
1326: for (; size > 0; size--, aa++, bb++, cc++) {
1327: ctemp = *aa;
1328: *aa = *cc;
1329: *cc = *bb;
1330: *bb = ctemp;
1331: }
1332: }
1333:
1334: void
1335: qsort_recur(
1336: char *left,
1337: char *right,
1338: int eltsize,
1339: int (*compfun)(char *, char *))
1340: {
1341: char *i, *j;
1342: char *sameleft, *sameright;
1343:
1344: top:
1345: if (left + eltsize - 1 >= right) {
1346: return;
1347: }
1348:
1349: /* partition element (reference for "same"ness */
1350: sameleft = left + (((right - left) / eltsize) / 2) * eltsize;
1351: sameright = sameleft;
1352:
1353: i = left;
1354: j = right - eltsize;
1355:
1356: again:
1357: while (i < sameleft) {
1358: int comp;
1359:
1360: comp = (*compfun)(i, sameleft);
1361: if (comp == 0) {
1362: /*
1363: * Move to the "same" partition.
1364: */
1365: /*
1366: * Shift the left part of the "same" partition to
1367: * the left, so that "same" elements stay in their
1368: * original order.
1369: */
1370: sameleft -= eltsize;
1371: qsort_swap((int *) i, (int *) sameleft, eltsize);
1372: } else if (comp < 0) {
1373: /*
1374: * Stay in the "left" partition.
1375: */
1376: i += eltsize;
1377: } else {
1378: /*
1379: * Should be moved to the "right" partition.
1380: * Wait until the next loop finds an appropriate
1381: * place to store this element.
1382: */
1383: break;
1384: }
1385: }
1386:
1387: while (j > sameright) {
1388: int comp;
1389:
1390: comp = (*compfun)(sameright, j);
1391: if (comp == 0) {
1392: /*
1393: * Move to the right of the "same" partition.
1394: */
1395: sameright += eltsize;
1396: qsort_swap((int *) sameright, (int *) j, eltsize);
1397: } else if (comp > 0) {
1398: /*
1399: * Move to the "left" partition.
1400: */
1401: if (i == sameleft) {
1402: /*
1403: * Unfortunately, the "left" partition
1404: * has already been fully processed, so
1405: * we have to shift the "same" partition
1406: * to the right to free a "left" element.
1407: * This is done by moving the leftest same
1408: * to the right of the "same" partition.
1409: */
1410: sameright += eltsize;
1411: qsort_rotate((int *) sameleft, (int*) sameright,
1412: (int *) j, eltsize);
1413: sameleft += eltsize;
1414: i = sameleft;
1415: } else {
1416: /*
1417: * Swap with the "left" partition element
1418: * waiting to be moved to the "right"
1419: * partition.
1420: */
1421: qsort_swap((int *) i, (int *) j, eltsize);
1422: j -= eltsize;
1423: /*
1424: * Go back to the 1st loop.
1425: */
1426: i += eltsize;
1427: goto again;
1428: }
1429: } else {
1430: /*
1431: * Stay in the "right" partition.
1432: */
1433: j -= eltsize;
1434: }
1435: }
1436:
1437: if (i != sameleft) {
1438: /*
1439: * The second loop completed (the"right" partition is ok),
1440: * but we have to go back to the first loop, and deal with
1441: * the element waiting for a place in the "right" partition.
1442: * Let's shift the "same" zone to the left.
1443: */
1444: sameleft -= eltsize;
1445: qsort_rotate((int *) sameright, (int *) sameleft, (int *) i,
1446: eltsize);
1447: sameright -= eltsize;
1448: j = sameright;
1449: /*
1450: * Go back to 1st loop.
1451: */
1452: goto again;
1453: }
1454:
1455: /*
1456: * The partitions are correct now. Recur on the smallest side only.
1457: */
1458: if (sameleft - left >= right - (sameright + eltsize)) {
1459: qsort_recur(sameright + eltsize, right, eltsize, compfun);
1460: /*
1461: * The "right" partition is now completely sorted.
1462: * The "same" partition is OK, so...
1463: * Ignore them, and start the loops again on the
1464: * "left" partition.
1465: */
1466: right = sameleft;
1467: goto top;
1468: } else {
1469: qsort_recur(left, sameleft, eltsize, compfun);
1470: /*
1471: * The "left" partition is now completely sorted.
1472: * The "same" partition is OK, so ...
1473: * Ignore them, and start the loops again on the
1474: * "right" partition.
1475: */
1476: left = sameright + eltsize;
1477: goto top;
1478: }
1479: }
1480:
1481: void
1482: qsort_checker(
1483: char *table,
1484: int nbelts,
1485: int eltsize,
1486: int (*compfun)(char *, char *))
1487: {
1488: char *curr, *prev, *last;
1489:
1490: prev = table;
1491: curr = prev + eltsize;
1492: last = table + (nbelts * eltsize);
1493:
1494: while (prev < last) {
1495: if ((*compfun)(prev, curr) > 0) {
1496: printf("**** qsort_checker: error between 0x%x and 0x%x!!!\n", prev, curr);
1497: break;
1498: }
1499: prev = curr;
1500: curr += eltsize;
1501: }
1502: printf("qsort_checker: OK\n");
1503: }
1504:
1505: int qsort_search_debug = 0;
1506:
1507: void
1508: db_qsort_limit_search(
1509: char *target,
1510: char **start,
1511: char **end,
1512: int eltsize,
1513: int (*compfun)(char *, char *))
1514: {
1515: register char *left, *right;
1516: char *oleft, *oright, *part;
1517: int nbiter = 0;
1518: int comp;
1519:
1520: oleft = left = *start;
1521: oright = right = *end;
1522: part = (char *) 0;
1523:
1524: while (left < right) {
1525: nbiter++;
1526: part = left + (((right - left) / eltsize) / 2) * eltsize;
1527: comp = (*compfun)(target, part);
1528: if (comp > 0) {
1529: oleft = left;
1530: oright = right;
1531: left = part;
1532: if (left == oleft)
1533: break;
1534: if (qsort_search_debug > 1)
1535: printf(" [ Moved left from 0x%x to 0x%x]\n",
1536: oleft, left);
1537: } else if (comp < 0) {
1538: oright = right;
1539: oleft = left;
1540: right = part;
1541: if (qsort_search_debug > 1)
1542: printf(" [ Moved right from 0x%x to 0x%x]\n",
1543: oright, right);
1544: } else {
1545: if (qsort_search_debug > 1)
1546: printf(" [ FOUND! left=0x%x right=0x%x]\n",
1547: left, right);
1548: for (left = part;
1549: left > *start && (*compfun)(left, part) == 0;
1550: left -= eltsize);
1551: for (right = part + eltsize;
1552: right < *end && (*compfun)(right, part) == 0;
1553: right += eltsize);
1554: oright = right;
1555: oleft = left;
1556: break;
1557: }
1558: }
1559:
1560: if (qsort_search_debug)
1561: printf("[ Limited from %x-%x to %x-%x in %d iters ]\n",
1562: *start, *end, oleft, oright, nbiter);
1563: *start = oleft;
1564: *end = oright;
1565: }
1566:
1567: void
1568: bubble_sort(
1569: char *table,
1570: int nbelts,
1571: int eltsize,
1572: int (*compfun)(char *, char *))
1573: {
1574: boolean_t sorted;
1575: char *end;
1576: register char *p;
1577:
1578: end = table + ((nbelts-1) * eltsize);
1579: do {
1580: sorted = TRUE;
1581: for (p = table; p < end; p += eltsize) {
1582: if ((*compfun)(p, p + eltsize) > 0) {
1583: qsort_swap((int *) p, (int *) (p + eltsize),
1584: eltsize);
1585: sorted = FALSE;
1586: }
1587: }
1588: } while (sorted == FALSE);
1589:
1590: if (qsort_check)
1591: qsort_checker(table, nbelts, eltsize, compfun);
1592: }
1593:
1594: vm_offset_t vm_min_inks_addr = VM_MAX_KERNEL_ADDRESS;
1595:
1596: void
1597: db_install_inks(
1598: vm_offset_t base)
1599: {
1600: /* save addr to demarcate kernel/inks boundary (1st time only) */
1601: if (vm_min_inks_addr == VM_MAX_KERNEL_ADDRESS) {
1602: vm_min_inks_addr = base;
1603: db_qualify_ambiguous_names = TRUE;
1604: }
1605: }
1606:
1607:
1608: void
1609: db_clone_symtabXXX(
1610: char *clonee, /* which symtab to clone */
1611: char *cloner, /* in-kernel-server name */
1612: vm_offset_t base) /* base address of cloner */
1613: {
1614: db_symtab_t *st, *st_src;
1615: char * memp;
1616: vm_size_t size;
1617: long offset;
1618: extern vm_offset_t kalloc(vm_size_t);
1619: extern void db_clone_offsetXXX(char *, long);
1620:
1621: if (db_nsymtab >= MAXNOSYMTABS) {
1622: db_printf("db_clone_symtab: Too Many Symbol Tables\n");
1623: return;
1624: }
1625:
1626: db_install_inks(base);
1627:
1628: st = &db_symtabs[db_nsymtab]; /* destination symtab */
1629: if ((st_src = db_symtab_cloneeXXX(clonee)) == 0) {
1630: db_printf("db_clone_symtab: clonee (%s) not found\n", clonee);
1631: return;
1632: }
1633: /* alloc new symbols */
1634: size = (vm_size_t)(st_src->end - st_src->private);
1635: memp = (char *)kalloc( round_page(size) );
1636: if (!memp) {
1637: db_printf("db_clone_symtab: no memory for symtab\n");
1638: return;
1639: }
1640:
1641: *st = *st_src; /* bulk copy src -> dest */
1642: strcpy(st->name, cloner); /* new name */
1643: st->private = memp; /* copy symbols */
1644: bcopy((const char *)st_src->private, st->private, size);
1645: st->start = memp + sizeof(int); /* fixup pointers to symtab */
1646: st->end = memp + *(int *)memp;
1647: st->map_pointer = 0; /* no map because kernel-loaded */
1648:
1649: /* Offset symbols, leaving strings pointing into st_src */
1650: offset = base - st_src->minsym;
1651: st->minsym += offset;
1652: st->maxsym += offset;
1653: db_clone_offsetXXX(memp, offset);
1654: db_nsymtab++;
1655:
1656: db_printf( "[ cloned symbol table for %s: range 0x%x to 0x%x %s]\n",
1657: st->name, st->minsym, st->maxsym,
1658: st->sorted ? "(sorted) " : "");
1659: db_maxval = (unsigned int)st->maxsym + db_maxoff;
1660: }
1661:
1662: db_symtab_t *
1663: db_symtab_cloneeXXX(
1664: char *clonee)
1665: {
1666: db_symtab_t *st, *st_src;
1667:
1668: st = &db_symtabs[db_nsymtab]; /* destination symtab */
1669: for (st_src = &db_symtabs[0]; st_src < st; ++st_src)
1670: if (!strcmp(clonee, st_src->name))
1671: break;
1672: return ((st_src < st) ? st_src : 0);
1673: }
1674:
1675: /*
1676: * Switch into symbol-table specific routines
1677: */
1678:
1679: #if !defined(__alpha) && !defined(INTEL860)
1680: #define DB_NO_COFF
1681: #endif
1682:
1683: #ifndef DB_NO_AOUT
1684: #include <ddb/db_aout.h>
1685: #endif
1686:
1687: #ifndef DB_NO_COFF
1688: #include <ddb/db_coff.h>
1689: #endif
1690:
1691: static void no_init(void)
1692:
1693: {
1694: db_printf("Non-existent code for ddb init\n");
1695: }
1696:
1697: static boolean_t no_sym_init(
1698: char *start,
1699: char *end,
1700: char *name,
1701: char *task_addr)
1702: {
1703: db_printf("Non-existent code for init of symtab %s\n", name);
1704: return FALSE;
1705: }
1706:
1707: static db_sym_t no_lookup(
1708: db_symtab_t *stab,
1709: char *symstr)
1710: {
1711: db_printf("Bogus lookup of symbol %s\n", symstr);
1712: return DB_SYM_NULL;
1713: }
1714:
1715: static db_sym_t no_search(
1716: db_symtab_t *stab,
1717: db_addr_t off,
1718: db_strategy_t strategy,
1719: db_expr_t *diffp)
1720: {
1721: db_printf("Bogus search for offset %#Xn", off);
1722: return DB_SYM_NULL;
1723: }
1724:
1725: static boolean_t no_line_at_pc(
1726: db_symtab_t *stab,
1727: db_sym_t sym,
1728: char **file,
1729: int *line,
1730: db_expr_t pc)
1731: {
1732: db_printf("Bogus search for pc %#X\n", pc);
1733: return FALSE;
1734: }
1735:
1736: static void no_symbol_values(
1737: db_sym_t sym,
1738: char **namep,
1739: db_expr_t *valuep)
1740: {
1741: db_printf("Bogus symbol value resolution\n");
1742: if (namep) *namep = NULL;
1743: if (valuep) *valuep = 0;
1744: }
1745:
1746: static db_sym_t no_search_by_addr(
1747: db_symtab_t *stab,
1748: db_addr_t off,
1749: char **file,
1750: char **func,
1751: int *line,
1752: db_expr_t *diffp,
1753: int *args)
1754: {
1755: db_printf("Bogus search for address %#X\n", off);
1756: return DB_SYM_NULL;
1757: }
1758:
1759: int
1760: no_print_completion(
1761: db_symtab_t *stab,
1762: char *symstr )
1763: {
1764: db_printf("Bogus print completion: not supported\n");
1765: return 0;
1766: }
1767:
1768: int
1769: no_lookup_incomplete(
1770: db_symtab_t *stab,
1771: char *symstr,
1772: char **name,
1773: int *len,
1774: int *toadd)
1775: {
1776: db_printf("Bogus lookup incomplete: not supported\n");
1777: return 0;
1778: }
1779:
1780: #define NONE \
1781: { no_init, no_sym_init, no_lookup, no_search, \
1782: no_line_at_pc, no_symbol_values, no_search_by_addr, \
1783: no_print_completion, no_lookup_incomplete}
1784:
1785: struct db_sym_switch x_db[] = {
1786:
1787: /* BSD a.out format (really, sdb/dbx(1) symtabs) */
1788: #ifdef DB_NO_AOUT
1789: NONE,
1790: #else /* DB_NO_AOUT */
1791: { aout_db_init, aout_db_sym_init, aout_db_lookup, aout_db_search_symbol,
1792: aout_db_line_at_pc, aout_db_symbol_values, aout_db_search_by_addr,
1793: aout_db_print_completion, aout_db_lookup_incomplete},
1794: #endif /* DB_NO_AOUT */
1795:
1796: #ifdef DB_NO_COFF
1797: NONE,
1798: #else /* DB_NO_COFF */
1799: { coff_db_init, coff_db_sym_init, coff_db_lookup, coff_db_search_symbol,
1800: coff_db_line_at_pc, coff_db_symbol_values, coff_db_search_by_addr,
1801: coff_db_print_completion, coff_db_lookup_incomplete },
1802: #endif /* DB_NO_COFF */
1803:
1804: /* Machdep, not inited here */
1805: NONE
1806: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.