haiku.git

/*
 * Copyright 2018, Haiku, Inc. All rights reserved.
 * Based on Demumble; Copyright 2016-2018, Nico Weber.
 * 		https://github.com/nico/demumble/
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>

#include "Demangler.h"


static void print_help(FILE* out)
{
	fprintf(out,
		"usage: haikuc++filt [options] [symbols...]\n"
		"\n"
		"if symbols are unspecified, reads from stdin.\n"
		"\n"
		"options:\n"
		"  -m         only print mangled names that were demangled,"
			"omit other output\n"
		"  -u         use unbuffered output\n"
		"  --no-gcc2	ignore GCC 2-style symbols\n");
}


static bool starts_with(const char* s, const char* prefix)
{
	return strncmp(s, prefix, strlen(prefix)) == 0;
}


static void print_demangled(const char* s)
{
	const char* cxa_in = s;
	if (starts_with(s, "__Z") || starts_with(s, "____Z"))
		cxa_in += 1;
	printf("%s", Demangler::Demangle(cxa_in).String());
}


static bool is_mangle_char_posix(char c)
{
	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
		(c >= '0' && c <= '9') || c == '_';
}


static bool look_for_itanium_prefix(char** str, char* end)
{
	char* s = *str;
	s += strcspn(s, "_?");
	if (s == end)
		return false;

	// Itanium symbols start with 1-4 underscores followed by Z.
	// strnstr() is BSD, so use a small local buffer and strstr().
	const int N = 5;  // == strlen("____Z")
	char prefix[N + 1];
	strncpy(prefix, s, N);
		prefix[N] = '\0';
	if (strstr(prefix, "_Z")) {
		*str = s;
		return true;
	}
	return false;
}


static bool look_for_gcc2_symbol(char** str, char* end)
{
	// search '__' starting from the end, don't accept them at the start
	char* s = *str;
	size_t pos = (end - s) - 1;
	char* mangled = NULL;

	while (pos > 1) {
		if (s[pos] == '_') {
			if (s[pos - 1] == '_') {
				mangled = s + pos + 1;
				break;
			} else
				pos--;
		}
		pos--;
	}

	// if we've found a symbol, go backwards to its beginning
	while (mangled != NULL && mangled > (s + 1)
			&& is_mangle_char_posix(mangled[-1])) {
		mangled--;
	}

	if (mangled != NULL)
		*str = mangled;

	return mangled != NULL;
}


static char buf[8192];
int main(int argc, char* argv[])
{
	enum { kPrintAll, kPrintMatching } print_mode = kPrintAll;
	bool noGCC2 = false;

	while (argc > 1 && argv[1][0] == '-') {
		if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
			print_help(stdout);
			return 0;
		} else if (strcmp(argv[1], "-m") == 0) {
			print_mode = kPrintMatching;
		} else if (strcmp(argv[1], "--no-gcc2") == 0) {
			noGCC2 = true;
		} else if (strcmp(argv[1], "-u") == 0) {
			setbuf(stdout, NULL);
		} else if (strcmp(argv[1], "--") == 0) {
			--argc;
			++argv;
			break;
		} else {
			fprintf(stderr, "c++filt: unrecognized option `%s'\n", argv[1]);
			print_help(stderr);
			return 1;
		}
		--argc;
		++argv;
	}
	for (int i = 1; i < argc; ++i) {
		print_demangled(argv[i]);
		printf("\n");
	}
	if (argc != 1)
		return 0;
	// Read stdin instead.
	// By default, don't demangle types.  Mangled function names are unlikely
	// to appear in text for since they start with _Z (or ___Z) or ?? / ?$ / ?@.
	// But type manglings can be regular words ("Pi" is "int*").
	// (For command-line args, do try to demangle types though.)
	while (fgets(buf, sizeof(buf), stdin)) {
		bool need_separator = false;
		char* cur = buf;
		char* end = cur + strlen(cur);

		while (cur != end) {
			if (print_mode == kPrintMatching && need_separator)
				printf("\n");
			need_separator = false;

			// Check if we have a symbol, and then for how long it is.
			size_t n_sym = 0;
			char* real_cur = cur;
			if (look_for_itanium_prefix(&real_cur, end) ||
					(!noGCC2 && look_for_gcc2_symbol(&real_cur, end))) {
				// Print all the stuff before the symbol.
				if (print_mode == kPrintAll)
					printf("%.*s", static_cast<int>(real_cur - cur), cur);
				cur = real_cur;
				while (cur + n_sym != end && is_mangle_char_posix(cur[n_sym]))
					++n_sym;
			} else {
				// No symbols found in this block; skip it.
				printf("%s", cur);
				cur = end;
				continue;
			}
			if (n_sym == 0) {
				++cur;
				continue;
			}

			char tmp = cur[n_sym];
			cur[n_sym] = '\0';
			print_demangled(cur);
			need_separator = true;
			cur[n_sym] = tmp;

			cur += n_sym;
		}
	}
}