name string | code string | asm string | file string |
|---|---|---|---|
ncnn::Quantize::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Quantize::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
const int dims = bottom_blob.dims;
const int w = bottom_blob.w;
const int h = bottom_blob.h;
const int channels = bottom_blob.c;
if (dims == 1)
{
top_blob.create(w, (size_t)1u, opt.blob_allocator);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movl 0x28(%rsi), %edx
movl 0x2c(%rsi), %r12d
movl 0x30(%rsi), %r13d
xorl %eax, %eax
cmpl $0x3, %edx
movq %rbx, 0x20(%rsp)
je 0x343c6a
cmpl $0x2, %edx
je 0x343b72
cmpl $0x1, %edx
jne 0... | /Tencent[P]ncnn/src/layer/quantize.cpp |
ncnn::Quantize_x86::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Quantize_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
const int dims = bottom_blob.dims;
const int w = bottom_blob.w;
const int h = bottom_blob.h;
const int channels = bottom_blob.c;
const int elempack = bottom_blob.elempack;
if (dims == 1)
{
in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x20(%rsp)
movl 0x18(%rsi), %ecx
movl 0x28(%rsi), %eax
movl 0x2c(%rsi), %esi
movl 0x30(%r12), %edx
movq %rdx, 0x10(%rsp)
movl %ecx, 0x8(%rsp)
movslq %ecx, %r14
xorl %edx, %edx
cm... | /Tencent[P]ncnn/src/layer/x86/quantize_x86.cpp |
ncnn::Quantize_x86_avx512::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Quantize_x86_avx512::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
const int dims = bottom_blob.dims;
const int w = bottom_blob.w;
const int h = bottom_blob.h;
const int channels = bottom_blob.c;
const int elempack = bottom_blob.elempack;
if (dims == 1)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbp
movq %rdx, %r15
movq %rdi, 0x20(%rsp)
movl 0x18(%rsi), %ecx
movl 0x28(%rsi), %eax
movl 0x2c(%rsi), %r12d
movq %rsi, 0x10(%rsp)
movl 0x30(%rsi), %edx
movq %rdx, 0x8(%rsp)
movslq %ecx, %rbx
xorl %edx, %edx
cmpl $0x3, %eax
m... | /Tencent[P]ncnn/build_O3/src/layer/x86/quantize_x86_avx512.cpp |
ncnn::Quantize_x86_fma::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Quantize_x86_fma::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
const int dims = bottom_blob.dims;
const int w = bottom_blob.w;
const int h = bottom_blob.h;
const int channels = bottom_blob.c;
const int elempack = bottom_blob.elempack;
if (dims == 1)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
movl 0x18(%rsi), %r12d
movl 0x28(%rsi), %eax
movl 0x2c(%rsi), %esi
movl 0x30(%r14), %ecx
movq %rcx, (%rsp)
movslq %r12d, %rbx
xorl %edx, %edx
cmpl $0x3, %eax
movq %r14... | /Tencent[P]ncnn/build_O3/src/layer/x86/quantize_x86_fma.cpp |
LockSignal_SignalShouldBeLocked() | void LockSignal_SignalShouldBeLocked()
{
TestRunner::StartTest(MethodName);
lsignal::signal<void()> sg;
sg.set_lock(true);
AssertHelper::VerifyValue(sg.is_locked(), true, "Signal should be locked.");
} | pushq %r14
pushq %rbx
pushq %rax
leaq 0x98d9(%rip), %rdi # 0x14478
callq 0xa4bc
movl $0x58, %edi
callq 0xa1c0
movq %rax, %rbx
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%rbx)
leaq 0xfd9a(%rip), %rax # 0x1a960
movq %rax, (%rbx)
leaq 0x40(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x40... | /balmerdx[P]lsignal/tests/test_basic.cpp |
CallSignalWithoutConnections_SignalShouldBeCalled() | void CallSignalWithoutConnections_SignalShouldBeCalled()
{
TestRunner::StartTest(MethodName);
lsignal::signal<void(int, bool)> sg;
int paramOne = 7;
bool paramTwo = true;
sg(paramOne, paramTwo);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x9809(%rip), %rdi # 0x144d5
callq 0xa4bc
xorl %r14d, %r14d
leaq 0x8(%rsp), %rbx
movq %r14, (%rbx)
movl $0x58, %edi
callq 0xa1c0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0xfcb5(%rip), %rcx # 0x1a9b0
movq %rcx, (%rax)
leaq 0x10(%r... | /balmerdx[P]lsignal/tests/test_basic.cpp |
CallSignalWithSingleConnection_SignalShouldBeCalled() | void CallSignalWithSingleConnection_SignalShouldBeCalled()
{
TestRunner::StartTest(MethodName);
lsignal::signal<void(int, bool)> sg;
int paramOne = 7;
bool paramTwo = true;
bool receiverCalled = false;
std::function<void(int, bool)> receiver = [=, &receiverCalled](int p0, bool p1)
{
receiverCalled = true;
... | pushq %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x978a(%rip), %rdi # 0x14507
callq 0xa4bc
xorl %r14d, %r14d
leaq 0x10(%rsp), %rbx
movq %r14, (%rbx)
movl $0x58, %edi
callq 0xa1c0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0xfc04(%rip), %rcx # 0x1a9b0
movq %rcx, (%rax)
leaq 0x10(%... | /balmerdx[P]lsignal/tests/test_basic.cpp |
TestSignalDestroyListener() | void TestSignalDestroyListener()
{
TestRunner::StartTest(MethodName);
std::vector<TestB*> listeners;
TestA ta;
const size_t count = 1000;
for (size_t i = 0; i < count; i++)
{
TestB* pb = new TestB();
listeners.push_back(pb);
ta.sigA.connect(pb, &TestB::ReceiveSigA, pb);
}
receiveSigACount = 0;
ta.sigA(2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0x905d(%rip), %rdi # 0x146d1
callq 0xa4bc
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x136ac
leaq 0xf1a6(%rip), %rax # 0x1a840
movq %rax, 0x20(%rsp)
movq $0x0, 0x40(%rsp)
movl... | /balmerdx[P]lsignal/tests/test_basic.cpp |
TestDisconnectConnection() | void TestDisconnectConnection()
{
TestRunner::StartTest(MethodName);
std::vector<TestB*> listeners;
TestA ta;
const size_t count = 1000;
for (size_t i = 0; i < count; i++)
{
TestB* pb = new TestB();
listeners.push_back(pb);
pb->explicitConnectionA = ta.sigA.connect(pb, &TestB::ReceiveSigA, pb);
}
receive... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0x8d2b(%rip), %rdi # 0x14728
callq 0xa4bc
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x136ac
leaq 0xee1d(%rip), %rax # 0x1a840
movq %rax, 0x20(%rsp)
movq $0x0, 0x40(%rsp)
movl... | /balmerdx[P]lsignal/tests/test_basic.cpp |
TestSignalCopy() | void TestSignalCopy()
{
TestRunner::StartTest(MethodName);
lsignal::signal<void(int, bool)> sg;
int paramOne = 7;
bool paramTwo = true;
bool receiverCalled = false;
std::function<void(int, bool)> receiver = [=, &receiverCalled](int p0, bool p1)
{
receiverCalled = true;
AssertHelper::VerifyValue(paramOne... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x8566(%rip), %rdi # 0x14768
callq 0xa4bc
xorl %r12d, %r12d
leaq 0x20(%rsp), %rbx
movq %r12, (%rbx)
movl $0x58, %edi
callq 0xa1c0
movabsq $0x100000001, %r14 # imm = 0x100000001
movq %r14, 0x8(%rax)
leaq 0xe77f(%rip), %r15 # 0x1a9b0
movq %r... | /balmerdx[P]lsignal/tests/test_basic.cpp |
lsignal::signal<void (int)>::delete_deffered_internal(lsignal::signal<void (int)>::internal_data*) const | void signal<R(Args...)>::delete_deffered_internal(internal_data* data) const
{
auto it_to_remove = std::remove_if(data->_callbacks.begin(), data->_callbacks.end(),
[](const joint& jnt) { return jnt.connection->deleted; }
);
data->_callbacks.erase(it_to_remove, data->_callbacks.end());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x30(%rsi), %rdi
addq $0x30, %rbx
movq %rbx, %rsi
callq 0x11ab8
cmpq %rbx, %rax
je 0x11ab0
movq %rax, %rsi
movq (%rsi), %r14
movq %rbx, %rdi
callq 0x11b2e
movq %r14, %rsi
cmpq %rbx, %r14
jne 0x11a9d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /balmerdx[P]lsignal/tests/../lsignal.h |
lsignal::slot::disconnect() | void slot::disconnect()
{
decltype(_cleaners) cleaners = _cleaners;
for (auto iter = cleaners.cbegin(); iter != cleaners.cend(); ++iter)
{
const connection_cleaner& cleaner = *iter;
cleaner.data->deleted = true;
}
_cleaners.clear();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x8, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1379c
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x13723
movq (%rax), %rdx
movb $0x1, 0x1(%rdx)
addq $0x10, %rax
jmp 0x13711
movq %rbx, %rdi
callq 0x1383a
movq %rsp, %rdi
callq 0... | /balmerdx[P]lsignal/lsignal.cpp |
common_chat_params_init_firefunction_v2(minja::chat_template const&, templates_params const&) | static common_chat_params common_chat_params_init_firefunction_v2(const common_chat_template & tmpl, const struct templates_params & inputs) {
LOG_DBG("%s\n", __func__);
common_chat_params data;
data.prompt = apply(tmpl, inputs.messages, /* tools= */ nullptr, inputs.add_generation_prompt, {
{"dateti... | subq $0x3c8, %rsp # imm = 0x3C8
movq %rdi, 0x170(%rsp)
movq %rdi, %rax
movq %rax, 0x178(%rsp)
movq %rdi, 0x3c0(%rsp)
movq %rsi, 0x3b8(%rsp)
movq %rdx, 0x3b0(%rsp)
movl $0x1, %eax
leaq 0x1ec8ca(%rip), %rcx # 0x275688
cmpl (%rcx), %eax
jg 0x88de4
callq 0x1df610
movq %rax, %rdi
movl $0x1, %esi
leaq 0x1639c6(... | /ggerganov[P]llama/common/chat.cpp |
common_chat_params_init_without_tools(minja::chat_template const&, templates_params const&) | static common_chat_params common_chat_params_init_without_tools(const common_chat_template & tmpl, const struct templates_params & inputs) {
common_chat_params data;
data.prompt = apply(tmpl, inputs.messages, inputs.tools.empty() ? json() : inputs.tools, inputs.add_generation_prompt);
data.format = COMMON_C... | subq $0xc8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movb $0x0, 0xaf(%rsp)
callq 0xbaa80
movq 0xb8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xb0(%rsp), %rdi
addq $0x10, %rdi
callq 0xbaaf0
... | /ggerganov[P]llama/common/chat.cpp |
common_chat_params_init_mistral_nemo(minja::chat_template const&, templates_params const&) | static common_chat_params common_chat_params_init_mistral_nemo(const common_chat_template & tmpl, const struct templates_params & inputs) {
common_chat_params data;
data.grammar_lazy = inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_REQUIRED;
data.grammar = build_grammar([&](const common_grammar_builder & bui... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0xa0(%rsp)
movq %rdi, %rax
movq %rax, 0x98(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
movb $0x0, 0x1cf(%rsp)
callq 0xbaa80
movq 0xa0(%rsp), %rdi
movq 0x1d0(%rsp), %rax
movl 0x20(%rax), %eax
subl $0x1, %eax
setne 0x48(%rdi)
movq 0x1d0(... | /ggerganov[P]llama/common/chat.cpp |
foreach_function(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::all... | static void foreach_function(const json & tools, const std::function<void(const json &)> & fn) {
for (const auto & tool : tools) {
if (!tool.contains("type") || tool.at("type") != "function" || !tool.contains("function")) {
LOG_INF("Skipping tool without function: %s", tool.dump(2).c_str());
... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xb6b20
movq 0x90(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0xb6b50
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xb6b80
testb $0x1, %al
jne 0x8c023
jmp 0x8c141
l... | /ggerganov[P]llama/common/chat.cpp |
minja::simple_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::function<... | static Value simple_function(const std::string & fn_name, const std::vector<std::string> & params, const std::function<Value(const std::shared_ptr<Context> &, Value & args)> & fn) {
std::map<std::string, size_t> named_positions;
for (size_t i = 0, n = params.size(); i < n; i++) named_positions[params[i]] = i;
re... | subq $0x158, %rsp # imm = 0x158
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
movq %rcx, 0x138(%rsp)
leaq 0x108(%rsp), %rdi
callq 0xf58f0
movq $0x0, 0x100(%rsp)
movq 0x140(%rsp), %rdi
callq 0xbbac0
movq %rax, 0xf8(%rsp)
movq 0... | /ggerganov[P]llama/common/minja/minja.hpp |
parse_json_tool_calls(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::optional<std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>>> const&, std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, std::__cxx11::basic_regex<char, std::__cxx11::re... | static common_chat_msg parse_json_tool_calls(
const std::string& input,
const std::optional<std::regex> & trigger_opt,
const std::regex & function_regex,
const std::regex & close_regex,
bool allow_raw_python = false) {
std::smatch match;
common_chat_msg result;
result.role = "assistant"... | subq $0x548, %rsp # imm = 0x548
movq %rdi, 0x158(%rsp)
movb %r9b, %al
movq %rdi, %r9
movq %r9, 0x150(%rsp)
movq %rdi, 0x540(%rsp)
movq %rsi, 0x538(%rsp)
movq %rdx, 0x530(%rsp)
movq %rcx, 0x528(%rsp)
movq %r8, 0x520(%rsp)
andb $0x1, %al
movb %al, 0x51f(%rsp)
leaq 0x4f8(%rsp), %rdi
callq 0x117730
movq 0x158(%r... | /ggerganov[P]llama/common/chat.cpp |
nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, st... | bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0)
{
if (prefix == 0)
{
prefix = get_ignore_noop();
}
switch (prefix)
{
case 'U':
{
std::uint8_t number{};
if (JSON_HE... | subq $0x988, %rsp # imm = 0x988
movq %rdi, 0x978(%rsp)
movq %rsi, 0x970(%rsp)
movq %rdx, 0x968(%rsp)
movl %ecx, 0x964(%rsp)
movq 0x978(%rsp), %rax
movq %rax, 0x218(%rsp)
cmpl $0x0, 0x964(%rsp)
jne 0xb0b94
movq 0x218(%rsp), %rdi
callq 0xa94f0
movl %eax, 0x964(%rsp)
movl 0x964(%rsp), %eax
addl $-0x49, %eax
mov... | /ggerganov[P]llama/common/json.hpp |
bool nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serialize... | bool get_string(const input_format_t format,
const NumberType len,
string_t& result)
{
bool success = true;
for (NumberType i = 0; i < len; i++)
{
get();
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
{
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movb $0x1, 0x17(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jge 0xb39de
movq (%rsp), %rdi
callq 0xa9530
movq (%rsp), %rdi
movl 0x2c(%rsp), %esi
leaq ... | /ggerganov[P]llama/common/json.hpp |
handle_think_tag_prelude(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, std::function<common_chat_msg (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)> const&) | static common_chat_msg handle_think_tag_prelude(const std::string & input, bool extract_reasoning, const std::function<common_chat_msg(const std::string &)> & rest_parser) {
std::smatch match;
static const std::regex reasoning_content_regex("((?:<think>)?([\\s\\S\\r\\n]*?)</think>)?([\\s\\S\\r\\n]*)");
if (... | subq $0x298, %rsp # imm = 0x298
movq %rdi, 0x30(%rsp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, 0x38(%rsp)
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
andb $0x1, %al
movb %al, 0x287(%rsp)
movq %rcx, 0x278(%rsp)
leaq 0x258(%rsp), %rdi
callq 0x117730
cmpb $0x0, 0x1c1225(%rip) # 0x274dd0
jne 0xb3bfe
leaq 0x... | /ggerganov[P]llama/common/chat.cpp |
parse_literal(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, std::__cxx11::basic_string<char, std::char_traits<ch... | static bool parse_literal(std::string::const_iterator & it, const std::string::const_iterator & end, const std::string & expected) {
auto expected_it = expected.begin();
auto tmp_it = it;
while (tmp_it != end && expected_it != expected.end() && *tmp_it == *expected_it) {
++tmp_it;
++expected... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x60320
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xdb580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7... | /ggerganov[P]llama/common/chat.cpp |
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::v... | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
jne 0xb777a
leaq 0x13a5a0(%rip), %rdi # 0x1f1d00
movl $0x33c0, %esi # imm = 0x33C0
leaq 0x139cbc(%rip), %rdx # 0x1f1428
leaq 0x13bca6(%rip), %rcx # 0x1f3419
movb $0x0, %al
callq 0x60c20
movq 0x8(%rsp),... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | const_reference at(KeyType && key) const
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xb6f10
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb7898
jmp 0xb7974
movb $0x1, 0x83(%rsp)
movl $0x20, %edi
callq 0x605a0
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0xca160
mo... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | const_reference at(KeyType && key) const
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xb6f10
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb7bf8
jmp 0xb7cd4
movb $0x1, 0x83(%rsp)
movl $0x20, %edi
callq 0x605a0
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0xca160
mo... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json parse(InputType&& i,
const parser_callback_t cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false)
{
basic_json result;
parser(deta... | subq $0x158, %rsp # imm = 0x158
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x18(%rsp)
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
andb $0x1, %cl
movb %cl, 0x13f(%rsp)
andb $0x1, %al
movb %al, 0x13e(%rsp)
movb $0x0, 0x13d(%rsp)
xorl %eax, %eax
m... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | const_reference at(KeyType && key) const
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xb6f10
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb9b48
jmp 0xb9c24
movb $0x1, 0x83(%rsp)
movl $0x20, %edi
callq 0x605a0
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0xca160
mo... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | bool empty() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
{
// null values are empty
return true;
}
case value_t::array:
{
// delegate call to array_t::empty()
... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl (%rax), %eax
movq %rax, 0x10(%rsp)
subq $0x9, %rax
ja 0xbab5b
movq 0x10(%rsp), %rax
leaq 0x134a43(%rip), %rcx # 0x1ef560
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, 0x27(%rsp)
jmp 0xbab60
movq 0x8(%rsp), %ra... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | const_reference operator[](const typename object_t::key_type& key) const
{
// const operator[] only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
auto it = m_data.m_value.object->find(key);
JSON_ASSERT(it != m_data.m_value.object->end());
return... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xb6f10
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc9ca7
jmp 0xc9d20
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x58(%rsp), %rsi
callq 0xc9de0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, ... | iterator find(const key_type& key)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it;
}
}
return Container::end();
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xca220
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
callq 0xc9ec0
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xc9e80
testb $0x1, %al
jne 0xc9e26
jmp 0xc9e66
movq 0x10(%rsp), %rax
a... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | JSON_HEDLEY_RETURNS_NON_NULL
const char* type_name() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
return "null";
case value_t::object:
return "object";
case value_t::array:
return "array";
... | movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
movq %rax, -0x18(%rsp)
subq $0x9, %rax
ja 0xca1f1
movq -0x18(%rsp), %rax
leaq 0x1254a4(%rip), %rcx # 0x1ef628
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x12c3b1(%rip), %rax # 0x1f6545
movq %rax, -0x8(%rsp)
jmp 0xca1fd
leaq 0x12ca00... | /ggerganov[P]llama/common/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::exception::diagnostics<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, lon... | static std::string diagnostics(const BasicJsonType* leaf_element)
{
#if JSON_DIAGNOSTICS
std::vector<std::string> tokens;
for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent)
{
switch (current->m_parent->type())... | subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x60dc0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x12780b(%rip), %rsi # 0x1f1c76
callq 0x703a0
jmp 0xca472
leaq 0x37(%rsp), %rdi
callq 0x61... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | void set_parents()
{
#if JSON_DIAGNOSTICS
switch (m_data.m_type)
{
case value_t::array:
{
for (auto& element : *m_data.m_value.array)
{
element.m_parent = this;
}
break;
}
... | movq %rdi, -0x8(%rsp)
retq
nopw %cs:(%rax,%rax)
| /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | reference operator[](size_type idx)
{
// implicitly convert null value to an empty array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value.array = create<array_t>();
assert_invariant();
}
// operator[] only works for arrays
... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xb77f0
testb $0x1, %al
jne 0xce953
jmp 0xce973
movq 0x18(%rsp), %rax
movb $0x2, (%rax)
callq 0xcef00
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rdi)
movl $0x1, %esi
callq 0xcc220
movq 0x18(%rsp), %rdi
callq 0xb68e... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | reference at(size_type idx)
{
// at only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
JSON_TRY
{
return set_parent(m_data.m_value.array->at(idx));
}
JSON_CATCH (std::out_of_range&)
{
// crea... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xb68e0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xceae6
jmp 0xcec6a
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0xb8(%rsp), %rsi
callq 0xcfc90
movq %rax, 0x18(%rsp)
jmp 0xceb03
movq 0x18(%rsp),... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | iterator insert(const_iterator pos, const basic_json& val)
{
// insert only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
// check if iterator pos fits to this JSON value
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
{
JSON_THROW... | subq $0xe8, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq 0xd8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xb68e0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xd1408
jmp 0xd1543
mov... | /ggerganov[P]llama/common/json.hpp |
_gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned lo... | iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it;
}
}
return Container::end();
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xca220
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
callq 0xc9ec0
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xc9e80
testb $0x1, %al
jne 0xd8e96
jmp 0xd8ed6
movq 0x10(%rsp), %rax
a... | /ggerganov[P]llama/common/json.hpp |
minja::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Options const&) | static std::shared_ptr<TemplateNode> parse(const std::string& template_str, const Options & options) {
Parser parser(std::make_shared<std::string>(normalize_newlines(template_str)), options);
auto tokens = parser.tokenize();
TemplateTokenIterator begin = tokens.begin();
auto it = begin;
... | subq $0xf8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0xe8(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x162490
movq 0x28(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x162410
jmp 0x160c3a
movq 0xe0(%rsp), %rdx
le... | /ggerganov[P]llama/common/minja/minja.hpp |
Tiles::Tiles() | Tiles::Tiles()
{
//Quick Test
int switchCase = rand() % 5;
switch(switchCase)
{
case 0:
data = WATER;
break;
case 1:
data = GRASS;
break;
case 2:
data = PATH;
break;
case 3:
data = MOUNTAIN;
break;
case 4:
data = FOREST;
break;
default: data = EMPTY;
}
//data = WATER;
} | pushq %rbx
movq %rdi, %rbx
callq 0x1030
pushq $0x5
popq %rcx
cltd
idivl %ecx
cmpl $0x5, %edx
cmovbl %edx, %ecx
movl %ecx, (%rbx)
popq %rbx
retq
nop
| /Axelm3sh[P]WorldGen/Tiles.cpp |
oonf_class_add | void
oonf_class_add(struct oonf_class *ci) {
/* round up size to make block extendable */
ci->total_size = _roundup(ci->size);
/* hook into tree */
ci->_node.key = ci->name;
avl_insert(&_classes_tree, &ci->_node);
/* add standard key generator if necessary */
if (ci->to_keystring == NULL) {
ci->to_k... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rcx, 0x20(%rdi)
leaq 0x28(%rdi), %rsi
movq %rax, 0x50(%rdi)
leaq 0x48f42(%rip), %rdi # 0x5a6c8
callq 0x279af
cmpq $0x0, 0x18(%rbx)
jne 0x1179d
leaq 0x65(%rip), %rax # 0x117fe
movq %rax, 0x18(%rbx)
leaq 0... | /OLSR[P]OONF/src/base/oonf_class.c |
oonf_class_remove | void
oonf_class_remove(struct oonf_class *ci) {
struct oonf_class_extension *ext, *iterator;
/* remove memcookie from tree */
avl_remove(&_classes_tree, &ci->_node);
/* remove all free memory blocks */
_free_freelist(ci);
/* remove all listeners */
list_for_each_element_safe(&ci->_extensions, ext, _nod... | pushq %rbx
movq %rdi, %rbx
leaq 0x28(%rdi), %rsi
leaq 0x48e99(%rip), %rdi # 0x5a6c8
callq 0x27bcf
movq %rbx, %rdi
callq 0x118bf
movq 0x70(%rbx), %rax
movq 0x8(%rax), %rcx
cmpq 0x78(%rbx), %rcx
je 0x1187d
xorps %xmm0, %xmm0
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
je 0x11873
movq 0x8(%rcx), %rdx
testq %rdx... | /OLSR[P]OONF/src/base/oonf_class.c |
free_freelist | static void
_free_freelist(struct oonf_class *ci) {
while (!list_is_empty(&ci->_free_list)) {
struct list_entity *item;
item = ci->_free_list.next;
list_remove(item);
free(item);
}
ci->_free_list_size = 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
movq (%r14), %rdi
cmpq %r14, %rdi
jne 0x118d8
cmpq %r14, 0x68(%rbx)
je 0x118f3
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
callq 0x11060
jmp 0x118ca
movl $0x0, 0x80(%rbx)
addq... | /OLSR[P]OONF/src/base/oonf_class.c |
oonf_class_event | void
oonf_class_event(struct oonf_class *c, void *ptr, enum oonf_class_event evt) {
struct oonf_class_extension *ext;
#ifdef OONF_LOG_DEBUG_INFO
struct oonf_objectkey_str buf;
#endif
OONF_DEBUG(LOG_CLASS, "Fire '%s' event for %s", OONF_CLASS_EVENT_NAME[evt], c->to_keystring(&buf, c, ptr));
list_for_each_elemen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0x3e6c1(%rip), %r12d # 0x5038c
leaq 0x5bbfe(%rip), %r13 # 0x6d8d0
testb $0x1, (%r13,%r12)
je 0x11d2e
movl %ebx, %eax
leaq 0x3df1d(%rip), %rcx # 0x4fc00
movq (%rcx,%rax,8), %... | /OLSR[P]OONF/src/base/oonf_class.c |
oonf_clock_toClockString | const char *
oonf_clock_toClockString(struct isonumber_str *buf, uint64_t clk) {
uint64_t msec = clk % MSEC_PER_SEC;
uint64_t sec = clk / MSEC_PER_SEC;
snprintf(buf->buf, sizeof(*buf), "%" PRIu64 ":%02" PRIu64 ":%02" PRIu64 ".%03" PRIu64 "", sec / 3600,
(sec % 3600) / 60, (sec % 60), msec);
return buf->bu... | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
mulq %rcx
movq %rdx, %r9
movq %rdi, %rbx
shrq $0x4, %r9
imulq $0x3e8, %r9, %rax # imm = 0x3E8
movq %rsi, %rdi
subq %rax, %rdi
movabsq $0x4a90be587de6e565, %rcx # imm = 0x4A90BE587DE6E565
movq %... | /OLSR[P]OONF/src/base/oonf_clock.c |
oonf_layer2_origin_remove | void
oonf_layer2_origin_remove(struct oonf_layer2_origin *origin) {
struct oonf_layer2_net *l2net, *l2net_it;
if (!avl_is_node_added(&origin->_node)) {
return;
}
avl_for_each_element_safe(&_oonf_layer2_net_tree, l2net, _node, l2net_it) {
oonf_layer2_net_remove(l2net, origin);
}
avl_remove(&_oonf_... | pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x18(%rdi)
je 0x12135
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x12135
leaq 0x18(%rbx), %r14
movq 0x48623(%rip), %rdi # 0x5a730
movq 0x8(%rdi), %rax
cmpq 0x48620(%rip), %rax # 0x5a738
je 0x1213b
movq (%rdi), %r15
addq $-0x7a0, %rdi # imm = 0xF860
movq %rbx, ... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_data_parse_string | int
oonf_layer2_data_parse_string(
union oonf_layer2_value *value, const struct oonf_layer2_metadata *meta, const char *input) {
memset(value, 0, sizeof(*value));
switch (meta->type) {
case OONF_LAYER2_INTEGER_DATA:
return isonumber_to_s64(&value->integer, input, meta->scaling);
case OONF_LAYER2_B... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl 0x10(%rsi), %eax
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $0x1, %eax
je 0x12264
testl %eax, %eax
jne 0x122a5
movq 0x20(%rsi), %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
pop... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_data_set | bool
oonf_layer2_data_set(struct oonf_layer2_data *l2data, const struct oonf_layer2_origin *origin,
const struct oonf_layer2_metadata *meta, const union oonf_layer2_value *input) {
bool changed = false;
if (meta == NULL) {
OONF_ASSERT(l2data->_meta != NULL, LOG_LAYER2, "Tried to set layer2 data without metad... | movq %rsi, %r10
testq %rdx, %rdx
jne 0x12341
movq 0x18(%rdi), %rdx
testq %rdx, %rdx
jne 0x12341
movl 0x3e1b0(%rip), %esi # 0x504e4
leaq 0x5b595(%rip), %rax # 0x6d8d0
testb $0x8, (%rax,%rsi)
jne 0x123b5
movq 0x18(%rdi), %rsi
testq %rsi, %rsi
je 0x1236a
movq 0x20(%rdi), %rax
testq %rax, %rax
sete %r8b
cmpq %r10, ... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_data_compare | bool
oonf_layer2_data_compare(const union oonf_layer2_value *left, const union oonf_layer2_value *right,
enum oonf_layer2_data_comparator_type comparator, enum oonf_layer2_data_type data_type) {
int result;
switch (data_type) {
case OONF_LAYER2_INTEGER_DATA:
if (left->integer > right->integer) {
... | pushq %rbx
movl %edx, %ebx
cmpl $0x2, %ecx
je 0x124d5
cmpl $0x1, %ecx
je 0x124cb
testl %ecx, %ecx
jne 0x124fd
movq (%rsi), %rcx
movl $0x1, %eax
cmpq %rcx, (%rdi)
jg 0x124df
setl %al
movzbl %al, %eax
negl %eax
jmp 0x124df
movzbl (%rdi), %eax
movzbl (%rsi), %ecx
subl %ecx, %eax
jmp 0x124df
movl $0x12, %edx
callq 0x11300
... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_net_cleanup | bool
oonf_layer2_net_cleanup(struct oonf_layer2_net *l2net, const struct oonf_layer2_origin *origin, bool cleanup_neigh) {
struct oonf_layer2_neigh *l2neigh;
bool changed = false;
int i;
for (i = 0; i < OONF_LAYER2_NET_COUNT; i++) {
if (l2net->data[i]._origin == origin) {
oonf_layer2_data_reset(&l2ne... | movl $0x130, %ecx # imm = 0x130
xorl %eax, %eax
xorps %xmm0, %xmm0
cmpq %rsi, (%rdi,%rcx)
jne 0x126fb
movups %xmm0, -0x8(%rdi,%rcx)
movb $0x1, %al
addq $0x28, %rcx
cmpq $0x3b0, %rcx # imm = 0x3B0
jne 0x126ee
movl $0x3b0, %ecx # imm = 0x3B0
xorps %xmm0, %xmm0
cmpq %rsi, (%rdi,%rcx)
jne 0... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_neigh_remove | static INLINE bool
list_is_node_added(const struct list_entity *node) {
return node->next != NULL && node->prev != NULL;
} | cmpq $0x0, 0x4c0(%rdi)
je 0x127f7
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x4c8(%rdi)
je 0x127fe
movq %rsi, %r14
movq 0x58(%rbx), %rdi
movq 0x8(%rdi), %rax
cmpq 0x60(%rbx), %rax
je 0x12802
xorl %ebp, %ebp
movq (%rdi), %r15
cmpq %r14, -0x8(%rdi)
jne 0x127e8
addq $-0x28, %rdi
cal... | /OLSR[P]OONF/include/oonf/libcommon/list.h |
oonf_layer2_neigh_relabel | void
oonf_layer2_neigh_relabel(struct oonf_layer2_neigh *l2neigh, const struct oonf_layer2_origin *new_origin,
const struct oonf_layer2_origin *old_origin) {
struct oonf_layer2_neighbor_address *neigh_ip;
struct oonf_layer2_destination *l2dst;
size_t i;
for (i = 0; i < OONF_LAYER2_NEIGH_COUNT; i++) {
if ... | movl $0xd0, %eax
cmpq %rdx, (%rdi,%rax)
jne 0x12a46
movq %rsi, (%rdi,%rax)
addq $0x28, %rax
cmpq $0x4e0, %rax # imm = 0x4E0
jne 0x12a3c
movq 0x80(%rdi), %rax
movq 0x8(%rax), %rcx
cmpq 0x88(%rdi), %rcx
je 0x12a75
cmpq %rdx, -0x40(%rax)
jne 0x12a70
movq %rsi, -0x40(%rax)
movq (%rax), %rax
jmp 0x12a59
movq 0x58... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_net_remove_ip | int
oonf_layer2_net_remove_ip(struct oonf_layer2_peer_address *ip, const struct oonf_layer2_origin *origin) {
if (ip->origin != origin) {
return -1;
}
oonf_class_event(&_l2net_addr_class, ip, OONF_OBJECT_REMOVED);
avl_remove(&ip->l2net->local_peer_ips, &ip->_net_node);
avl_remove(&_local_peer_ips_tree, ... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rsi, 0x20(%rdi)
je 0x12b52
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3da68(%rip), %r14 # 0x505c8
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x11cab
movl $0xb8, %edi
addq 0x18(%rbx), %rdi
leaq 0x60(%rbx), %rsi
callq 0x27bcf
leaq 0x28... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_neigh_generate_lid | int
oonf_layer2_neigh_generate_lid(struct oonf_layer2_neigh_key *key,
struct oonf_layer2_origin *origin, const struct netaddr *mac) {
struct oonf_layer2_lid *lid;
uint32_t u32;
if (!origin->lid) {
return -1;
}
if (netaddr_get_address_family(mac) != AF_MAC48 && netaddr_get_address_family(mac) != AF_E... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpb $0x1, 0x10(%rsi)
jne 0x12d36
movq %rdx, %r15
movb 0x10(%rdx), %al
addb $-0x2f, %al
cmpb $0x1, %al
ja 0x12d36
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x47ae5(%rip), %rdi # 0x5a780
movq %r15, %rsi
callq 0x2780e
le... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_destination_remove | void
oonf_layer2_destination_remove(struct oonf_layer2_destination *l2dst) {
if (!avl_is_node_added(&l2dst->_node)) {
return;
}
oonf_class_event(&_l2dst_class, l2dst, OONF_OBJECT_REMOVED);
avl_remove(&l2dst->neighbor->destinations, &l2dst->_node);
oonf_class_free(&_l2dst_class, l2dst);
} | pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x28(%rdi)
je 0x12e8b
movq %rdi, %rbx
cmpq $0x0, 0x30(%rdi)
je 0x12e8b
leaq 0x28(%rbx), %r14
leaq 0x3d9ad(%rip), %r15 # 0x50808
movq %r15, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x11cab
movq 0x18(%rbx), %rdi
addq $0x58, %rdi
movq %r14, %rsi
callq 0x27bcf
movq %r15, %r... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_neigh_add_ip | struct oonf_layer2_neighbor_address *
oonf_layer2_neigh_add_ip(
struct oonf_layer2_neigh *l2neigh, const struct oonf_layer2_origin *origin, const struct netaddr *ip) {
struct oonf_layer2_neighbor_address *l2addr;
l2addr = oonf_layer2_neigh_get_remote_ip(l2neigh, ip);
if (l2addr) {
l2addr->origin = origin;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x80(%rdi), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x2780e
testq %rax, %rax
je 0x1309a
movq %rax, %r14
addq $-0x60, %r14
movq %rbx, -0x40(%rax)
jmp 0x1310e
leaq 0x3d6d7(%rip), %rdi # 0x50778
callq 0x11933... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_neigh_query | struct oonf_layer2_data *
oonf_layer2_neigh_query(const char *ifname, const struct netaddr *l2neigh_addr,
enum oonf_layer2_neighbor_index idx, bool get_default) {
struct oonf_layer2_net *l2net;
struct oonf_layer2_neigh *l2neigh;
struct oonf_layer2_data *data;
/* query layer2 database about neighbor */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x47567(%rip), %rdi # 0x5a730
callq 0x2780e
leaq -0x7a0(%rax), %r15
testq %rax, %rax
cmoveq %rax, %r15
je 0x13279
xorps %xmm0, %xmm0
movq %rsp, %rsi
movups %xmm0, 0x12(%rsi)
movb $0x0, 0... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_layer2_neigh_key_from_string | int
oonf_layer2_neigh_key_from_string(struct oonf_layer2_neigh_key *key, const char *string) {
struct netaddr_str nbuf;
const char *split, *addr;
ssize_t len;
memset(key, 0, sizeof(*key));
split = strchr(string, ',');
if (!split) {
addr = string;
}
else {
len = split - string;
if (len > (s... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x0, 0x1f(%rdi)
movq %rsi, %rdi
movl $0x2c, %esi
callq 0x111d0
testq %rax, %rax
je 0x13437
movq %rax, %r12
movq %rax, %rdx
subq %r15, %rdx
movl $0xffffffff,... | /OLSR[P]OONF/src/base/oonf_layer2.c |
init | static int
_init(void) {
oonf_class_add(&_l2network_class);
oonf_class_add(&_l2neighbor_class);
oonf_class_add(&_l2dst_class);
oonf_class_add(&_l2net_addr_class);
oonf_class_add(&_l2neigh_addr_class);
oonf_class_add(&_lid_class);
avl_init(&_oonf_layer2_net_tree, avl_comp_strcasecmp, false);
avl_init(&_... | pushq %rbx
leaq 0x3cfcd(%rip), %rdi # 0x50538
callq 0x11760
leaq 0x3d171(%rip), %rdi # 0x506e8
callq 0x11760
leaq 0x3d285(%rip), %rdi # 0x50808
callq 0x11760
leaq 0x3d039(%rip), %rdi # 0x505c8
callq 0x11760
leaq 0x3d1dd(%rip), %rdi # 0x50778
callq 0x11760
leaq 0x3d0b1(%rip), %rdi # 0x50658
callq... | /OLSR[P]OONF/src/base/oonf_layer2.c |
oonf_packet_remove | void
oonf_packet_remove(struct oonf_packet_socket *pktsocket, bool force __attribute__((unused))) {
// TODO: implement non-force behavior for UDP sockets
if (list_is_node_added(&pktsocket->node)) {
oonf_socket_remove(&pktsocket->scheduler_entry);
os_fd_close(&pktsocket->scheduler_entry.fd);
abuf_free(&p... | pushq %rbx
cmpq $0x0, (%rdi)
je 0x138c4
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x138c4
leaq 0x10(%rbx), %rdi
callq 0x14c60
movl 0x18(%rbx), %edi
cmpl $-0x1, %edi
je 0x138a4
callq 0x11290
movl $0xffffffff, 0x18(%rbx) # imm = 0xFFFFFFFF
leaq 0xd8(%rbx), %rdi
callq 0x27214
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax... | /OLSR[P]OONF/src/base/oonf_packet_socket.c |
oonf_packet_add_managed | void
oonf_packet_add_managed(struct oonf_packet_managed *managed) {
if (managed->config.input_buffer_length == 0) {
managed->config.input_buffer = _input_buffer;
managed->config.input_buffer_length = sizeof(_input_buffer);
}
managed->_if_listener.if_changed = _cb_interface_listener;
managed->_if_listen... | cmpq $0x0, 0x608(%rdi)
jne 0x13c8f
leaq 0x46b33(%rip), %rax # 0x5a7b0
movq %rax, 0x600(%rdi)
movq $0x10000, 0x608(%rdi) # imm = 0x10000
leaq 0x22(%rip), %rax # 0x13cb8
movq %rax, 0x6e0(%rdi)
leaq 0x658(%rdi), %rax
movq %rax, 0x6d0(%rdi)
movb 0x6c8(%rdi), %al
movb %al, 0x6d8(%rdi)
retq
| /OLSR[P]OONF/src/base/oonf_packet_socket.c |
oonf_packet_remove_managed | void
oonf_packet_remove_managed(struct oonf_packet_managed *managed, bool forced) {
oonf_packet_remove(&managed->socket_v4, forced);
oonf_packet_remove(&managed->socket_v6, forced);
oonf_packet_remove(&managed->multicast_v4, forced);
oonf_packet_remove(&managed->multicast_v6, forced);
os_interface_remove(&ma... | pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x13876
leaq 0x300(%rbx), %rdi
xorl %esi, %esi
callq 0x13876
leaq 0x180(%rbx), %rdi
xorl %esi, %esi
callq 0x13876
leaq 0x480(%rbx), %rdi
xorl %esi, %esi
callq 0x13876
leaq 0x6d0(%rbx), %rdi
callq 0x1950e
leaq 0x630(%rbx), %rdi
callq 0x29957
addq $0x668, %rbx #... | /OLSR[P]OONF/src/base/oonf_packet_socket.c |
apply_managed_socket | static int
_apply_managed_socket(struct oonf_packet_managed *managed, struct oonf_packet_socket *packet,
const struct netaddr *bindto, int port, uint8_t dscp, int protocol, struct os_interface *data) {
union netaddr_socket sock;
struct netaddr_str buf;
/* create binding socket */
if (netaddr_socket_init(&soc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %r9d, 0x4(%rsp)
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %rbp
movq 0x100(%rsp), %r14
testq %r14, %r14
je 0x148ce
movl 0x1c(%r14), %ecx
jmp 0x148d0
xorl %ecx, %ecx
movzwl %r13w, %edx
leaq 0x48(%rsp... | /OLSR[P]OONF/src/base/oonf_packet_socket.c |
oonf_stream_add | int
oonf_stream_add(struct oonf_stream_socket *stream_socket, const union netaddr_socket *local) {
struct netaddr_str buf;
/* server socket not necessary for outgoing connections */
if (netaddr_socket_get_port(local) != 0) {
/* Init socket */
if (os_fd_getsocket(&stream_socket->scheduler_entry.fd, local,... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x28e2d
testw %ax, %ax
je 0x1521e
leaq 0xa0(%r14), %rbx
leaq 0xa8(%r14), %r15
movl 0x3b926(%rip), %r9d # 0x50a94
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r... | /OLSR[P]OONF/src/base/oonf_stream_socket.c |
oonf_stream_remove | void
oonf_stream_remove(struct oonf_stream_socket *stream_socket, bool force) {
if (stream_socket->busy && !force) {
stream_socket->remove = true;
return;
}
if (!list_is_node_added(&stream_socket->_node)) {
return;
}
oonf_stream_close_all_sessions(stream_socket);
list_remove(&stream_socket->_n... | pushq %rbx
movq %rdi, %rbx
movb 0x198(%rdi), %al
xorb $0x1, %al
orb %sil, %al
je 0x1552f
cmpq $0x0, (%rbx)
je 0x15536
cmpq $0x0, 0x8(%rbx)
je 0x15536
movq %rbx, %rdi
callq 0x15538
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
leaq 0xa0(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
... | /OLSR[P]OONF/src/base/oonf_stream_socket.c |
stream_close | static void
_stream_close(struct oonf_stream_session *session) {
if (session->stream_socket->config.cleanup_session) {
session->stream_socket->config.cleanup_session(session);
}
oonf_timer_stop(&session->timeout);
session->stream_socket->session_counter--;
list_remove(&session->node);
oonf_socket_rem... | pushq %rbx
movq %rdi, %rbx
movq 0x170(%rdi), %rax
movq 0x118(%rax), %rax
testq %rax, %rax
je 0x15b97
movq %rbx, %rdi
callq *%rax
leaq 0x1b8(%rbx), %rdi
callq 0x1758b
movq 0x170(%rbx), %rax
decl 0x194(%rax)
movq 0x160(%rbx), %rax
movq 0x168(%rbx), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
leaq 0x178(%rbx), %rdi
xorps ... | /OLSR[P]OONF/src/base/oonf_stream_socket.c |
cb_interface_listener | static int
_cb_interface_listener(struct os_interface_listener *interf) {
struct oonf_stream_managed *managed;
int result;
/* calculate managed socket for this event */
managed = container_of(interf, struct oonf_stream_managed, _if_listener);
result = _apply_managed(managed);
OONF_DEBUG(LOG_STREAM, "Resu... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $-0x408, %rdi # imm = 0xFBF8
callq 0x15e6d
movl %eax, %ebx
movl 0x3adfb(%rip), %esi # 0x50a94
leaq 0x57c30(%rip), %rax # 0x6d8d0
testb $0x1, (%rax,%rsi)
je 0x15cd9
subq $0x8, %rsp
leaq 0x2231c(%rip), %r10 # 0x37fcd
leaq 0x224bd(%rip), %rdx ... | /OLSR[P]OONF/src/base/oonf_stream_socket.c |
cb_telnet_help | static enum oonf_telnet_result
_cb_telnet_help(struct oonf_telnet_data *data) {
struct oonf_telnet_command *cmd;
if (data->parameter != NULL && data->parameter[0] != 0) {
cmd = avl_find_element(&_telnet_cmd_tree, data->parameter, cmd, _node);
if (cmd) {
cmd = _check_telnet_command_acl(data, cmd);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
testq %rsi, %rsi
je 0x17208
cmpb $0x0, (%rsi)
je 0x17208
leaq 0x536cf(%rip), %rdi # 0x6a8b8
callq 0x2780e
testq %rax, %rax
je 0x1727e
addq $-0x28, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17444
jmp 0x17280
movq 0x8(%rbx... | /OLSR[P]OONF/src/base/oonf_telnet.c |
cb_telnet_repeat | static enum oonf_telnet_result
_cb_telnet_repeat(struct oonf_telnet_data *data) {
int interval = 0;
char *ptr = NULL;
if (data->stop_handler) {
abuf_puts(data->out, "Error, you cannot stack continous output commands\n");
return TELNET_RESULT_ACTIVE;
}
if (data->parameter == NULL || (ptr = strchr(dat... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x1731b
movq 0x8(%rbx), %rdi
leaq 0x216bb(%rip), %rsi # 0x389d1
jmp 0x173f9
movq 0x18(%rbx), %r15
testq %r15, %r15
je 0x173ee
movq %r15, %rdi
movl $0x20, %esi
callq 0x111d0
testq %rax, %rax
je 0x173ee
movq %rax, %r14
mov... | /OLSR[P]OONF/src/base/oonf_telnet.c |
oonf_timer_remove | void
oonf_timer_remove(struct oonf_timer_class *info) {
struct oonf_timer_instance *timer, *iterator;
if (!list_is_node_added(&info->_node)) {
/* only free node if its hooked to the timer core */
return;
}
avl_for_each_element_safe(&_timer_tree, timer, _node, iterator) {
if (timer->class == info) ... | pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, (%rdi)
je 0x17583
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x17583
movq 0x533a5(%rip), %rdi # 0x6a8f0
movq 0x8(%rdi), %rax
cmpq 0x533a2(%rip), %rax # 0x6a8f8
je 0x1756f
movq (%rdi), %r14
cmpq %rbx, 0x38(%rdi)
jne 0x17566
callq 0x1758b
movq 0x8(%r14), %rax
movq %r14, %r... | /OLSR[P]OONF/src/base/oonf_timer.c |
avlcomp_timer | static int
_avlcomp_timer(const void *p1, const void *p2) {
const struct oonf_timer_instance *t1, *t2;
t1 = p1;
t2 = p2;
if (t1->_clock > t2->_clock) {
return 1;
}
if (t1->_clock < t2->_clock) {
return -1;
}
return 0;
} | movq 0x58(%rdi), %rax
movq 0x58(%rsi), %rcx
xorl %edx, %edx
cmpq %rcx, %rax
sbbl %edx, %edx
cmpq %rcx, %rax
movl $0x1, %eax
cmovbel %edx, %eax
retq
nop
| /OLSR[P]OONF/src/base/oonf_timer.c |
os_clock_linux_gettime64_ns | int
os_clock_linux_gettime64_ns(uint64_t *t64) {
int error;
#if defined(CLOCK_MONOTONIC_RAW) || defined(CLOCK_MONOTONIC)
if (_clock_source) {
struct timespec ts;
if ((error = clock_gettime(_clock_source, &ts)) != 0) {
return error;
}
*t64 = 1000000000ull * ts.tv_sec + ts.tv_nsec;
return... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x5294a(%rip), %edi # 0x6a918
testl %edi, %edi
je 0x17ff2
movq %rsp, %rsi
callq 0x11150
testl %eax, %eax
jne 0x17ff7
imulq $0x3b9aca00, (%rsp), %rax # imm = 0x3B9ACA00
addq 0x8(%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x17ff7
movl $0xffffffff, %eax # i... | /OLSR[P]OONF/src/base/os_linux/os_clock_linux.c |
os_fd_generic_join_mcast_send | int
os_fd_generic_join_mcast_send(struct os_fd *sock, const struct netaddr *multicast, const struct os_interface *os_if,
bool loop, uint8_t ttl, enum oonf_log_source log_src __attribute__((unused))) {
struct netaddr_str buf1, buf2;
unsigned i;
if (netaddr_get_address_family(multicast) == AF_INET) {
OONF_DE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r8d, 0x14(%rsp)
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %rbp
cmpb $0x2, 0x10(%rsi)
movq %rdi, %r15
movl %r9d, 0xc(%rsp)
movl %r9d, %r12d
leaq 0x54e9b(%rip), %rbx # 0x6d8d0
movb (%rbx,%r12), %al
jne 0x18b82
testb $0x1, %al
j... | /OLSR[P]OONF/src/base/os_generic/os_fd_generic_join_mcast.c |
os_fd_linux_skip_rawsocket_prefix | uint8_t *
os_fd_linux_skip_rawsocket_prefix(uint8_t *ptr, ssize_t *len, int af_type) {
int header_size;
if (af_type != AF_INET) {
return ptr;
}
/* skip IPv4 header */
header_size = (ptr[0] & 0x0f) << 2;
*len -= header_size;
return ptr + header_size;
} | movq %rdi, %rax
cmpl $0x2, %edx
jne 0x190fc
movzbl (%rax), %ecx
shll $0x2, %ecx
andl $0x3c, %ecx
subq %rcx, (%rsi)
addq %rcx, %rax
retq
| /OLSR[P]OONF/src/base/os_linux/os_fd_linux.c |
remove_interface | static void
_remove_interface(struct os_interface *data) {
struct os_interface_ip *ip, *ip_iter;
if (!list_is_empty(&data->_listeners) || data->_internal.configured) {
return;
}
if (data->flags.mesh) {
_cleanup_mesh(data);
}
/* remove all addresses */
avl_for_each_element_safe(&data->addresses,... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xb0(%rdi), %rax
cmpq %rax, 0xb0(%rdi)
jne 0x198db
movq %rdi, %rbx
cmpq %rax, 0xb8(%rdi)
jne 0x198db
cmpb $0x0, 0xa(%rbx)
je 0x198e5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpb $0x1, 0x2a(%rbx)
jne 0x198f3
movq %rbx, %rdi
callq 0x195a2
movq 0x6... | /OLSR[P]OONF/src/base/os_linux/os_interface_linux.c |
os_interface_linux_address_set | int
os_interface_linux_address_set(struct os_interface_ip_change *addr) {
uint8_t buffer[UIO_MAXIOV];
struct nlmsghdr *msg;
struct ifaddrmsg *ifaddrreq;
int seq;
#if defined(OONF_LOG_DEBUG_INFO)
struct netaddr_str nbuf;
#endif
memset(buffer, 0, sizeof(buffer));
/* get pointers for netlink message */
m... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x448, %rsp # imm = 0x448
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movl $0x400, %edx # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x11250
movzbl 0x34(%rbx), %eax
testw %ax, %ax
movl $0x505, %ecx # imm = 0x505
movl $0x5, %edx
cmovnel ... | /OLSR[P]OONF/src/base/os_linux/os_interface_linux.c |
remove_address | static void
_remove_address(struct os_interface *os_if, struct netaddr *prefixed_addr, bool peer) {
struct os_interface_ip *ip;
struct avl_tree *tree;
#if defined(OONF_LOG_INFO)
struct netaddr_str nbuf;
#endif
tree = peer ? &os_if->peers : &os_if->addresses;
ip = avl_find_element(tree, prefixed_addr, ip, _no... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r15
leaq 0x60(%rdi), %rbx
leaq 0x88(%rdi), %rax
testl %edx, %edx
cmovneq %rax, %rbx
movq %rbx, %rdi
callq 0x2780e
testq %rax, %rax
je 0x1b347
movq %rax, %r14
movl 0x368f6(%rip), %r13d # 0x51... | /OLSR[P]OONF/src/base/os_linux/os_interface_linux.c |
os_system_linux_is_minimal_kernel | bool
os_system_linux_is_minimal_kernel(int v1, int v2, int v3) {
struct utsname uts;
char *next;
int first = 0, second = 0, third = 0;
memset(&uts, 0, sizeof(uts));
if (uname(&uts)) {
OONF_WARN(LOG_OS_SYSTEM, "Error, could not read kernel version: %s (%d)\n", strerror(errno), errno);
return false;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movl %edx, %ebp
movl %esi, %r15d
movl %edi, %r12d
leaq 0xa(%rsp), %rbx
movl $0x186, %edx # imm = 0x186
movq %rbx, %rdi
xorl %esi, %esi
callq 0x11250
movq %rbx, %rdi
callq 0x11200
testl %eax, %eax
je 0x1bc02
movl... | /OLSR[P]OONF/src/base/os_linux/os_system_linux.c |
os_system_linux_netlink_add_mc | int
os_system_linux_netlink_add_mc(struct os_system_netlink *nl, const uint32_t *groups, size_t groupcount) {
size_t i;
for (i = 0; i < groupcount; i++) {
if (setsockopt(os_fd_get_fd(&nl->socket.fd), SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &groups[i], sizeof(groups[i]))) {
OONF_WARN(nl->used_by->logging, "C... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdx, %rdx
je 0x1c8ed
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movl 0x10(%r14), %edi
movl $0x10e, %esi # imm = 0x10E
movl $0x1, %edx
movq %r15, %rcx
movl $0x4, %r8d
callq 0x11130
testl %eax, %eax
jne 0x1c89a
addq $0x4, %r15
d... | /OLSR[P]OONF/src/base/os_linux/os_system_linux.c |
os_routing_linux_query | int
os_routing_linux_query(struct os_route *route) {
uint8_t buffer[UIO_MAXIOV];
struct nlmsghdr *msg;
struct rtgenmsg *rt_gen;
int seq;
OONF_ASSERT(route->cb_finished != NULL && route->cb_get != NULL, LOG_OS_ROUTING, "illegal route query");
memset(buffer, 0, sizeof(buffer));
/* get pointers for netlink... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x410, %rsp # imm = 0x410
movq %rdi, %rbx
cmpq $0x0, 0xa0(%rdi)
je 0x1d21c
cmpq $0x0, 0xa8(%rbx)
jne 0x1d22f
movl 0x351aa(%rip), %esi # 0x523cc
leaq 0x506a7(%rip), %rax # 0x6d8d0
testb $0x8, (%rax,%rsi)
jne 0x1d2a4
leaq 0x10(%rsp), %r14
xorl %ebp, %ebp
movl $0x4... | /OLSR[P]OONF/src/base/os_linux/os_routing_linux.c |
init | static int
_init(void) {
if (os_system_linux_netlink_add(&_rtnetlink_socket, NETLINK_ROUTE)) {
return -1;
}
if (os_system_linux_netlink_add_mc(&_rtnetlink_socket, _rtnetlink_mcast, ARRAYSIZE(_rtnetlink_mcast))) {
os_system_linux_netlink_remove(&_rtnetlink_socket);
return -1;
}
avl_init(&_rtnetlink... | pushq %rbx
leaq 0x3508d(%rip), %rdi # 0x52420
xorl %esi, %esi
callq 0x1bcd7
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x1d410
leaq 0x35076(%rip), %rdi # 0x52420
leaq 0x1d187(%rip), %rsi # 0x3a538
movl $0x2, %edx
callq 0x1c853
testl %eax, %eax
je 0x1d3cd
leaq 0x3505a(%rip), %rdi ... | /OLSR[P]OONF/src/base/os_linux/os_routing_linux.c |
cb_rtnetlink_timeout | static void
_cb_rtnetlink_timeout(void) {
struct os_route *route, *rt_it;
OONF_WARN(LOG_OS_ROUTING, "Netlink timeout for routing");
avl_for_each_element_safe(&_rtnetlink_feedback, route, _internal._node, rt_it) {
_routing_finished(route, -1);
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0x348a1(%rip), %esi # 0x523cc
leaq 0x4fd9e(%rip), %rax # 0x6d8d0
testb $0x4, (%rax,%rsi)
je 0x1db61
leaq 0x1cbf4(%rip), %rax # 0x3a733
movq %rax, (%rsp)
leaq 0x1ca7c(%rip), %rdx # 0x3a5c6
movl $0x4, %edi
movl $0x2b3, %ecx # imm = 0x2B3
xo... | /OLSR[P]OONF/src/base/os_linux/os_routing_linux.c |
cb_compact_save | static int
_cb_compact_save(const char *param, struct cfg_db *src_db, struct autobuf *log) {
int fd = 0;
ssize_t bytes;
size_t total;
struct autobuf abuf;
if (abuf_init(&abuf)) {
cfg_append_printable_line(log, "Out of memory error while allocating io buffer");
return -1;
}
if (_compact_serialize(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x38(%rsp), %rdi
callq 0x271cc
testl %eax, %eax
je 0x1e264
leaq 0x1c612(%rip), %rsi # 0x3a858
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2dfe9
movl $0xffffffff, %eax # imm = 0xF... | /OLSR[P]OONF/src/generic/cfg_compact/cfg_compact.c |
cb_create_text_default | static int
_cb_create_text_default(struct oonf_viewer_template *template) {
struct oonf_layer2_net *net;
avl_for_each_element(oonf_layer2_get_net_tree(), net, _node) {
_initialize_if_values(net);
_initialize_neigh_data_values(template, net->neighdata);
_initialize_neigh_origin_values(net->neighdata);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x134d9
movq (%rax), %r15
movq 0x8(%r15), %r14
callq 0x134d9
cmpq 0x8(%rax), %r14
je 0x1ea8e
leaq -0x7a0(%r15), %rdi
callq 0x1eb70
leaq -0x410(%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ed0c
movq %r14, %rdi
callq 0x1ed70
movq %rbx, %rdi
callq 0x17b21
movq... | /OLSR[P]OONF/src/generic/layer2info/layer2info.c |
cb_create_text_dst | static int
_cb_create_text_dst(struct oonf_viewer_template *template) {
struct oonf_layer2_destination *l2dst;
struct oonf_layer2_neigh *neigh;
struct oonf_layer2_net *net;
avl_for_each_element(oonf_layer2_get_net_tree(), net, _node) {
_initialize_if_values(net);
avl_for_each_element(&net->neighbors, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x134d9
movq (%rax), %r12
movq 0x8(%r12), %r14
callq 0x134d9
cmpq 0x8(%rax), %r14
je 0x1eb5f
leaq 0x4dd99(%rip), %r14 # 0x6c860
leaq 0x4ddd2(%rip), %r15 # 0x6c8a0
leaq -0x7a0(%r12), %rdi
callq 0x1eb70
movq -0x710(... | /OLSR[P]OONF/src/generic/layer2info/layer2info.c |
initialize_neigh_values | static void
_initialize_neigh_values(struct oonf_layer2_neigh *neigh) {
netaddr_to_string(&_value_neigh_addr, &neigh->key.addr);
oonf_layer2_neigh_key_to_string(&_value_neigh_key, &neigh->key, false);
snprintf(_value_neigh_key_length, sizeof(_value_neigh_key_length), "%u", neigh->key.link_id_length);
netaddr_t... | pushq %rbx
movq %rdi, %rbx
leaq 0x4da10(%rip), %rdi # 0x6c680
movq %rbx, %rsi
xorl %edx, %edx
callq 0x28e44
leaq 0x4da3d(%rip), %rdi # 0x6c6be
movq %rbx, %rsi
xorl %edx, %edx
callq 0x134e9
movzbl 0x12(%rbx), %ecx
leaq 0x4da8b(%rip), %rdi # 0x6c721
leaq 0x228b6(%rip), %rdx # 0x41553
movl $0x6, %esi
xorl ... | /OLSR[P]OONF/src/generic/layer2info/layer2info.c |
cb_create_text_ifpeer | static int
_cb_create_text_ifpeer(struct oonf_viewer_template *template) {
struct os_interface *interf;
struct os_interface_ip *ip;
avl_for_each_element(os_interface_get_tree(), interf, _node) {
_initialize_interface_key_values(template, interf);
avl_for_each_element(&interf->peers, ip, _node) {
_... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x199b4
movq (%rax), %r15
movq 0x8(%r15), %r14
callq 0x199b4
cmpq 0x8(%rax), %r14
je 0x1f457
leaq -0xc8(%r15), %rdi
callq 0x1f45f
movq -0x40(%r15), %r14
movq 0x8(%r14), %rax
cmpq -0x38(%r15), %rax
je 0x1f452
movq %r14, %rdi
callq 0x1f4bb
movq %rbx, %rdi
callq 0x17b... | /OLSR[P]OONF/src/generic/systeminfo/systeminfo.c |
cb_neigh_value_tobin | static int
_cb_neigh_value_tobin(struct cfg_schema_entry *entries __attribute__((unused)),
size_t entry_count __attribute__((unused)), const char *value __attribute__((unused)), void *ptr) {
struct l2_config_data *l2_data;
const struct oonf_layer2_metadata *meta;
l2_data = ptr;
meta = oonf_layer2_neigh_meta... | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl 0x28(%rcx), %edi
callq 0x126d2
movq %rax, %r14
leaq 0x30(%rbx), %rdi
leaq 0x48(%rbx), %rdx
movq %rax, %rsi
callq 0x12228
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x1fcd6
movl 0x10(%r14), %eax
movl %eax, 0x2c(%rbx)
xorl %ea... | /OLSR[P]OONF/src/generic/layer2_config/layer2_config.c |
reset_if_data | static void
_reset_if_data(struct oonf_layer2_net *l2net, struct l2_config_data *entry, struct oonf_layer2_origin *origin) {
struct oonf_layer2_neighbor_address *l2_remote_ip;
struct oonf_layer2_peer_address *l2_local_peer;
struct oonf_layer2_destination *l2_neigh_dest;
struct oonf_layer2_neigh *l2neigh;
swi... | pushq %r14
pushq %rbx
pushq %rax
movl (%rsi), %eax
cmpq $0x5, %rax
ja 0x20267
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x1ac5d(%rip), %rcx # 0x3ada0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq 0x28(%rbx), %rax
leaq (%rax,%rax,4), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x128(%rdi,%rax,8)
jmp 0x20267
leaq... | /OLSR[P]OONF/src/generic/layer2_config/layer2_config.c |
radio_write_session_update | static int
_radio_write_session_update(struct dlep_extension *ext __attribute__((unused)), struct dlep_session *session,
const struct oonf_layer2_neigh_key *neigh __attribute__((unused))) {
struct _prefix_storage *storage, *storage_it;
struct dlep_radio_session *radio_session;
struct oonf_layer2_peer_address *p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq 0x138(%rsi), %r14
callq 0x134d9
movq %rax, %rdi
movq %r14, %rsi
callq 0x2780e
leaq -0x7a0(%rax), %r15
testq %rax, %rax
movq %rax, 0x10(%rsp)
cmoveq %rax, %r15
je 0x2139e
movq 0xb8(%r15), %r14
movq 0x8(%r14), %rax
cmp... | /OLSR[P]OONF/src/generic/dlep/ext_base_ip/ip.c |
router_process_destination_update | static enum dlep_parser_error
_router_process_destination_update(struct dlep_extension *ext __attribute((unused)), struct dlep_session *session) {
struct oonf_layer2_neigh *l2neigh;
struct netaddr ip;
struct dlep_parser_value *value;
bool add_ip;
l2neigh = dlep_extension_get_l2_neighbor(session);
if (!l2ne... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x226fc
xorl %ebp, %ebp
testq %rax, %rax
je 0x2176a
movq %rax, %r14
movq %rbx, %rdi
movl $0x8, %esi
callq 0x24eaf
testq %rax, %rax
je 0x21627
movq %rax, %r15
leaq 0x6(%rsp), %r12
leaq 0x5(%rsp), %r13... | /OLSR[P]OONF/src/generic/dlep/ext_base_ip/ip.c |
add_prefix | static void
_add_prefix(struct avl_tree *tree, struct netaddr *addr) {
struct _prefix_storage *storage;
storage = avl_find_element(tree, addr, storage, _node);
if (storage) {
return;
}
storage = oonf_class_malloc(&_prefix_class);
if (!storage) {
return;
}
/* copy key and put into tree */
me... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2780e
testq %rax, %rax
je 0x21b6c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x34995(%rip), %rdi # 0x56508
callq 0x11933
testq %rax, %rax
je 0x21b64
movzwl 0x10(%r14), %ecx
movw %cx, 0x10(%rax)
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq... | /OLSR[P]OONF/src/generic/dlep/ext_base_ip/ip.c |
dlep_extension_router_process_destination | enum dlep_parser_error
dlep_extension_router_process_destination(struct dlep_extension *ext, struct dlep_session *session) {
struct oonf_layer2_neigh *l2neigh;
enum dlep_parser_error result;
if (session->restrict_signal != DLEP_ALL_SIGNALS) {
/* ignore unless we have an established session */
return DLEP... | pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
cmpl $-0x1, 0x20(%rsi)
je 0x22773
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x226fc
testq %rax, %rax
je 0x2276b
addq $0xb0, %rax
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x256cb
testl %eax, %eax
... | /OLSR[P]OONF/src/generic/dlep/dlep_extension.c |
dlep_extension_radio_write_destination | int
dlep_extension_radio_write_destination(
struct dlep_extension *ext, struct dlep_session *session, const struct oonf_layer2_neigh_key *neigh) {
struct oonf_layer2_neigh *l2neigh;
union oonf_layer2_neigh_key_str nbuf;
int result;
l2neigh = dlep_session_get_local_l2_neighbor(session, neigh);
if (!l2neigh)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2490a
testq %rax, %rax
je 0x22cc2
leaq 0xc8(%r12), %rdi
movq %rax, %rdx
addq $0xb0, %rdx
movl $0x390, %ecx # imm = 0x390
addq 0x28(%rax), %rcx
movq %r15, %rsi
c... | /OLSR[P]OONF/src/generic/dlep/dlep_extension.c |
dlep_session_add_local_neighbor | struct dlep_local_neighbor *
dlep_session_add_local_neighbor(struct dlep_session *session, const struct oonf_layer2_neigh_key *key) {
struct dlep_local_neighbor *local;
if ((local = dlep_session_get_local_neighbor(session, key))) {
return local;
}
if (key->link_id_length != 0 && key->link_id_length != sess... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xe0(%rdi), %r15
movq %r15, %rdi
callq 0x2780e
movq %rax, %r14
addq $-0xe0, %rax
testq %r14, %r14
cmovneq %rax, %r14
jne 0x248ce
movzbl 0x12(%r12), %eax
testl %eax, %eax
je 0x24858
cmpl %eax, 0x1c(%rbx)
jne 0x248cb
leaq 0x337f1(... | /OLSR[P]OONF/src/generic/dlep/dlep_session.c |
dlep_session_get_local_l2_neighbor | struct oonf_layer2_neigh *
dlep_session_get_local_l2_neighbor(struct dlep_session *session, const struct oonf_layer2_neigh_key *key) {
struct dlep_local_neighbor *dlep_neigh;
struct oonf_layer2_neigh *l2neigh;
struct oonf_layer2_net *l2net;
#ifdef OONF_LOG_INFO
union oonf_layer2_neigh_key_str nbuf1, nbuf2;
#end... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0xe0, %rdi
callq 0x2780e
movq %rax, %r12
addq $-0xe0, %rax
testq %r12, %r12
cmovneq %rax, %r12
je 0x24a09
movq 0x138(%r15), %rbx
callq 0x134d9
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2780e
testq %rax, %rax
je 0x24a5e
addq... | /OLSR[P]OONF/src/generic/dlep/dlep_session.c |
dlep_reader_heartbeat_tlv | int
dlep_reader_heartbeat_tlv(uint64_t *interval, struct dlep_session *session, struct dlep_parser_value *value) {
uint32_t tmp;
const uint8_t *ptr;
if (!value) {
value = dlep_session_get_tlv_value(session, DLEP_HEARTBEAT_INTERVAL_TLV);
if (!value) {
return -1;
}
}
ptr = dlep_session_get_t... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
jne 0x24fdc
movq %r14, %rdi
movl $0x5, %esi
callq 0x24eaf
movq %rax, %rdx
testq %rax, %rax
je 0x24ff9
movq 0xa8(%r14), %rax
movzwl 0x4(%rdx), %ecx
movl (%rax,%rcx), %eax
bswapl %eax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %... | /OLSR[P]OONF/src/generic/dlep/dlep_reader.c |
dlep_reader_ipv6_subnet_tlv | int
dlep_reader_ipv6_subnet_tlv(
struct netaddr *ipv6, bool *add, struct dlep_session *session, struct dlep_parser_value *value) {
const uint8_t *ptr;
if (!value) {
value = dlep_session_get_tlv_value(session, DLEP_IPV6_SUBNET_TLV);
if (!value) {
return -1;
}
}
ptr = dlep_session_get_tlv_bi... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rcx, %rcx
jne 0x25324
movq %r15, %rdi
movl $0xb, %esi
callq 0x24eaf
movq %rax, %rcx
testq %rax, %rax
je 0x2535a
movq 0xa8(%r15), %rax
movzwl 0x4(%rcx), %ecx
leaq (%rax,%rcx), %rsi
incq %rsi
movb -0x1(%rsi), %al
andb $0x1, %al
movb %... | /OLSR[P]OONF/src/generic/dlep/dlep_reader.c |
dlep_reader_ipv4_conpoint_tlv | int
dlep_reader_ipv4_conpoint_tlv(
struct netaddr *addr, uint16_t *port, bool *tls, struct dlep_session *session, struct dlep_parser_value *value) {
uint16_t tmp;
const uint8_t *ptr;
if (!value) {
value = dlep_session_get_tlv_value(session, DLEP_IPV4_CONPOINT_TLV);
if (!value) {
return -1;
}
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %r8, %r8
jne 0x25393
movq %r12, %rdi
movl $0x2, %esi
callq 0x24eaf
movq %rax, %r8
testq %rax, %rax
je 0x253f7
movzwl 0x6(%r8), %eax
orl $0x2, %eax
cmpl $0x7, %eax
jne 0x253f7
movq 0xa8(%r12), %ra... | /OLSR[P]OONF/src/generic/dlep/dlep_reader.c |
dlep_reader_uint64 | int
dlep_reader_uint64(uint64_t *number, uint16_t tlv_id, struct dlep_session *session, struct dlep_parser_value *value) {
uint64_t tmp;
const uint8_t *ptr;
if (!value) {
value = dlep_session_get_tlv_value(session, tlv_id);
if (!value) {
return -1;
}
}
ptr = dlep_session_get_tlv_binary(ses... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testq %rcx, %rcx
jne 0x254cd
movzwl %si, %esi
movq %r14, %rdi
callq 0x24eaf
movq %rax, %rcx
testq %rax, %rax
je 0x254ec
movq 0xa8(%r14), %rax
movzwl 0x4(%rcx), %ecx
movq (%rax,%rcx), %rax
bswapq %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq ... | /OLSR[P]OONF/src/generic/dlep/dlep_reader.c |
dlep_writer_add_ip_tlv | int
dlep_writer_add_ip_tlv(struct dlep_writer *writer, const struct netaddr *ip, bool add) {
uint8_t value[18];
value[0] = add ? DLEP_IP_ADD : DLEP_IP_REMOVE;
netaddr_to_binary(&value[1], ip, 16);
switch (netaddr_get_address_family(ip)) {
case AF_INET:
value[5] = netaddr_get_prefix_length(ip);
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1(%rsp), %rdi
movb %dl, -0x1(%rdi)
movl $0x10, %edx
callq 0x289c7
movzbl 0x10(%r14), %ecx
cmpl $0xa, %ecx
je 0x25b69
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x2, %ecx
jne 0x25ba4
movb 0x11(%r14), %al
movb %al, 0x5(%rsp)
movq %rs... | /OLSR[P]OONF/src/generic/dlep/dlep_writer.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.