// Copyright 2019-2020 CERN and copyright holders of ALICE O2.

// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.

// All rights not expressly granted are reserved.

//

// This software is distributed under the terms of the GNU General Public

// License v3 (GPL Version 3), copied verbatim in the file "COPYING".

//

// In applying this license CERN does not waive the privileges and immunities

// granted to it by virtue of its status as an Intergovernmental Organization

// or submit itself to any jurisdiction.

#include "Framework/BacktraceHelpers.h"

#include <climits>

#include <cstddef>

#include <cstdio>

#include <cstdlib>

#include <unistd.h>

#include <cxxabi.h>

#include <execinfo.h>

namespace o2::framework

{

void BacktraceHelpers::demangled_backtrace_symbols(void** stackTrace, unsigned int stackDepth, int fd)

{

char** stackStrings;

stackStrings = backtrace_symbols(stackTrace, stackDepth);

char exe[PATH_MAX];

bool hasExe = false;

int exeSize = 0;

#if __linux__

exeSize = readlink("/proc/self/exe", exe, PATH_MAX);

if (exeSize == -1) {

dprintf(fd, "Unable to detect exectuable name\n");

hasExe = false;

} else {

dprintf(fd, "Executable is %.*s\n", exeSize, exe);

hasExe = true;

}

#endif

// We skip the level 0, which is the actual logging function.

for (size_t i = 1; i < stackDepth; i++) {

size_t sz = 64000; // 64K ought to be enough for our templates...

char* function = static_cast<char*>(malloc(sz));

char *begin = nullptr, *end = nullptr;

// find the last space and address offset surrounding the mangled name

#if __APPLE__

for (char* j = stackStrings[i]; *j; ++j) {

if (*j == ' ' && *(j + 1) != '+') {

begin = j;

} else if (*j == ' ' && *(j + 1) == '+') {

end = j;

break;

}

}

bool tryAddr2Line = false;

#else

for (char* j = stackStrings[i]; j && *j; ++j) {

if (*j == '(') {

begin = j;

} else if (*j == '+') {

end = j;

break;

}

}

bool tryAddr2Line = true;

#endif

if (begin && end) {

// The first byte is a ' ' which we need to skip.

*begin++ = '\0';

*end = '\0';

// found our mangled name, now in [begin, end)

int status;

char* ret = abi::__cxa_demangle(begin, function, &sz, &status);

if (status == 0) {

// return value may be a realloc() of the input

function = ret;

dprintf(fd, " %s: %s\n", stackStrings[i], function);

tryAddr2Line = false;

} else {

tryAddr2Line = true;

}

}

if (tryAddr2Line) {

// didn't find the mangled name, just print the whole line

dprintf(fd, " %s: ", stackStrings[i]);

if (stackTrace[i] && hasExe) {

char syscom[4096 + PATH_MAX];

// Find c++filt from the environment

// This is needed for platforms where we still need c++filt -r

static char const* cxxfilt = getenv("CXXFILT");

if (cxxfilt == nullptr) {

cxxfilt = "c++filt";

}

// Do the same for addr2line, just in case we wanted to pass some options

static char const* addr2line = getenv("ADDR2LINE");

if (addr2line == nullptr) {

addr2line = "addr2line";

}

snprintf(syscom, 4096, "%s %p -p -s -f -e %.*s 2>/dev/null | %s ", addr2line, stackTrace[i], exeSize, exe, cxxfilt); // last parameter is the name of this app

FILE* fp;

char path[1024];

fp = popen(syscom, "r");

if (fp == nullptr) {

// We could not run addr2line, print whatever we have.

// Also free function, which is allocated at the beginning of the loop.

dprintf(fd, "%s\n", begin);

free(function);

continue;

}

while (fgets(path, sizeof(path) - 1, fp) != nullptr) {

dprintf(fd, " %s", path);

}

pclose(fp);

} else {

dprintf(fd, "%s\n", begin);

}

}

free(function);

}

free(stackStrings); // malloc()ed by backtrace_symbols

fsync(fd);

}

} // namespace o2::framework