// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements.  See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership.  The ASF licenses this file

// to you 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 "util/bfd_parser.h"

#include <stdio.h>

#include <stdlib.h>

#include <algorithm>

#include <memory>

#include <ostream>

#include "common/logging.h"

namespace doris {

struct BfdFindCtx {

    BfdFindCtx(bfd_symbol** syms_, bfd_vma pc_)

            : found(false),

              syms(syms_),

              pc(pc_),

              file_name(nullptr),

              func_name(nullptr),

              lineno(0) {}

    bool found;

    bfd_symbol** syms;

    bfd_vma pc;

    const char* file_name;

    const char* func_name;

    unsigned int lineno;

};

std::mutex BfdParser::_bfd_mutex;

bool BfdParser::_is_bfd_inited = false;

static void find_addr_in_section(bfd* abfd, asection* sec, void* arg) {

    BfdFindCtx* ctx = (BfdFindCtx*)arg;

    if (ctx->found) {

        return;

    }

#ifdef bfd_get_section_flags

    if ((bfd_get_section_flags(abfd, sec) & SEC_ALLOC) == 0) {

        return;

    }

#else

    if ((bfd_section_flags(sec) & SEC_ALLOC) == 0) {

        return;

    }

#endif

#ifdef bfd_get_section_vma

    auto vma = bfd_get_section_vma(abfd, sec);

#else

    auto vma = bfd_section_vma(sec);

#endif

    if (ctx->pc < vma) {

        return;

    }

#ifdef bfd_get_section_size

    auto size = bfd_get_section_size(sec);

#else

    auto size = bfd_section_size(sec);

#endif

    if (ctx->pc >= vma + size) {

        return;

    }

    ctx->found = bfd_find_nearest_line(abfd, sec, ctx->syms, ctx->pc - vma, &ctx->file_name,

                                       &ctx->func_name, &ctx->lineno);

}

static void section_print(bfd* bfd, asection* sec, void* arg) {

    std::string* str = (std::string*)arg;

    str->append(sec->name);

    str->push_back('\n');

}

void BfdParser::init_bfd() {

    if (_is_bfd_inited) {

        return;

    }

    std::lock_guard<std::mutex> lock(_bfd_mutex);

    bfd_init();

    // The default target must match the host architecture: hardcoding

    // "elf64-x86-64" fails on aarch64 (libbfd there does not bundle the x86

    // backend) and logs a spurious error on every BE start.

#if defined(__aarch64__)

    static constexpr const char* kDefaultTarget = "elf64-littleaarch64";

#elif defined(__x86_64__)

    static constexpr const char* kDefaultTarget = "elf64-x86-64";

#else

    static constexpr const char* kDefaultTarget = nullptr;

#endif

    if (kDefaultTarget != nullptr && !bfd_set_default_target(kDefaultTarget)) {

        LOG(ERROR) << "set default target to " << kDefaultTarget << " failed.";

    }

    _is_bfd_inited = true;

}

BfdParser* BfdParser::create() {

    FILE* file = fopen("/proc/self/cmdline", "r");

    if (file == nullptr) {

        return nullptr;

    }

    char prog_name[1024];

    if (fscanf(file, "%1023s ", prog_name) != 1) {

        fclose(file);

        return nullptr;

    }

    fclose(file);

    std::unique_ptr<BfdParser> parser(new BfdParser(prog_name));

    if (parser->parse()) {

        return nullptr;

    }

    return parser.release();

}

BfdParser* BfdParser::create(const std::string& prog_name) {

    std::unique_ptr<BfdParser> parser(new BfdParser(prog_name));

    if (parser->parse()) {

        return nullptr;

    }

    return parser.release();

}

void BfdParser::list_targets(std::vector<std::string>* out) {

    if (!_is_bfd_inited) {

        init_bfd();

    }

    const char** targets = bfd_target_list();

    const char** p = targets;

    while ((*p) != nullptr) {

        out->emplace_back(*p++);

    }

    free(targets);

}

BfdParser::BfdParser(const std::string& file_name)

        : _file_name(file_name), _abfd(nullptr), _syms(nullptr), _num_symbols(0), _symbol_size(0) {

    if (!_is_bfd_inited) {

        init_bfd();

    }

}

BfdParser::~BfdParser() {

    if (_syms != nullptr) {

        free(_syms);

    }

    if (_abfd != nullptr) {

        bfd_close(_abfd);

    }

}

void BfdParser::list_sections(std::string* ss) {

    std::lock_guard<std::mutex> lock(_mutex);

    bfd_map_over_sections(_abfd, section_print, (void*)ss);

}

static void list_matching_formats(char** p, std::string* message) {

    if (!p || !*p) {

        return;

    }

    message->append(": Matching formats: ");

    while (*p) {

        message->append(*p++);

    }

    message->push_back('\n');

}

int BfdParser::open_bfd() {

    _abfd = bfd_openr(_file_name.c_str(), nullptr);

    if (_abfd == nullptr) {

        LOG(WARNING) << "bfd_openr failed because errmsg=" << bfd_errmsg(bfd_get_error());

        return -1;

    }

    if (bfd_check_format(_abfd, bfd_archive)) {

        LOG(WARNING) << "bfd_check_format for archive failed because errmsg="

                     << bfd_errmsg(bfd_get_error());

        return -1;

    }

    char** matches = nullptr;

    if (!bfd_check_format_matches(_abfd, bfd_object, &matches)) {

        if (bfd_get_error() == bfd_error_file_ambiguously_recognized) {

            std::string message = _file_name;

            list_matching_formats(matches, &message);

            free(matches);

            LOG(WARNING) << "bfd_check_format_matches failed because errmsg="

                         << bfd_errmsg(bfd_get_error()) << " and " << message;

        } else {

            LOG(WARNING) << "bfd_check_format_matches failed because errmsg="

                         << bfd_errmsg(bfd_get_error());

        }

        return -1;

    }

    return 0;

}

int BfdParser::load_symbols() {

    if ((bfd_get_file_flags(_abfd) & HAS_SYMS) == 0) {

        // No need to load symbols;

        return 0;

    }

    _num_symbols = bfd_read_minisymbols(_abfd, FALSE, (void**)&_syms, &_symbol_size);

    if (_num_symbols == 0) {

        _num_symbols =

                bfd_read_minisymbols(_abfd, TRUE /* dynamic */, (void**)&_syms, &_symbol_size);

    }

    if (_num_symbols == 0) {

        LOG(WARNING) << "Load symbols failed because errmsg=" << bfd_errmsg(bfd_get_error());

        return -1;

    }

    return 0;

}

int BfdParser::parse() {

    int ret = open_bfd();

    if (ret != 0) {

        LOG(WARNING) << "open bfd failed.";

        return ret;

    }

    ret = load_symbols();

    if (ret != 0) {

        LOG(WARNING) << "Load symbols failed.";

        return ret;

    }

    return 0;

}

int BfdParser::decode_address(const char* str, const char** end, std::string* file_name,

                              std::string* func_name, unsigned int* lineno) {

    bfd_vma pc = bfd_scan_vma(str, end, 16);

    BfdFindCtx ctx(_syms, pc);

    std::lock_guard<std::mutex> lock(_mutex);

    bfd_map_over_sections(_abfd, find_addr_in_section, (void*)&ctx);

    if (!ctx.found) {

        file_name->append("??");

        func_name->append("??");

        return -1;

    }

    // demangle function

    if (ctx.func_name != nullptr) {

#define DMGL_PARAMS (1 << 0)

#define DMGL_ANSI (1 << 1)

        char* demangled_name = bfd_demangle(_abfd, ctx.func_name, DMGL_ANSI | DMGL_PARAMS);

        if (demangled_name != nullptr) {

            func_name->append(demangled_name);

            free(demangled_name);

        } else {

            func_name->append(ctx.func_name);

        }

    } else {

        func_name->append("??");

    }

    // file_name

    if (ctx.file_name != nullptr) {

        file_name->append(ctx.file_name);

    } else {

        file_name->append("??");

    }

    *lineno = ctx.lineno;

    return 0;

}

} // namespace doris