/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2015 Couchbase, Inc
 *
 *   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 "backtrace.h"

#include <inttypes.h>

#if defined(WIN32) && defined(HAVE_BACKTRACE_SUPPORT)
#define WIN32_LEAN_AND_MEAN
#include <Dbghelp.h>
#include <windows.h>
#endif

#if defined(HAVE_BACKTRACE) && defined(HAVE_DLADDR)
#define HAVE_BACKTRACE_SUPPORT 1
#include <dlfcn.h>    // for dladdr()
#include <execinfo.h> // for backtrace()
#include <stddef.h>   // for ptrdiff_t
#endif

// Maximum number of frames that will be printed.
#define MAX_FRAMES 50

#if defined(HAVE_BACKTRACE_SUPPORT)
/**
 * Populates buf with a description of the given address in the program.
 **/
static void
describe_address(char* msg, size_t len, void* addr)
{
#if defined(WIN32)

    // Get module information
    IMAGEHLP_MODULE64 module_info;
    module_info.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
    SymGetModuleInfo64(GetCurrentProcess(), (DWORD64)addr, &module_info);

    // Get symbol information.
    DWORD64 displacement = 0;
    char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR)];
    PSYMBOL_INFO sym_info = (PSYMBOL_INFO)buffer;
    sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
    sym_info->MaxNameLen = MAX_SYM_NAME;

    if (SymFromAddr(GetCurrentProcess(), (DWORD64)addr, &displacement, sym_info)) {
        snprintf(msg, len, "%s(%s+%lld) [0x%p]", module_info.ImageName ? module_info.ImageName : "", sym_info->Name, displacement, addr);
    } else {
        // No symbol found.
        snprintf(msg, len, "[0x%p]", addr);
    }
#else  // !WIN32
    Dl_info info;
    int status = dladdr(addr, &info);

    if (status != 0) {
        ptrdiff_t image_offset = (char*)addr - (char*)info.dli_fbase;
        if (info.dli_fname != NULL && info.dli_fname[0] != '\0') {
            // Found a nearest symbol - print it.
            if (info.dli_saddr == 0) {
                // No function offset calculation possible.
                snprintf(msg,
                         len,
                         "%s(%s) [%p+0x%" PRIx64 "]",
                         info.dli_fname,
                         info.dli_sname ? info.dli_sname : "",
                         info.dli_fbase,
                         (uint64_t)image_offset);
            } else {
                char sign;
                ptrdiff_t offset;
                if (addr >= info.dli_saddr) {
                    sign = '+';
                    offset = (char*)addr - (char*)info.dli_saddr;
                } else {
                    sign = '-';
                    offset = (char*)info.dli_saddr - (char*)addr;
                }
                snprintf(msg,
                         len,
                         "%s(%s%c%#tx) [%p+0x%" PRIx64 "]",
                         info.dli_fname,
                         info.dli_sname ? info.dli_sname : "",
                         sign,
                         offset,
                         info.dli_fbase,
                         (uint64_t)image_offset);
            }
        } else {
            // No function found; just print library name and offset.
            snprintf(msg, len, "%s [%p+0x%" PRIx64 "]", info.dli_fname, info.dli_fbase, (uint64_t)image_offset);
        }
    } else {
        // dladdr failed.
        snprintf(msg, len, "[%p]", addr);
    }
#endif // WIN32
}

void
print_backtrace(write_cb_t write_cb, void* context)
{
    void* frames[MAX_FRAMES];
#if defined(WIN32)
    int active_frames = CaptureStackBackTrace(0, MAX_FRAMES, frames, NULL);
    SymInitialize(GetCurrentProcess(), NULL, TRUE);
#else
    int active_frames = backtrace(frames, MAX_FRAMES);
#endif

    // Note we start from 1 to skip our own frame.
    for (int ii = 1; ii < active_frames; ii++) {
        // Fixed-sized buffer; possible that description will be cropped.
        char msg[300];
        describe_address(msg, sizeof(msg), frames[ii]);
        write_cb(context, msg);
    }
    if (active_frames == MAX_FRAMES) {
        write_cb(context, "<frame limit reached, possible truncation>");
    }
}

#else // if defined(HAVE_BACKTRACE_SUPPORT)

void
print_backtrace(write_cb_t write_cb, void* context)
{
    write_cb(context, "<backtrace not supported on this platform>");
}

#endif // defined(HAVE_BACKTRACE_SUPPORT)

static void
print_to_file_cb(void* ctx, const char* frame)
{
    fprintf(ctx, "\t%s\n", frame);
}

void
print_backtrace_to_file(FILE* stream)
{
    print_backtrace(print_to_file_cb, stream);
}

struct context {
    const char* indent;
    char* buffer;
    size_t size;
    size_t offset;
    bool error;
};

static void
memory_cb(void* ctx, const char* frame)
{
    struct context* c = ctx;

    if (!c->error) {

        int length = snprintf(c->buffer + c->offset, c->size - c->offset, "%s%s\n", c->indent, frame);

        if ((length < 0) || (length >= (int)(c->size - c->offset))) {
            c->error = true;
        } else {
            c->offset += (size_t)length;
        }
    }
}

bool
print_backtrace_to_buffer(const char* indent, char* buffer, size_t size)
{
    struct context c = { .indent = indent, .buffer = buffer, .size = size, .offset = 0, .error = false };
    print_backtrace(memory_cb, &c);
    return !c.error;
}