mirror of
https://github.com/Zenithsiz/ftmemsim-valgrind.git
synced 2026-02-13 14:42:03 +00:00
f9a9e03c7a
branch hereby becomes inactive. This currently breaks everything except x86; fixes for amd64/ppc32 to follow. git-svn-id: svn://svn.valgrind.org/valgrind/trunk@5520
266 lines
8.0 KiB
C
266 lines
8.0 KiB
C
|
|
/*--------------------------------------------------------------------*/
|
|
/*--- Demangling of C++ mangled names. demangle.c ---*/
|
|
/*--------------------------------------------------------------------*/
|
|
|
|
/*
|
|
This file is part of Valgrind, a dynamic binary instrumentation
|
|
framework.
|
|
|
|
Copyright (C) 2000-2005 Julian Seward
|
|
jseward@acm.org
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the
|
|
License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
02111-1307, USA.
|
|
|
|
The GNU General Public License is contained in the file COPYING.
|
|
*/
|
|
|
|
#include "pub_core_basics.h"
|
|
#include "pub_core_demangle.h"
|
|
#include "pub_core_libcbase.h"
|
|
#include "pub_core_mallocfree.h"
|
|
#include "pub_core_options.h"
|
|
#include "pub_core_libcassert.h"
|
|
#include "demangle.h"
|
|
#include "pub_core_libcprint.h"
|
|
|
|
/* The demangler's job is to take a raw symbol name and turn it into
|
|
something a Human Bean can understand. There are two levels of
|
|
mangling.
|
|
|
|
1. First, C++ names are mangled by the compiler. So we'll have to
|
|
undo that.
|
|
|
|
2. Optionally, in relatively rare cases, the resulting name is then
|
|
itself encoded using Z-escaping (see pub_core_redir.h) so as to
|
|
become part of a redirect-specification.
|
|
|
|
Therefore, VG_(demangle) first tries to undo (2). If successful,
|
|
the soname part is discarded (humans don't want to see that).
|
|
Then, it tries to undo (1) (using demangling code from GNU/FSF).
|
|
*/
|
|
|
|
/* This is the main, standard demangler entry point. */
|
|
|
|
void VG_(demangle) ( Char* orig, Char* result, Int result_size )
|
|
{
|
|
# define N_ZBUF 4096
|
|
HChar* demangled = NULL;
|
|
HChar z_demangled[N_ZBUF];
|
|
|
|
if (!VG_(clo_demangle)) {
|
|
VG_(strncpy_safely)(result, orig, result_size);
|
|
return;
|
|
}
|
|
|
|
/* Demangling was requested. First see if it's a Z-mangled
|
|
intercept specification. The fastest way is just to attempt a
|
|
Z-demangling (with NULL soname buffer, since we're not
|
|
interested in that). */
|
|
if (VG_(maybe_Z_demangle)( orig, NULL,0,/*soname*/
|
|
z_demangled, N_ZBUF, NULL)) {
|
|
orig = z_demangled;
|
|
}
|
|
|
|
demangled = VG_(cplus_demangle) ( orig, DMGL_ANSI | DMGL_PARAMS );
|
|
|
|
if (demangled) {
|
|
VG_(strncpy_safely)(result, demangled, result_size);
|
|
VG_(arena_free) (VG_AR_DEMANGLE, demangled);
|
|
} else {
|
|
VG_(strncpy_safely)(result, orig, result_size);
|
|
}
|
|
|
|
// 13 Mar 2005: We used to check here that the demangler wasn't leaking
|
|
// by calling the (now-removed) function VG_(is_empty_arena)(). But,
|
|
// very rarely (ie. I've heard of it twice in 3 years), the demangler
|
|
// does leak. But, we can't do much about it, and it's not a disaster,
|
|
// so we just let it slide without aborting or telling the user.
|
|
|
|
# undef N_ZBUF
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------*/
|
|
/*--- DEMANGLE Z-ENCODED NAMES ---*/
|
|
/*------------------------------------------------------------*/
|
|
|
|
/* Demangle a Z-encoded name as described in pub_tool_redir.h.
|
|
Z-encoded names are used by Valgrind for doing function
|
|
interception/wrapping.
|
|
|
|
Demangle 'sym' into its soname and fnname parts, putting them in
|
|
the specified buffers. Returns a Bool indicating whether the
|
|
demangled failed or not. A failure can occur because the prefix
|
|
isn't recognised, the internal Z-escaping is wrong, or because one
|
|
or the other (or both) of the output buffers becomes full. Passing
|
|
'so' as NULL is acceptable if the caller is only interested in the
|
|
function name part. */
|
|
|
|
Bool VG_(maybe_Z_demangle) ( const HChar* sym,
|
|
/*OUT*/HChar* so, Int soLen,
|
|
/*OUT*/HChar* fn, Int fnLen,
|
|
/*OUT*/Bool* isWrap )
|
|
{
|
|
# define EMITSO(ch) \
|
|
do { \
|
|
if (so) { \
|
|
if (soi >= soLen) { \
|
|
so[soLen-1] = 0; oflow = True; \
|
|
} else { \
|
|
so[soi++] = ch; so[soi] = 0; \
|
|
} \
|
|
} \
|
|
} while (0)
|
|
# define EMITFN(ch) \
|
|
do { \
|
|
if (fni >= fnLen) { \
|
|
fn[fnLen-1] = 0; oflow = True; \
|
|
} else { \
|
|
fn[fni++] = ch; fn[fni] = 0; \
|
|
} \
|
|
} while (0)
|
|
|
|
Bool error, oflow, valid, fn_is_encoded;
|
|
Int soi, fni, i;
|
|
|
|
vg_assert(soLen > 0 || (soLen == 0 && so == NULL));
|
|
vg_assert(fnLen > 0);
|
|
error = False;
|
|
oflow = False;
|
|
soi = 0;
|
|
fni = 0;
|
|
|
|
valid = sym[0] == '_'
|
|
&& sym[1] == 'v'
|
|
&& sym[2] == 'g'
|
|
&& (sym[3] == 'r' || sym[3] == 'w' || sym[3] == 'n')
|
|
&& sym[4] == 'Z'
|
|
&& (sym[5] == 'Z' || sym[5] == 'U')
|
|
&& sym[6] == '_';
|
|
if (!valid)
|
|
return False;
|
|
|
|
fn_is_encoded = sym[5] == 'Z';
|
|
|
|
if (isWrap)
|
|
*isWrap = sym[3] == 'w';
|
|
|
|
/* Now scan the Z-encoded soname. */
|
|
i = 7;
|
|
while (True) {
|
|
|
|
if (sym[i] == '_')
|
|
/* Found the delimiter. Move on to the fnname loop. */
|
|
break;
|
|
|
|
if (sym[i] == 0) {
|
|
error = True;
|
|
goto out;
|
|
}
|
|
|
|
if (sym[i] != 'Z') {
|
|
EMITSO(sym[i]);
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
/* We've got a Z-escape. */
|
|
i++;
|
|
switch (sym[i]) {
|
|
case 'a': EMITSO('*'); break;
|
|
case 'p': EMITSO('+'); break;
|
|
case 'c': EMITSO(':'); break;
|
|
case 'd': EMITSO('.'); break;
|
|
case 'u': EMITSO('_'); break;
|
|
case 'h': EMITSO('-'); break;
|
|
case 's': EMITSO(' '); break;
|
|
case 'Z': EMITSO('Z'); break;
|
|
case 'A': EMITSO('@'); break;
|
|
default: error = True; goto out;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
vg_assert(sym[i] == '_');
|
|
i++;
|
|
|
|
/* Now deal with the function name part. */
|
|
if (!fn_is_encoded) {
|
|
|
|
/* simple; just copy. */
|
|
while (True) {
|
|
if (sym[i] == 0)
|
|
break;
|
|
EMITFN(sym[i]);
|
|
i++;
|
|
}
|
|
goto out;
|
|
|
|
}
|
|
|
|
/* else use a Z-decoding loop like with soname */
|
|
while (True) {
|
|
|
|
if (sym[i] == 0)
|
|
break;
|
|
|
|
if (sym[i] != 'Z') {
|
|
EMITFN(sym[i]);
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
/* We've got a Z-escape. */
|
|
i++;
|
|
switch (sym[i]) {
|
|
case 'a': EMITFN('*'); break;
|
|
case 'p': EMITFN('+'); break;
|
|
case 'c': EMITFN(':'); break;
|
|
case 'd': EMITFN('.'); break;
|
|
case 'u': EMITFN('_'); break;
|
|
case 'h': EMITFN('-'); break;
|
|
case 's': EMITFN(' '); break;
|
|
case 'Z': EMITFN('Z'); break;
|
|
case 'A': EMITFN('@'); break;
|
|
default: error = True; goto out;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
out:
|
|
EMITSO(0);
|
|
EMITFN(0);
|
|
|
|
if (error) {
|
|
/* Something's wrong. Give up. */
|
|
VG_(message)(Vg_UserMsg, "m_demangle: error Z-demangling: %s", sym);
|
|
return False;
|
|
}
|
|
if (oflow) {
|
|
/* It didn't fit. Give up. */
|
|
VG_(message)(Vg_UserMsg, "m_demangle: oflow Z-demangling: %s", sym);
|
|
return False;
|
|
}
|
|
|
|
return True;
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------*/
|
|
/*--- end ---*/
|
|
/*--------------------------------------------------------------------*/
|