1 /* code for low-level debugging/diagnostic output */
4 * This software is part of the SBCL system. See the README file for
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.
16 * Some of the code in here (the various
17 * foo_slots[], at least) is deeply broken, depending on guessing
18 * already out-of-date values instead of getting them from sbcl.h.
28 #include "thread.h" /* genesis/primitive-objects.h needs this */
32 /* FSHOW and odxprint provide debugging output for low-level information
33 * (signal handling, exceptions, safepoints) which is hard to debug by
36 * If enabled at all, environment variables control whether calls of the
37 * form odxprint(name, ...) are enabled at run-time, e.g. using
38 * SBCL_DYNDEBUG="fshow fshow_signal safepoints".
40 * In the case of FSHOW and FSHOW_SIGNAL, old-style code from runtime.h
41 * can also be used to enable or disable these more aggressively.
44 struct dyndebug_config dyndebug_config
= {
45 QSHOW
== 2, QSHOW_SIGNALS
== 2
51 #define DYNDEBUG_NFLAGS (sizeof(struct dyndebug_config) / sizeof(int))
52 #define dyndebug_init1(lowercase, uppercase) \
54 int *ptr = &dyndebug_config.dyndebug_##lowercase; \
56 names[n] = #lowercase; \
57 char *val = getenv("SBCL_DYNDEBUG__" uppercase); \
58 *ptr = val && strlen(val); \
62 char *names
[DYNDEBUG_NFLAGS
];
63 int *ptrs
[DYNDEBUG_NFLAGS
];
65 dyndebug_init1(fshow
, "FSHOW");
66 dyndebug_init1(fshow_signal
, "FSHOW_SIGNAL");
67 dyndebug_init1(gencgc_verbose
, "GENCGC_VERBOSE");
68 dyndebug_init1(safepoints
, "SAFEPOINTS");
69 dyndebug_init1(seh
, "SEH");
70 dyndebug_init1(misc
, "MISC");
71 dyndebug_init1(pagefaults
, "PAGEFAULTS");
72 dyndebug_init1(io
, "IO");
73 dyndebug_init1(runtime_link
, "RUNTIME_LINK");
75 int n_output_flags
= n
;
76 dyndebug_init1(backtrace_when_lost
, "BACKTRACE_WHEN_LOST");
77 dyndebug_init1(sleep_when_lost
, "SLEEP_WHEN_LOST");
79 if (n
!= DYNDEBUG_NFLAGS
)
80 fprintf(stderr
, "Bug in dyndebug_init\n");
82 #if defined(LISP_FEATURE_GENCGC)
83 gencgc_verbose
= dyndebug_config
.dyndebug_gencgc_verbose
;
86 char *featurelist
= getenv("SBCL_DYNDEBUG");
89 featurelist
= strdup(featurelist
);
90 char *ptr
= featurelist
;
92 char *token
= strtok(ptr
, " ");
95 if (!strcmp(token
, "all"))
96 for (i
= 0; i
< n_output_flags
; i
++)
99 for (i
= 0; i
< (int)DYNDEBUG_NFLAGS
; i
++)
100 if (!strcmp(token
, names
[i
])) {
104 if (i
== DYNDEBUG_NFLAGS
) {
105 fprintf(stderr
, "No such dyndebug flag: `%s'\n", token
);
113 fprintf(stderr
, "Valid flags are:\n");
114 fprintf(stderr
, " all ;enables all of the following:\n");
116 for (i
= 0; i
< (int)DYNDEBUG_NFLAGS
; i
++) {
117 if (i
== n_output_flags
)
118 fprintf(stderr
, "Additional options:\n");
119 fprintf(stderr
, " %s\n", names
[i
]);
124 #undef dyndebug_init1
125 #undef DYNDEBUG_NFLAGS
128 /* Temporarily, odxprint merely performs the equivalent of a traditional
129 * FSHOW call, i.e. it merely formats to stderr. Ultimately, it should
130 * be restored to its full win32 branch functionality, where output to a
131 * file or to the debugger can be selected at runtime. */
133 void vodxprint_fun(const char *, va_list);
136 odxprint_fun(const char *fmt
, ...)
140 vodxprint_fun(fmt
, args
);
145 vodxprint_fun(const char *fmt
, va_list args
)
147 #ifdef LISP_FEATURE_WIN32
148 DWORD lastError
= GetLastError();
150 int original_errno
= errno
;
157 #ifdef LISP_FEATURE_SB_THREAD
158 struct thread
*arch_os_get_current_thread(void);
159 struct thread
*self
= arch_os_get_current_thread();
160 void *pth
= self
? (void *) self
->os_thread
: 0;
161 snprintf(buf
, sizeof(buf
), "[%p/%p] ", self
, pth
);
165 vsnprintf(buf
+ n
, sizeof(buf
) - n
- 1, fmt
, args
);
166 /* buf is now zero-terminated (even in case of overflow).
167 * Our caller took care of the newline (if any) through `fmt'. */
169 /* A sufficiently POSIXy implementation of stdio will provide
170 * per-FILE locking, as defined in the spec for flockfile. At least
171 * glibc complies with this. Hence we do not need to perform
172 * locking ourselves here. (Should it turn out, of course, that
173 * other libraries opt for speed rather than safety, we need to
174 * revisit this decision.) */
177 #ifdef LISP_FEATURE_WIN32
178 /* stdio's stderr is line-bufferred, i.e. \n ought to flush it.
179 * Unfortunately, MinGW does not behave the way I would expect it
180 * to. Let's be safe: */
186 #ifdef LISP_FEATURE_WIN32
187 SetLastError(lastError
);
189 errno
= original_errno
;
192 /* Translate the rather awkward syntax
193 * FSHOW((stderr, "xyz"))
194 * into the new and cleaner
196 * If we were willing to clean up all existing call sites, we could remove
197 * this wrapper function. (This is a function, because I don't know how to
198 * strip the extra parens in a macro.) */
200 fshow_fun(void __attribute__((__unused__
)) *ignored
,
206 vodxprint_fun(fmt
, args
);
210 /* This file can be skipped if we're not supporting LDB. */
211 #if defined(LISP_FEATURE_SB_LDB)
216 #ifdef LISP_FEATURE_GENCGC
217 #include "gencgc-alloc-region.h" /* genesis/thread.h needs this */
219 #if defined(LISP_FEATURE_WIN32)
220 # include "win32-thread-private-events.h" /* genesis/thread.h needs this */
222 #include "genesis/static-symbols.h"
223 #include "genesis/primitive-objects.h"
224 #include "genesis/static-symbols.h"
225 #include "genesis/tagnames.h"
227 static int max_lines
= 20, cur_lines
= 0;
228 static int max_depth
= 5, brief_depth
= 2, cur_depth
= 0;
229 static int max_length
= 5;
230 static boolean dont_descend
= 0, skip_newline
= 0;
231 static int cur_clock
= 0;
233 static void print_obj(char *prefix
, lispobj obj
);
235 #define NEWLINE_OR_RETURN if (continue_p(1)) newline(NULL); else return;
237 static void indent(int in
)
239 static char *spaces
= " ";
242 fputs(spaces
, stdout
);
246 fputs(spaces
+ 64 - in
, stdout
);
249 static boolean
continue_p(boolean newline
)
253 if (cur_depth
>= max_depth
|| dont_descend
)
262 if (cur_lines
>= max_lines
) {
263 printf("More? [y] ");
266 if (fgets(buffer
, sizeof(buffer
), stdin
)) {
267 if (buffer
[0] == 'n' || buffer
[0] == 'N')
272 printf("\nUnable to read response, assuming y.\n");
281 static void newline(char *label
)
285 fputs(label
, stdout
);
287 indent(cur_depth
* 2);
291 static void print_unknown(lispobj obj
)
293 printf("unknown object: %p", (void *)obj
);
296 static void brief_fixnum(lispobj obj
)
298 /* KLUDGE: Rather than update the tables in print_obj(), we
299 declare all fixnum-or-unknown tags to be fixnums and sort it
300 out here with a guard clause. */
301 if (!fixnump(obj
)) return print_unknown(obj
);
303 #ifndef LISP_FEATURE_ALPHA
304 printf("%ld", ((long)obj
)>>N_FIXNUM_TAG_BITS
);
306 printf("%d", ((s32
)obj
)>>N_FIXNUM_TAG_BITS
);
310 static void print_fixnum(lispobj obj
)
312 /* KLUDGE: Rather than update the tables in print_obj(), we
313 declare all fixnum-or-unknown tags to be fixnums and sort it
314 out here with a guard clause. */
315 if (!fixnump(obj
)) return print_unknown(obj
);
317 #ifndef LISP_FEATURE_ALPHA
318 printf(": %ld", ((long)obj
)>>N_FIXNUM_TAG_BITS
);
320 printf(": %d", ((s32
)obj
)>>N_FIXNUM_TAG_BITS
);
324 static void brief_otherimm(lispobj obj
)
329 type
= widetag_of(obj
);
331 case CHARACTER_WIDETAG
:
332 c
= obj
>>8; // no mask. show whatever's there
335 case '\0': charname
= "Nul"; break;
336 case '\n': charname
= "Newline"; break;
337 case '\b': charname
= "Backspace"; break;
338 case '\177': charname
= "Delete"; break;
340 if (c
< 32) printf("^%c", c
+64);
341 else printf(c
< 128 ? "%c" : "U+%X", c
);
344 fputs(charname
, stdout
);
347 case UNBOUND_MARKER_WIDETAG
:
348 printf("<unbound marker>");
352 printf("%s", widetag_names
[type
>> 2]);
357 static void print_otherimm(lispobj obj
)
359 printf(", %s", widetag_names
[widetag_of(obj
) >> 2]);
361 switch (widetag_of(obj
)) {
362 case CHARACTER_WIDETAG
:
368 case UNBOUND_MARKER_WIDETAG
:
372 printf(": data=%"OBJ_FMTX
, (obj
>>8));
377 static void brief_list(lispobj obj
)
382 if (!is_valid_lisp_addr((os_vm_address_t
)native_pointer(obj
)))
383 printf("(invalid Lisp-level address)");
388 while (lowtag_of(obj
) == LIST_POINTER_LOWTAG
) {
389 struct cons
*cons
= (struct cons
*)native_pointer(obj
);
393 if (++length
>= max_length
) {
398 print_obj("", cons
->car
);
412 static void print_list(lispobj obj
)
414 if (!is_valid_lisp_addr((os_vm_address_t
)native_pointer(obj
))) {
415 printf("(invalid address)");
416 } else if (obj
== NIL
) {
419 struct cons
*cons
= (struct cons
*)native_pointer(obj
);
421 print_obj("car: ", cons
->car
);
422 print_obj("cdr: ", cons
->cdr
);
426 // takes native pointer as input
427 char * simple_base_stringize(struct vector
* string
)
429 if (widetag_of(string
->header
) == SIMPLE_BASE_STRING_WIDETAG
)
430 return (char*)string
->data
;
431 int length
= string
->length
;
432 char * newstring
= malloc(length
+1);
433 uint32_t * data
= (uint32_t*)string
->data
;
435 for(i
=0;i
<length
;++i
)
436 newstring
[i
] = data
[i
] < 128 ? data
[i
] : '?';
437 newstring
[length
] = 0;
441 static void brief_struct(lispobj obj
)
443 struct instance
*instance
= (struct instance
*)native_pointer(obj
);
444 if (!is_valid_lisp_addr((os_vm_address_t
)instance
)) {
445 printf("(invalid address)");
447 extern struct vector
* instance_classoid_name(lispobj
*);
448 struct vector
* classoid_name
;
449 classoid_name
= instance_classoid_name((lispobj
*)instance
);
450 if ( classoid_name
) {
451 char * namestring
= simple_base_stringize(classoid_name
);
452 printf("#<ptr to %p %s instance>",
453 (void*)instance_layout((lispobj
*)instance
), namestring
);
454 if ( namestring
!= (char*)classoid_name
->data
)
457 printf("#<ptr to %p instance>",
458 (void*)instance_layout((lispobj
*)instance
));
463 #include "genesis/layout.h"
464 static boolean
untagged_slot_p(struct layout
* layout
,
467 #ifdef LISP_FEATURE_INTERLEAVED_RAW_SLOTS
468 extern boolean
positive_bignum_logbitp(int,struct bignum
*);
469 lispobj bitmap
= layout
->untagged_bitmap
;
470 return fixnump(bitmap
)
471 ? (fixnum_value(bitmap
) >> slot_index
) & 1
472 : positive_bignum_logbitp(slot_index
,
473 (struct bignum
*)native_pointer(bitmap
));
475 // STANDARD-OBJECT has layout-length = number of defined slots, but
476 // the primitive object always occupies 4 physical words. The guard on
477 // n_untagged_slots ensures that for classes with no slots, we don't
478 // wrongly show all words of the primitive object as untagged,
479 // because the second half of the expression reduces to slot_index>=1.
480 return layout
->n_untagged_slots
> 0
481 && slot_index
>= (fixnum_value(layout
->length
)|1)
482 - fixnum_value(layout
->n_untagged_slots
);
486 static void print_struct(lispobj obj
)
488 struct instance
*instance
= (struct instance
*)native_pointer(obj
);
491 if (!is_valid_lisp_addr((os_vm_address_t
)instance
)) {
492 printf("(invalid address)");
494 lispobj layout_obj
= instance_layout(native_pointer(obj
));
495 print_obj("type: ", layout_obj
);
496 struct layout
* layout
= (struct layout
*)native_pointer(layout_obj
);
497 for (i
=INSTANCE_DATA_START
; i
<instance_length(instance
->header
); i
++) {
498 sprintf(buffer
, "slot %d: ", i
);
499 if (layout
==NULL
|| untagged_slot_p(layout
, i
)) {
501 printf("\n\t %s0x%"OBJ_FMTX
" [raw]", buffer
, instance
->slots
[i
]);
503 print_obj(buffer
, instance
->slots
[i
]);
508 void show_lstring(struct vector
* string
, int quotes
, FILE *s
)
511 int i
, len
= fixnum_value(string
->length
);
513 #ifdef SIMPLE_CHARACTER_STRING_WIDETAG
514 if (widetag_of(string
->header
) == SIMPLE_CHARACTER_STRING_WIDETAG
) {
517 putc('u', s
); /* an arbitrary notational convention */
520 if (quotes
) putc('"', s
);
521 for (i
=0 ; i
<len
; i
++) {
522 // hopefully the compiler will optimize out the ucs4_p test
523 // when the runtime is built without Unicode support
526 ch
= i
[(uint32_t*)string
->data
];
528 ch
= i
[(char*)string
->data
];
529 if (ch
>= 32 && ch
< 127) {
530 if (quotes
&& (ch
== '"' || ch
== '\\'))
534 fprintf(s
, ch
> 0xffff ? "\\U%08X" :
535 ch
> 0xff ? "\\u%04X" : "\\x%02X", ch
);
538 if (quotes
) putc('"', s
);
541 static void brief_otherptr(lispobj obj
)
543 lispobj
*ptr
, header
;
545 struct symbol
*symbol
;
547 ptr
= (lispobj
*) native_pointer(obj
);
549 if (!is_valid_lisp_addr((os_vm_address_t
)obj
)) {
550 printf("(invalid address)");
555 type
= widetag_of(header
);
557 case SYMBOL_HEADER_WIDETAG
:
558 symbol
= (struct symbol
*)ptr
;
559 if (symbol
->package
== NIL
)
561 show_lstring((struct vector
*)native_pointer(symbol
->name
),
565 case SIMPLE_BASE_STRING_WIDETAG
:
566 #ifdef SIMPLE_CHARACTER_STRING_WIDETAG
567 case SIMPLE_CHARACTER_STRING_WIDETAG
:
569 show_lstring((struct vector
*)ptr
, 1, stdout
);
574 brief_otherimm(header
);
579 static void print_slots(char **slots
, int count
, lispobj
*ptr
)
581 while (count
-- > 0) {
583 print_obj(*slots
++, *ptr
++);
585 print_obj("???: ", *ptr
++);
590 /* FIXME: Yikes! This needs to depend on the values in sbcl.h (or
591 * perhaps be generated automatically by GENESIS as part of
593 static char *symbol_slots
[] = {"value: ", "hash: ",
594 "info: ", "name: ", "package: ",
595 #if defined (LISP_FEATURE_SB_THREAD) && !defined(LISP_FEATURE_X86_64)
599 static char *ratio_slots
[] = {"numer: ", "denom: ", NULL
};
600 static char *complex_slots
[] = {"real: ", "imag: ", NULL
};
601 static char *code_slots
[] = {"words: ", "entry: ", "debug: ", NULL
};
602 static char *fn_slots
[] = {
603 "self: ", "next: ", "name: ", "arglist: ", "type: ", "info: ", NULL
};
604 static char *closure_slots
[] = {"fn: ", NULL
};
605 static char *funcallable_instance_slots
[] = {"raw_fn: ", "fn: ", "layout: ", NULL
};
606 static char *weak_pointer_slots
[] = {"value: ", NULL
};
607 static char *fdefn_slots
[] = {"name: ", "function: ", "raw_addr: ", NULL
};
608 static char *value_cell_slots
[] = {"value: ", NULL
};
610 static void print_otherptr(lispobj obj
)
612 if (!is_valid_lisp_addr((os_vm_address_t
)obj
)) {
613 printf("(invalid address)");
615 #ifndef LISP_FEATURE_ALPHA
617 unsigned long header
;
618 unsigned long length
;
624 int count
, type
, index
;
627 ptr
= (lispobj
*) native_pointer(obj
);
629 printf(" (NULL Pointer)");
634 length
= fixnum_value(*ptr
);
635 count
= HeaderValue(header
);
636 type
= widetag_of(header
);
638 print_obj("header: ", header
);
639 if (!other_immediate_lowtag_p(header
)) {
641 printf("(invalid header object)");
645 if (unprintable_array_types
[type
/8] & (1<<(type
% 8)))
654 #if N_WORD_BITS == 32
659 (unsigned long) *--ptr
, (count
?"_":""));
663 print_slots(ratio_slots
, count
, ptr
);
666 case COMPLEX_WIDETAG
:
667 print_slots(complex_slots
, count
, ptr
);
670 case SYMBOL_HEADER_WIDETAG
:
671 // Only 1 byte of a symbol header conveys its size.
672 // The other bytes may be freely used by the backend.
673 print_slots(symbol_slots
, count
& 0xFF, ptr
);
676 #if N_WORD_BITS == 32
677 case SINGLE_FLOAT_WIDETAG
:
679 printf("%g", ((struct single_float
*)native_pointer(obj
))->value
);
682 case DOUBLE_FLOAT_WIDETAG
:
684 printf("%g", ((struct double_float
*)native_pointer(obj
))->value
);
687 #ifdef LONG_FLOAT_WIDETAG
688 case LONG_FLOAT_WIDETAG
:
690 printf("%Lg", ((struct long_float
*)native_pointer(obj
))->value
);
694 #ifdef COMPLEX_SINGLE_FLOAT_WIDETAG
695 case COMPLEX_SINGLE_FLOAT_WIDETAG
:
697 #ifdef LISP_FEATURE_64_BIT
698 printf("%g", ((struct complex_single_float
*)native_pointer(obj
))->data
.data
[0]);
700 printf("%g", ((struct complex_single_float
*)native_pointer(obj
))->real
);
703 #ifdef LISP_FEATURE_64_BIT
704 printf("%g", ((struct complex_single_float
*)native_pointer(obj
))->data
.data
[1]);
706 printf("%g", ((struct complex_single_float
*)native_pointer(obj
))->imag
);
711 #ifdef COMPLEX_DOUBLE_FLOAT_WIDETAG
712 case COMPLEX_DOUBLE_FLOAT_WIDETAG
:
714 printf("%g", ((struct complex_double_float
*)native_pointer(obj
))->real
);
716 printf("%g", ((struct complex_double_float
*)native_pointer(obj
))->imag
);
720 #ifdef COMPLEX_LONG_FLOAT_WIDETAG
721 case COMPLEX_LONG_FLOAT_WIDETAG
:
723 printf("%Lg", ((struct complex_long_float
*)native_pointer(obj
))->real
);
725 printf("%Lg", ((struct complex_long_float
*)native_pointer(obj
))->imag
);
729 case SIMPLE_BASE_STRING_WIDETAG
:
730 #ifdef SIMPLE_CHARACTER_STRING_WIDETAG
731 case SIMPLE_CHARACTER_STRING_WIDETAG
:
734 show_lstring((struct vector
*)native_pointer(obj
), 1, stdout
);
737 case SIMPLE_VECTOR_WIDETAG
:
739 printf("length = %ld", length
);
742 while (length
-- > 0) {
743 sprintf(buffer
, "%d: ", index
++);
744 print_obj(buffer
, *ptr
++);
748 // FIXME: This case looks unreachable. print_struct() does it
749 case INSTANCE_HEADER_WIDETAG
:
751 printf("length = %ld", (long) count
);
753 while (count
-- > 0) {
754 sprintf(buffer
, "%d: ", index
++);
755 print_obj(buffer
, *ptr
++);
759 case CODE_HEADER_WIDETAG
:
760 print_slots(code_slots
, count
-1, ptr
);
763 case SIMPLE_FUN_HEADER_WIDETAG
:
764 print_slots(fn_slots
, 6, ptr
);
767 #if !defined(LISP_FEATURE_X86) && !defined(LISP_FEATURE_X86_64)
768 case RETURN_PC_HEADER_WIDETAG
:
769 print_obj("code: ", obj
- (count
* 4));
773 case CLOSURE_HEADER_WIDETAG
:
774 print_slots(closure_slots
, count
, ptr
);
777 case FUNCALLABLE_INSTANCE_HEADER_WIDETAG
:
778 print_slots(funcallable_instance_slots
, count
, ptr
);
781 case VALUE_CELL_HEADER_WIDETAG
:
782 print_slots(value_cell_slots
, 1, ptr
);
787 #ifndef LISP_FEATURE_ALPHA
788 printf("0x%08lx", (unsigned long) *ptr
);
790 printf("0x%016lx", *(lispobj
*)(ptr
+1));
794 case WEAK_POINTER_WIDETAG
:
795 print_slots(weak_pointer_slots
, 1, ptr
);
798 case CHARACTER_WIDETAG
:
799 case UNBOUND_MARKER_WIDETAG
:
801 printf("pointer to an immediate?");
805 print_slots(fdefn_slots
, count
, ptr
);
810 printf("Unknown header object?");
816 static void print_obj(char *prefix
, lispobj obj
)
818 #ifdef LISP_FEATURE_64_BIT
819 static void (*verbose_fns
[])(lispobj obj
)
820 = {print_fixnum
, print_otherimm
, print_fixnum
, print_struct
,
821 print_fixnum
, print_otherimm
, print_fixnum
, print_list
,
822 print_fixnum
, print_otherimm
, print_fixnum
, print_otherptr
,
823 print_fixnum
, print_otherimm
, print_fixnum
, print_otherptr
};
824 static void (*brief_fns
[])(lispobj obj
)
825 = {brief_fixnum
, brief_otherimm
, brief_fixnum
, brief_struct
,
826 brief_fixnum
, brief_otherimm
, brief_fixnum
, brief_list
,
827 brief_fixnum
, brief_otherimm
, brief_fixnum
, brief_otherptr
,
828 brief_fixnum
, brief_otherimm
, brief_fixnum
, brief_otherptr
};
830 static void (*verbose_fns
[])(lispobj obj
)
831 = {print_fixnum
, print_struct
, print_otherimm
, print_list
,
832 print_fixnum
, print_otherptr
, print_otherimm
, print_otherptr
};
833 static void (*brief_fns
[])(lispobj obj
)
834 = {brief_fixnum
, brief_struct
, brief_otherimm
, brief_list
,
835 brief_fixnum
, brief_otherptr
, brief_otherimm
, brief_otherptr
};
837 int type
= lowtag_of(obj
);
838 struct var
*var
= lookup_by_obj(obj
);
840 boolean verbose
= cur_depth
< brief_depth
;
842 if (!continue_p(verbose
))
845 if (var
!= NULL
&& var_clock(var
) == cur_clock
)
848 if (var
== NULL
&& is_lisp_pointer(obj
))
849 var
= define_var(NULL
, obj
, 0);
852 var_setclock(var
, cur_clock
);
857 sprintf(buffer
, "$%s=", var_name(var
));
862 printf("%s0x%08lx: ", prefix
, (unsigned long) obj
);
863 if (cur_depth
< brief_depth
) {
864 fputs(lowtag_names
[type
], stdout
);
865 (*verbose_fns
[type
])(obj
);
868 (*brief_fns
[type
])(obj
);
872 printf("$%s", var_name(var
));
875 printf("$%s=", var_name(var
));
876 (*brief_fns
[type
])(obj
);
890 void print(lispobj obj
)
902 void brief_print(lispobj obj
)
917 brief_print(lispobj obj
)
919 printf("lispobj 0x%lx\n", (unsigned long)obj
);
922 #endif /* defined(LISP_FEATURE_SB_LDB) */