1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 #include <stdio.h> 27 #include <demangle.h> 28 #include "_conv.h" 29 #include "demangle_msg.h" 30 31 /* 32 * Demangle C++ symbols. 33 * 34 * This routine acts as a generic routine for use by liblddbg (and hence tools 35 * like elfdump(1) and pvs(1)), ld(1) and ld.so.1(1). 36 * 37 * The C++ ABI-2 places no limits on symbol names, thus when demangling a name 38 * it's possible the buffer won't be big enough (DEMANGLE_ESPACE) so here we 39 * try to allocate bigger buffers. However, we place a limit on this buffer 40 * size for fear of a C++ error sending us into an infinit loop. 41 * 42 * NOTE. we create and use a common buffer for use by cplus_demangle(), thus 43 * each call to this routine will override the contents of any existing call. 44 * Normally this is sufficient for typical error diagnostics referencing one 45 * symbol. For those diagnostics using more than one symbol name, all but the 46 * last name must be copied to a temporary buffer (regardless of whether 47 * demangling occurred, as the process of attempting to demangle may damage the 48 * buffer). One model is: 49 * 50 * if ((_name1 = demangle(name1)) != name1) { 51 * char * __name1 = strdupa(_name1); 52 * name1 = (const char *)__name1; 53 * } 54 * name2 = demangle(name2); 55 * eprintf(format, name1, name2); 56 */ 57 #define SYM_MAX 1000 58 59 const char * 60 conv_demangle_name(const char *name) 61 { 62 static char _str[SYM_MAX], *str = _str; 63 static size_t size = SYM_MAX; 64 static int again = 1; 65 static int (*fptr)() = 0; 66 int error; 67 68 if (str == 0) 69 return (name); 70 71 /* 72 * If we haven't located the demangler yet try now (we do this rather 73 * than maintain a static dependency on libdemangle as it's part of an 74 * optional package). Null the str element out to reject any other 75 * callers until this operation is complete - under ld.so.1 we can get 76 * into serious recursion without this. 77 */ 78 if (fptr == 0) { 79 void *hdl; 80 81 str = 0; 82 if (!(hdl = dlopen(MSG_ORIG(MSG_DEM_LIB), RTLD_LAZY)) || 83 !(fptr = (int (*)())dlsym(hdl, MSG_ORIG(MSG_DEM_SYM)))) 84 return (name); 85 str = _str; 86 } 87 88 if ((error = (*fptr)(name, str, size)) == 0) 89 return ((const char *)str); 90 91 while ((error == DEMANGLE_ESPACE) && again) { 92 char *_str; 93 size_t _size = size; 94 95 /* 96 * If we haven't allocated our maximum try incrementing the 97 * present buffer size. Use malloc() rather than realloc() so 98 * that we at least have the old buffer on failure. 99 */ 100 if (((_size += SYM_MAX) > (SYM_MAX * 4)) || 101 ((_str = malloc(_size)) == 0)) { 102 again = 0; 103 break; 104 } 105 if (size != SYM_MAX) { 106 free(str); 107 } 108 str = _str; 109 size = _size; 110 111 if ((error = (*fptr)(name, str, size)) == 0) 112 return ((const char *)str); 113 } 114 return (name); 115 } 116