name string | code string | asm string | file string |
|---|---|---|---|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::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::alloc... | const typename object_t::key_type& key() const
{
JSON_ASSERT(m_object != nullptr);
if (JSON_HEDLEY_LIKELY(m_object->is_object()))
{
return m_it.object_iterator->first;
}
JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_obje... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, (%rax)
jne 0x21a6ea
leaq 0x136d5f(%rip), %rdi # 0x35142f
movl $0x3519, %esi # imm = 0x3519
leaq 0x126729(%rip), %rdx # 0x340e05
leaq 0x128e55(%rip), %rcx # 0x343538
movb $0x0, %al
callq 0x7c9b0
movq 0x10(%rs... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::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 char>>, void>::operator[](unsign... | const_reference operator[](size_type idx) const
{
// const operator[] only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
return m_data.m_value.array->operator[](idx);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numer... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2099c0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x21cfb7
jmp 0x21cfcf
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x48(%rsp), %rsi
callq 0x21ca90
addq $0x58, %rsp
retq
movb $0x1, 0x13(%rsp)
movl... | /ggerganov[P]llama/common/json.hpp |
common_chat_tool_choice_parse_oaicompat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | common_chat_tool_choice common_chat_tool_choice_parse_oaicompat(const std::string & tool_choice) {
if (tool_choice == "auto") {
return COMMON_CHAT_TOOL_CHOICE_AUTO;
}
if (tool_choice == "none") {
return COMMON_CHAT_TOOL_CHOICE_NONE;
}
if (tool_choice == "required") {
return C... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x116cb4(%rip), %rsi # 0x345089
callq 0xc6b10
testb $0x1, %al
jne 0x22e3e0
jmp 0x22e3ed
movl $0x0, 0x44(%rsp)
jmp 0x22e4ca
movq 0x38(%rsp), %rdi
leaq 0x11851c(%rip), %rsi # 0x346915
callq 0xc6b10
testb $0x1, %al
jne 0x22e404
jmp 0x22e411
movl $0x2,... | /ggerganov[P]llama/common/chat.cpp |
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 common_chat_msgs_to_json_oaicompat(const std::vector<common_chat_msg> & msgs, bool concat_typed_text) {
json messages = json::array();
for (const auto & msg : msgs) {
if (!msg.content.empty() && !msg.content_parts.empty()) {
throw std::runtime_error("Cannot specify both content and cont... | subq $0x838, %rsp # imm = 0x838
movq %rdi, 0x360(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x358(%rsp)
movq %rdi, 0x830(%rsp)
movq %rsi, 0x828(%rsp)
andb $0x1, %al
movb %al, 0x827(%rsp)
movb $0x0, 0x826(%rsp)
leaq 0x810(%rsp), %rdi
callq 0x108860
movq 0x360(%rsp), %rdi
movq 0x810(%rsp), %rsi
movq 0x818(... | /ggerganov[P]llama/common/chat.cpp |
std::vector<common_chat_tool, std::allocator<common_chat_tool>> common_chat_tools_parse_oaicompat<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... | std::vector<common_chat_tool> common_chat_tools_parse_oaicompat(const json & tools) {
std::vector<common_chat_tool> result;
try {
if (!tools.is_null()) {
if (!tools.is_array()) {
throw std::runtime_error("Expected 'tools' to be an array, got " + tools.dump());
}
... | subq $0x368, %rsp # imm = 0x368
movq %rdi, 0xa0(%rsp)
movq %rdi, %rax
movq %rax, 0xa8(%rsp)
movq %rdi, 0x360(%rsp)
movq %rsi, 0x358(%rsp)
movb $0x0, 0x357(%rsp)
callq 0x18dda0
movq 0x358(%rsp), %rdi
callq 0x10c400
testb $0x1, %al
jne 0x232295
movq 0x358(%rsp), %rdi
callq 0xc08b0
testb $0x1, %al
jne 0x231b67
... | /ggerganov[P]llama/common/chat.cpp |
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 common_chat_tools_to_json_oaicompat(const std::vector<common_chat_tool> & tools) {
if (tools.empty()) {
return json();
}
auto result = json::array();
for (const auto & tool : tools) {
result.push_back({
{"type", "function"},
{"function", {
{"... | subq $0x4b8, %rsp # imm = 0x4B8
movq %rdi, 0x208(%rsp)
movq %rdi, %rax
movq %rax, 0x210(%rsp)
movq %rdi, 0x4b0(%rsp)
movq %rsi, 0x4a8(%rsp)
movq 0x4a8(%rsp), %rdi
callq 0x18d8a0
testb $0x1, %al
jne 0x2324ed
jmp 0x232503
movq 0x208(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xbbc20
jmp 0x2331f3
movb $0... | /ggerganov[P]llama/common/chat.cpp |
common_chat_verify_template(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | bool common_chat_verify_template(const std::string & tmpl, bool use_jinja) {
if (use_jinja) {
try {
common_chat_msg msg;
msg.role = "user";
msg.content = "test";
auto tmpls = common_chat_templates_init(/* model= */ nullptr, tmpl);
common_chat_tem... | subq $0x3d8, %rsp # imm = 0x3D8
movb %sil, %al
movq %rdi, 0x3c8(%rsp)
andb $0x1, %al
movb %al, 0x3c7(%rsp)
testb $0x1, 0x3c7(%rsp)
je 0x233671
leaq 0x2f0(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x1b5ac0
movq 0x60(%rsp), %rdi
leaq 0x12253f(%rip), %rsi # 0x355796
callq 0x7c5c0
jmp 0x23325e
leaq 0x310(%rsp),... | /ggerganov[P]llama/common/chat.cpp |
common_chat_templates_init(llama_model const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | common_chat_templates_ptr common_chat_templates_init(
const struct llama_model * model,
const std::string & chat_template_override,
const std::string & bos_token_override,
const std::string & eos_token_override)
{
std::string default_template_src;
std::string template_tool_use_src;
bool has... | subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, 0x60(%rsp)
movq %rdi, %rax
movq %rax, 0x68(%rsp)
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq %rdx, 0x1b0(%rsp)
movq %rcx, 0x1a8(%rsp)
movq %r8, 0x1a0(%rsp)
leaq 0x180(%rsp), %rdi
callq 0x7d370
leaq 0x160(%rsp), %rdi
callq 0x7d370
movq 0x1b0(%rsp), %rdi
callq ... | /ggerganov[P]llama/common/chat.cpp |
common_chat_parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, common_chat_format) | common_chat_msg common_chat_parse(const std::string & input, common_chat_format format) {
switch (format) {
case COMMON_CHAT_FORMAT_CONTENT_ONLY:
return common_chat_parse_content_only(input);
case COMMON_CHAT_FORMAT_GENERIC:
return common_chat_parse_generic(input);
ca... | subq $0x88, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movl 0x74(%rsp), %eax
movq %rax, 0x18(%rsp)
subq $0xd, %rax
ja 0x235fc1
movq 0x18(%rsp), %rax
leaq 0x11c924(%rip), %rcx # 0x3527a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
j... | /ggerganov[P]llama/common/chat.cpp |
common_chat_parse_functionary_v3_1_llama_3_1(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static common_chat_msg common_chat_parse_functionary_v3_1_llama_3_1(const std::string & input) {
// This version of Functionary still supports the llama 3.1 tool call format for the python tool.
static const std::regex python_tag_regex(R"(<\|python_tag\|>([\s\S\n]*)$)");
std::smatch match;
if (std::rege... | subq $0x2a8, %rsp # imm = 0x2A8
movq %rdi, 0xe8(%rsp)
movq %rdi, %rax
movq %rax, 0xf0(%rsp)
movq %rdi, 0x2a0(%rsp)
movq %rsi, 0x298(%rsp)
cmpb $0x0, 0x330307(%rip) # 0x567fb8
jne 0x237d04
leaq 0x3302fe(%rip), %rdi # 0x567fb8
callq 0x7d2c0
cmpl $0x0, %eax
je 0x237d04
leaq 0x3302cd(%rip), %rdi # 0x567... | /ggerganov[P]llama/common/chat.cpp |
build_grammar[abi:cxx11](std::function<void (common_grammar_builder const&)> const&, common_grammar_options const&)::$_0::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string build_grammar(const std::function<void(const common_grammar_builder &)> & cb, const common_grammar_options & options) {
SchemaConverter converter([&](const std::string &) { return json(); }, options.dotall);
common_grammar_builder builder {
/* .add_rule = */ [&](const std::string & name, con... | subq $0x28, %rsp
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xbbc20
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
| /ggerganov[P]llama/common/json-schema-to-grammar.cpp |
SchemaConverter::_build_object_rule(std::vector<std::pair<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, lon... | std::string _build_object_rule(
const std::vector<std::pair<std::string, json>> & properties,
const std::unordered_set<std::string> & required,
const std::string & name,
const json & additional_properties)
{
std::vector<std::string> required_props;
std::vector<std::st... | subq $0x658, %rsp # imm = 0x658
movq %rdi, 0xc0(%rsp)
movq %rdi, %rax
movq %rax, 0xc8(%rsp)
movq %rdi, 0x650(%rsp)
movq %rsi, 0x648(%rsp)
movq %rdx, 0x640(%rsp)
movq %rcx, 0x638(%rsp)
movq %r8, 0x630(%rsp)
movq %r9, 0x628(%rsp)
movq 0x648(%rsp), %rax
movq %rax, 0xd0(%rsp)
leaq 0x610(%rsp), %rdi
callq 0xb9080... | /ggerganov[P]llama/common/json-schema-to-grammar.cpp |
SchemaConverter::_visit_pattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string _visit_pattern(const std::string & pattern, const std::string & name) {
if (!(pattern.front() == '^' && pattern.back() == '$')) {
_errors.push_back("Pattern must start with '^' and end with '$'");
return "";
}
std::string sub_pattern = pattern.substr(1, patter... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x40(%rsp)
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq %rdx, 0x1f0(%rsp)
movq %rcx, 0x1e8(%rsp)
movq 0x1f8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x1f0(%rsp), %rdi
callq 0x7c350
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x... | /ggerganov[P]llama/common/json-schema-to-grammar.cpp |
_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 0xc0680
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
callq 0xc06b0
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xc06e0
testb $0x1, %al
jne 0x324fb6
jmp 0x324ff6
movq 0x10(%rsp), %rax... | /ggerganov[P]llama/common/json.hpp |
SchemaConverter::_not_strings(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::string _not_strings(const std::vector<std::string> & strings) {
struct TrieNode {
std::map<char, TrieNode> children;
bool is_end_of_string;
TrieNode() : is_end_of_string(false) {}
void insert(const std::string & string) {
auto node = this;
... | subq $0x2d8, %rsp # imm = 0x2D8
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x2d0(%rsp)
movq %rsi, 0x2c8(%rsp)
movq %rdx, 0x2c0(%rsp)
movq 0x2c8(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x288(%rsp), %rdi
callq 0x326a30
movq 0x2c0(%rsp), %rax
movq %rax, 0x280(%rsp)
movq 0x280(%rsp), %... | /ggerganov[P]llama/common/json-schema-to-grammar.cpp |
string_view::operator[](unsigned long) const | char operator[](size_t pos) const {
auto index = _start + pos;
if (index >= _end) {
throw std::out_of_range("string_view index out of range");
}
return _str[_start + pos];
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x10(%rcx), %rax
jb 0x32e923
movl $0x10, %edi
callq 0x7d3d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x2db3b(%... | /ggerganov[P]llama/common/json-schema-to-grammar.cpp |
SchemaConverter::resolve_refs(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 c... | void resolve_refs(json & schema, const std::string & url) {
/*
* Resolves all $ref fields in the given schema, fetching any remote schemas,
* replacing each $ref with absolute reference URL and populates _refs with the
* respective referenced (sub)schema dictionaries.
*/
... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x32eb90
mov... | /ggerganov[P]llama/common/json-schema-to-grammar.cpp |
common_log::pause() | void pause() {
{
std::lock_guard<std::mutex> lock(mtx);
if (!running) {
return;
}
running = false;
// push an entry to signal the worker thread to stop
{
auto & entry = entries[tail];
entry... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rsi
movq %rsi, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xb2830
movq 0x10(%rsp), %rax
testb $0x1, 0x6a(%rax)
jne 0x330422
movl $0x1, 0x24(%rsp)
jmp 0x330494
movq 0x10(%rsp), %rax
movb $0x0, 0x6a(%rax)
movq %rax, %rdi
addq $0x78, %rdi
movq 0x98(%rax), %rsi
callq 0x3... | /ggerganov[P]llama/common/log.cpp |
common_params_sampling::print[abi:cxx11]() const | std::string common_params_sampling::print() const {
char result[1024];
snprintf(result, sizeof(result),
"\trepeat_last_n = %d, repeat_penalty = %.3f, frequency_penalty = %.3f, presence_penalty = %.3f\n"
"\tdry_multiplier = %.3f, dry_base = %.3f, dry_allowed_length = %d, dry_penalty_last... | subq $0x4a8, %rsp # imm = 0x4A8
movq %rdi, 0x60(%rsp)
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0x4a0(%rsp)
movq %rsi, 0x498(%rsp)
movq 0x498(%rsp), %rax
movq %rax, 0x50(%rsp)
movl 0x34(%rax), %ecx
movss 0x38(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movss 0x3c(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movss 0x40(%... | /ggerganov[P]llama/common/sampling.cpp |
common_sampler_clone(common_sampler*) | struct common_sampler * common_sampler_clone(common_sampler * gsmpl) {
return new common_sampler {
/* .params = */ gsmpl->params,
/* .grmr = */ llama_sampler_clone(gsmpl->grmr),
/* .chain = */ llama_sampler_clone(gsmpl->chain),
/* .prev = */ gsmpl->prev,
/* .cur = */ ... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl $0x1a0, %edi # imm = 0x1A0
callq 0x7cf40
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rsi
callq 0xf7810
jmp 0x334832
movq 0x30(%rsp), %rax
addq $0x120, %rax # imm = 0x120
movq %rax, 0x20(%r... | /ggerganov[P]llama/common/sampling.cpp |
common_sampler_sample_and_accept_n(common_sampler*, llama_context*, std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&, bool) | std::vector<llama_token> common_sampler_sample_and_accept_n(struct common_sampler * gsmpl, struct llama_context * ctx, const std::vector<int> & idxs, const llama_tokens & draft, bool grammar_first) {
GGML_ASSERT(idxs.size() == draft.size() + 1 && "idxs.size() must be draft.size() + 1");
std::vector<llama_token... | subq $0xa8, %rsp
movq %rdi, 0x40(%rsp)
movb %r9b, %al
movq %rdi, %r9
movq %r9, 0x48(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
andb $0x1, %al
movb %al, 0x7f(%rsp)
movq 0x88(%rsp), %rdi
callq 0xf6660
movq %rax, 0x50(%rsp)
movq 0x80(%rsp), %rdi
callq... | /ggerganov[P]llama/common/sampling.cpp |
common_sampler_sample_and_accept_n(common_sampler*, llama_context*, std::vector<int, std::allocator<int>> const&, bool) | std::vector<llama_token> common_sampler_sample_and_accept_n(struct common_sampler * gsmpl, struct llama_context * ctx, const llama_tokens & draft, bool grammar_first) {
std::vector<int> idxs(draft.size() + 1);
for (size_t i = 0; i < idxs.size(); ++i) {
idxs[i] = i;
}
return common_sampler_sampl... | subq $0x98, %rsp
movq %rdi, 0x18(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x20(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq 0x78(%rsp), %rdi
callq 0xf6660
incq %rax
movq %rax, 0x28(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x30(... | /ggerganov[P]llama/common/sampling.cpp |
common_sampler_type_to_chr(common_sampler_type) | char common_sampler_type_to_chr(enum common_sampler_type cnstr) {
switch (cnstr) {
case COMMON_SAMPLER_TYPE_DRY: return 'd';
case COMMON_SAMPLER_TYPE_TOP_K: return 'k';
case COMMON_SAMPLER_TYPE_TYPICAL_P: return 'y';
case COMMON_SAMPLER_TYPE_TOP_P: return 'p';
... | movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rsp)
subl $0x9, %eax
ja 0x33551a
movq -0x10(%rsp), %rax
leaq 0x2747a(%rip), %rcx # 0x35c94c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x64, -0x1(%rsp)
jmp 0x33551f
movb $0x6b, -0x1(%rsp)
jmp 0x33551f
movb $0x79... | /ggerganov[P]llama/common/sampling.cpp |
common_sampler_types_from_names(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&, bool) | std::vector<common_sampler_type> common_sampler_types_from_names(const std::vector<std::string> & names, bool allow_alt_names) {
std::unordered_map<std::string, common_sampler_type> sampler_canonical_name_map {
{ "dry", COMMON_SAMPLER_TYPE_DRY },
{ "top_k", COMMON_SAMPLER_TYPE_TOP_K },... | subq $0x4e8, %rsp # imm = 0x4E8
movq %rdi, 0xb0(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0xb8(%rsp)
movq %rdi, 0x4e0(%rsp)
movq %rsi, 0x4d8(%rsp)
andb $0x1, %al
movb %al, 0x4d7(%rsp)
leaq 0x320(%rsp), %rdi
movq %rdi, 0x318(%rsp)
movl $0x1, 0x314(%rsp)
leaq 0x27439(%rip), %rsi # 0x35cd90
leaq 0x314(... | /ggerganov[P]llama/common/sampling.cpp |
ring_buffer<int>::push_back(int const&) | void push_back(const T & value) {
if (sz == capacity) {
// advance the start when buffer is full
first = (first + 1) % capacity;
} else {
sz++;
}
data[pos] = value;
pos = (pos + 1) % capacity;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rcx), %rax
cmpq (%rcx), %rax
jne 0x33696e
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rax
addq $0x1, %rax
xorl %edx, %edx
divq (%rcx)
movq 0x10(%rsp), %rax
movq %rdx, 0x10(%rax)
jmp 0x33697f
movq 0x10(%rsp), %... | /ggerganov[P]llama/common/sampling.cpp |
ring_buffer<int>::rat(unsigned long) const | const T & rat(size_t i) const {
if (i >= sz) {
throw std::runtime_error("ring buffer: index out of bounds");
}
return data[(first + sz - i - 1) % capacity];
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x8(%rcx), %rax
jb 0x336d18
movl $0x10, %edi
callq 0x7d3d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x260e5(%rip), %rsi # 0x35cdc4
callq 0x7c400
jmp 0x336ce6
movq 0x8(... | /ggerganov[P]llama/common/sampling.cpp |
common_speculative_gen_draft(common_speculative*, common_speculative_params, std::vector<int, std::allocator<int>> const&, int) | llama_tokens common_speculative_gen_draft(
struct common_speculative * spec,
struct common_speculative_params params,
const llama_tokens & prompt_tgt,
llama_token id_last) {
auto & batch = spec->batch;
auto & ctx = spec->ctx;
auto & smpl = spec->smpl;
auto & prompt ... | subq $0x3d8, %rsp # imm = 0x3D8
movq %rdi, 0x130(%rsp)
movq %rdi, %rax
movq %rax, 0x138(%rsp)
movq %rdi, 0x3d0(%rsp)
movq %rdx, 0x3b4(%rsp)
movss %xmm0, 0x3bc(%rsp)
movq 0x3b4(%rsp), %rax
movq %rax, 0x3c4(%rsp)
movl 0x3bc(%rsp), %eax
movl %eax, 0x3cc(%rsp)
movq %rsi, 0x3a8(%rsp)
movq %rcx, 0x3a0(%rsp)
movl %... | /ggerganov[P]llama/common/speculative.cpp |
nk_rgba_f | NK_API struct nk_color
nk_rgba_f(float r, float g, float b, float a)
{
struct nk_color ret;
ret.r = (nk_byte)(NK_SATURATE(r) * 255.0f);
ret.g = (nk_byte)(NK_SATURATE(g) * 255.0f);
ret.b = (nk_byte)(NK_SATURATE(b) * 255.0f);
ret.a = (nk_byte)(NK_SATURATE(a) * 255.0f);
return ret;
} | movss 0x3c265(%rip), %xmm4 # 0x42364
movaps %xmm4, %xmm6
minss %xmm0, %xmm6
movss 0x3c25a(%rip), %xmm0 # 0x42368
movaps %xmm6, %xmm5
mulss %xmm0, %xmm5
cvttss2si %xmm5, %ecx
movl $0xff, %esi
andl %esi, %ecx
xorl %edx, %edx
xorps %xmm5, %xmm5
ucomiss %xmm5, %xmm6
cmovbel %edx, %ecx
movaps %xmm4, %xmm6
minss %xmm1,... | /wjakob[P]glfw/deps/nuklear.h |
nk_font_atlas_init_custom | NK_API void
nk_font_atlas_init_custom(struct nk_font_atlas *atlas,
struct nk_allocator *permanent, struct nk_allocator *temporary)
{
NK_ASSERT(atlas);
NK_ASSERT(permanent);
NK_ASSERT(temporary);
if (!atlas || !permanent || !temporary) return;
nk_zero_struct(*atlas);
atlas->permanent = *perma... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xcd97
movq %rsi, %r15
testq %rsi, %rsi
je 0xcdb6
movq %rdx, %rbx
testq %rdx, %rdx
je 0xcdd5
movq %rdi, %r14
movl $0x190, %esi # imm = 0x190
callq 0x6d88
movq 0x10(%r15), %rax
movq %rax, 0x20(%r14)
movups (%r15), %xmm0
movups %xmm0, 0x10(%r14)
movups (%rbx... | /wjakob[P]glfw/deps/nuklear.h |
nk_panel_get_padding | NK_LIB struct nk_vec2
nk_panel_get_padding(const struct nk_style *style, enum nk_panel_type type)
{
switch (type) {
default:
case NK_PANEL_WINDOW: return style->window.padding;
case NK_PANEL_GROUP: return style->window.group_padding;
case NK_PANEL_POPUP: return style->window.popup_padding;
case ... | cmpl $0x80, %esi
je 0x17502
cmpl $0x4, %esi
je 0x17517
cmpl $0x10, %esi
je 0x17509
cmpl $0x20, %esi
je 0x17510
cmpl $0x40, %esi
je 0x17502
movl $0x1d3c, %eax # imm = 0x1D3C
cmpl $0x2, %esi
jne 0x1751c
movl $0x1d44, %eax # imm = 0x1D44
jmp 0x1751c
movl $0x1d64, %eax # imm = 0x1D64
jmp 0x175... | /wjakob[P]glfw/deps/nuklear.h |
nk_text_calculate_text_bounds | NK_LIB struct nk_vec2
nk_text_calculate_text_bounds(const struct nk_user_font *font,
const char *begin, int byte_len, float row_height, const char **remaining,
struct nk_vec2 *out_offset, int *glyphs, int op)
{
float line_height = row_height;
struct nk_vec2 text_size = nk_vec2(0,0);
float line_width... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x2c0cc
movq %rsi, %r14
testq %rsi, %rsi
je 0x2c0cc
movl %edx, %ebp
testl %edx, %edx
jle 0x2c0cc
movq %r8, %r12
movq %rcx, %rbx
movq %rdi, %r13
movaps %xmm0, 0x60(%rsp)
leaq 0... | /wjakob[P]glfw/deps/nuklear.h |
nk_textedit_move_to_word_next | NK_INTERN int
nk_textedit_move_to_word_next(struct nk_text_edit *state)
{
const int len = state->string.len;
int c = state->cursor+1;
while( c < len && !nk_is_word_boundary(state, c))
++c;
if( c > len )
c = len;
return c;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x90(%rdi), %ebp
movl 0xa8(%rdi), %ebx
movl %ebx, %r15d
leal 0x1(%r15), %ebx
cmpl %ebp, %ebx
jge 0x2c88c
movq %r14, %rdi
movl %ebx, %esi
callq 0x2ca11
testl %eax, %eax
je 0x2c873
cmpl %ebp, %r15d
cmovgel %ebp, %ebx
movl %ebx, %eax
addq $0x8, %r... | /wjakob[P]glfw/deps/nuklear.h |
nk_is_word_boundary | NK_INTERN int
nk_is_word_boundary( struct nk_text_edit *state, int idx)
{
int len;
nk_rune c;
if (idx <= 0) return 1;
if (!nk_str_at_rune(&state->string, idx, &c, &len)) return 1;
return (c == ' ' || c == '\t' ||c == 0x3000 || c == ',' || c == ';' ||
c == '(' || c == ')' || c == '{' || c... | pushq %rbx
subq $0x10, %rsp
pushq $0x1
popq %rbx
testl %esi, %esi
jle 0x2ca67
addq $0x18, %rdi
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %rcx
callq 0x7a58
testq %rax, %rax
je 0x2ca67
movl 0x8(%rsp), %eax
cmpq $0x3b, %rax
ja 0x2ca4f
movabsq $0x800130100000200, %rcx # imm = 0x800130100000200
btq %rax, %rcx
jb 0x2ca67
leal -0x... | /wjakob[P]glfw/deps/nuklear.h |
gladLoadGLUserPtr | int gladLoadGLUserPtr( GLADuserptrloadfunc load, void *userptr) {
int version;
glGetString = (PFNGLGETSTRINGPROC) load("glGetString", userptr);
if(glGetString == NULL) return 0;
if(glGetString(GL_VERSION) == NULL) return 0;
version = glad_gl_find_core_gl();
glad_gl_load_GL_VERSION_1_0(load, us... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x21b70(%rip), %rdi # 0x4e63f
callq *%r15
movq %rax, 0x5b867(%rip) # 0x88340
xorl %ebp, %ebp
testq %rax, %rax
je 0x30a06
movl $0x1f02, %edi # imm = 0x1F02
callq *%rax
testq %rax, %ra... | /wjakob[P]glfw/deps/glad_gl.c |
glfwIsValidContextConfig | GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
{
if (ctxconfig->share)
{
if (ctxconfig->client == GLFW_NO_API ||
ctxconfig->share->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return GLFW_FALSE;
}... | pushq %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x30ae4
cmpl $0x0, (%rdi)
je 0x30b5a
cmpl $0x0, 0x208(%rax)
je 0x30b5a
movl 0x4(%rdi), %edx
leal -0x36001(%rdx), %eax
cmpl $0x3, %eax
jae 0x30b6f
movl (%rdi), %edx
testl %edx, %edx
je 0x30c49
cmpl $0x30001, %edx # imm = 0x30001
je 0x30b89
cmpl $0x30002, %edx... | /wjakob[P]glfw/src/context.c |
glfwSwapBuffers | GLFWAPI void glfwSwapBuffers(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT,
"Cannot swap buffers of a window that h... | testq %rdi, %rdi
je 0x314c6
leaq 0x57e7a(%rip), %rax # 0x89310
cmpl $0x0, (%rax)
je 0x314aa
cmpl $0x0, 0x208(%rdi)
je 0x314b3
jmpq *0x258(%rdi)
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
jmp 0x314bf
leaq 0x2046f(%rip), %rsi # 0x51929
movl $0x1000a, %edi # imm = 0x1000A
xorl %eax, %eax... | /wjakob[P]glfw/src/context.c |
glfwGetKeyName | GLFWAPI const char* glfwGetKeyName(int key, int scancode)
{
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (key != GLFW_KEY_UNKNOWN)
{
if (key != GLFW_KEY_KP_EQUAL &&
(key < GLFW_KEY_KP_0 || key > GLFW_KEY_KP_ADD) &&
(key < GLFW_KEY_APOSTROPHE || key > GLFW_KEY_WORLD_2))
{
... | pushq %rax
leaq 0x57059(%rip), %rax # 0x89310
cmpl $0x0, (%rax)
je 0x322f4
cmpl $-0x1, %edi
je 0x322ec
cmpl $0x150, %edi # imm = 0x150
je 0x322e5
leal -0x14f(%rdi), %eax
cmpl $-0xf, %eax
setb %al
leal -0xa3(%rdi), %ecx
cmpl $-0x7c, %ecx
setb %cl
testb %cl, %al
jne 0x32302
callq 0x3dd03
movl %eax, %esi
mo... | /wjakob[P]glfw/src/input.c |
glfwGetMouseButton | GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (button < GLFW_MOUSE_BUTTON_1 || button > GLFW_MOUSE_BUTTON_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Inval... | pushq %rbx
testq %rdi, %rdi
je 0x3243d
leaq 0x56f26(%rip), %rax # 0x89310
cmpl $0x0, (%rax)
je 0x3240d
movl %esi, %edx
cmpl $0x8, %esi
jb 0x3241f
leaq 0x3aa9d(%rip), %rsi # 0x6ce9a
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x315f3
jmp 0x32439
xorl %ebx, %ebx
movl $0x1000... | /wjakob[P]glfw/src/input.c |
glfwCreateCursor | GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot)
{
_GLFWcursor* cursor;
assert(image != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
cursor = calloc(1, sizeof(_GLFWcursor));
cursor->next = _glfw.cursorListHead;
_glfw.cursorListHead = cursor;
if (!_glfwPlatfo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x32658
leaq 0x56d24(%rip), %r12 # 0x89310
cmpl $0x0, (%r12)
je 0x3263c
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x5340
movq %rax, %rbx
movq 0x400(%r12), %rax
movq %rax, (%rbx)
movq %r... | /wjakob[P]glfw/src/input.c |
glfwGetJoystickAxes | GLFWAPI const float* glfwGetJoystickAxes(int jid, int* count)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputEr... | pushq %rbp
pushq %r14
pushq %rbx
testl %edi, %edi
js 0x32bf8
movl %edi, %ebp
cmpl $0x10, %edi
jae 0x32c17
movq %rsi, %rbx
testq %rsi, %rsi
je 0x32c36
andl $0x0, (%rbx)
leaq 0x5677c(%rip), %r14 # 0x89310
cmpl $0x0, (%r14)
je 0x32be0
callq 0x32b35
testl %eax, %eax
je 0x32bdc
movl %ebp, %eax
imulq $0x2018, %rax, %rax ... | /wjakob[P]glfw/src/input.c |
glfwGetJoystickHats | char* glfwGetJoystickHats(int jid, int* count)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALI... | pushq %rbp
pushq %r14
pushq %rbx
testl %edi, %edi
js 0x32dec
movl %edi, %ebp
cmpl $0x10, %edi
jae 0x32e0b
movq %rsi, %rbx
testq %rsi, %rsi
je 0x32e2a
andl $0x0, (%rbx)
leaq 0x56588(%rip), %r14 # 0x89310
cmpl $0x0, (%r14)
je 0x32dd4
callq 0x32b35
testl %eax, %eax
je 0x32dd0
movl %ebp, %eax
imulq $0x2018, %rax, %rax ... | /wjakob[P]glfw/src/input.c |
glfwGetJoystickGUID | GLFWAPI const char* glfwGetJoystickGUID(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
... | pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x32f86
movl %edi, %ebx
cmpl $0x10, %edi
jae 0x32fa5
leaq 0x563f1(%rip), %r14 # 0x89310
cmpl $0x0, (%r14)
je 0x32f6b
callq 0x32b35
testl %eax, %eax
je 0x32f67
movl %ebx, %eax
imulq $0x2018, %rax, %rax # imm = 0x2018
cmpl $0x0, 0x420(%r14,%rax)
je 0x32f67
addq... | /wjakob[P]glfw/src/input.c |
glfwGetJoystickUserPointer | GLFWAPI void* glfwGetJoystickUserPointer(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
js = _glfw.joysticks + jid;
if (!js->present)
return NULL;
return js->userPointer;
} | pushq %rbx
testl %edi, %edi
js 0x330a0
cmpl $0x10, %edi
jae 0x330bf
leaq 0x562b3(%rip), %rax # 0x89310
cmpl $0x0, (%rax)
je 0x33087
movl %edi, %ecx
imulq $0x2018, %rcx, %rcx # imm = 0x2018
cmpl $0x0, 0x420(%rax,%rcx)
je 0x33099
addq %rcx, %rax
addq $0x420, %rax # imm = 0x420
movq 0xb8(%rax), %rbx
jmp... | /wjakob[P]glfw/src/input.c |
glfwUpdateGamepadMappings | GLFWAPI int glfwUpdateGamepadMappings(const char* string)
{
int jid;
const char* c = string;
assert(string != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
while (*c)
{
if ((*c >= '0' && *c <= '9') ||
(*c >= 'a' && *c <= 'f') ||
(*c >= 'A' && *c <= 'F'))
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x678, %rsp # imm = 0x678
testq %rdi, %rdi
je 0x3381b
leaq 0x561c6(%rip), %r12 # 0x89310
cmpl $0x0, (%r12)
je 0x337f7
movq %rdi, %rbx
leaq 0x3a261(%rip), %r13 # 0x6d3c0
movb (%rbx), %al
testb %al, %al
je 0x337ba
leal -0x30(%rax),... | /wjakob[P]glfw/src/input.c |
glfwJoystickIsGamepad | GLFWAPI int glfwJoystickIsGamepad(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
... | pushq %rbp
pushq %r14
pushq %rbx
testl %edi, %edi
js 0x3391d
movl %edi, %ebp
cmpl $0x10, %edi
jae 0x3393c
leaq 0x55a58(%rip), %r14 # 0x89310
cmpl $0x0, (%r14)
je 0x33906
callq 0x32b35
xorl %ebx, %ebx
testl %eax, %eax
je 0x33916
movl %ebp, %eax
imulq $0x2018, %rax, %rax # imm = 0x2018
cmpl $0x0, 0x420(%r14,%rax)... | /wjakob[P]glfw/src/input.c |
glfwGetGamepadName | GLFWAPI const char* glfwGetGamepadName(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
... | pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x339da
movl %edi, %ebx
cmpl $0x10, %edi
jae 0x339f9
leaq 0x5599b(%rip), %r14 # 0x89310
cmpl $0x0, (%r14)
je 0x339bf
callq 0x32b35
testl %eax, %eax
je 0x339bb
movl %ebx, %eax
imulq $0x2018, %rax, %rax # imm = 0x2018
cmpl $0x0, 0x420(%r14,%rax)
je 0x339bb
addq... | /wjakob[P]glfw/src/input.c |
glfwGetGamepadState | GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state)
{
int i;
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
assert(state != NULL);
memset(state, 0, sizeof(GLFWgamepadstate));
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
if (jid < 0 ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %edi, %edi
js 0x33c66
movl %edi, %ebp
cmpl $0x10, %edi
jae 0x33c85
movq %rsi, %rbx
testq %rsi, %rsi
je 0x33ca4
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movups %xmm0, (%rbx)
leaq 0x558bb(%rip), %r14 # 0x89310
cmpl $0x0, (%r14)
je 0... | /wjakob[P]glfw/src/input.c |
glfwSetTime | GLFWAPI void glfwSetTime(double time)
{
_GLFW_REQUIRE_INIT();
if (time != time || time < 0.0 || time > 18446744073.0)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", time);
return;
}
_glfw.timer.offset = _glfwPlatformGetTimerValue() -
(uint64_t) (time * _glfwPlatfo... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x5554c(%rip), %r14 # 0x89310
cmpl $0x0, (%r14)
je 0x33e4f
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x33e64
ucomisd 0x38ef4(%rip), %xmm0 # 0x6ccd8
ja 0x33e64
movsd %xmm0, (%rsp)
callq 0x3e84b
movq %rax, %rbx
callq 0x3e895
movq %rax, %xmm0
punpckldq 0x38f0b(%rip), %xmm0 # x... | /wjakob[P]glfw/src/input.c |
glfwChooseVideoMode | const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
const GLFWvidmode* desired)
{
int i;
unsigned int sizeDiff, leastSizeDiff = UINT_MAX;
unsigned int rateDiff, leastRateDiff = UINT_MAX;
unsigned int colorDiff, leastColorDiff = UINT_MAX;
const GLFWv... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x342d0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x342c5
movl 0xa0(%r14), %ecx
testl %ecx, %ecx
cmovlel %eax, %ecx
imulq $0x18, %rcx, %rcx
pushq $-0x1
popq %rsi
xorl %edx, %edx
movl %esi, %edi
movl %esi, %r8d
cmpq %r... | /wjakob[P]glfw/src/monitor.c |
refreshVideoModes | static GLFWbool refreshVideoModes(_GLFWmonitor* monitor)
{
int modeCount;
GLFWvidmode* modes;
if (monitor->modes)
return GLFW_TRUE;
modes = _glfwPlatformGetVideoModes(monitor, &modeCount);
if (!modes)
return GLFW_FALSE;
qsort(modes, modeCount, sizeof(GLFWvidmode), compareVideo... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $0x1
popq %rbx
cmpq $0x0, 0x98(%rdi)
jne 0x34334
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
callq 0x39f88
testq %rax, %rax
je 0x34332
movq %rax, %r15
movslq 0xc(%rsp), %rsi
leaq 0x3b(%rip), %rcx # 0x34342
pushq $0x18
popq %rdx
movq %rax, %rdi
callq 0x52c0
movq 0x... | /wjakob[P]glfw/src/monitor.c |
glfwSplitBPP | void _glfwSplitBPP(int bpp, int* red, int* green, int* blue)
{
int delta;
// We assume that by 32 the user really meant 24
if (bpp == 32)
bpp = 24;
// Convert "bits per pixel" to red, green & blue sizes
*red = *green = *blue = bpp / 3;
delta = bpp - (*red * 3);
if (delta >= 1)
... | movq %rdx, %r8
cmpl $0x20, %edi
pushq $0x18
popq %r9
cmovnel %edi, %r9d
pushq $0x3
popq %rdi
movl %r9d, %eax
cltd
idivl %edi
movl %eax, (%rcx)
movl %eax, (%r8)
movl %eax, (%rsi)
imull $-0x3, %eax, %eax
addl %r9d, %eax
testl %eax, %eax
jle 0x343af
incl (%r8)
cmpl $0x2, %eax
jne 0x343af
incl (%rsi)
retq
| /wjakob[P]glfw/src/monitor.c |
glfwGetMonitorPos | GLFWAPI void glfwGetMonitorPos(GLFWmonitor* handle, int* xpos, int* ypos)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (xpos)
*xpos = 0;
if (ypos)
*ypos = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetMonitorPos(monitor, xpos, ypos);
} | testq %rdi, %rdi
je 0x34479
testq %rsi, %rsi
je 0x34452
andl $0x0, (%rsi)
testq %rdx, %rdx
je 0x3445a
andl $0x0, (%rdx)
leaq 0x54eaf(%rip), %rax # 0x89310
cmpl $0x0, (%rax)
je 0x3446b
jmp 0x39c03
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x315f3
pushq %rax
leaq 0x3911d(%rip), ... | /wjakob[P]glfw/src/monitor.c |
updateCursorImage | static void updateCursorImage(_GLFWwindow* window)
{
if (window->cursorMode == GLFW_CURSOR_NORMAL)
{
if (window->cursor)
{
XDefineCursor(_glfw.x11.display, window->x11.handle,
window->cursor->x11.handle);
}
else
XUndefineCursor(_g... | cmpl $0x34001, 0x84(%rdi) # imm = 0x34001
jne 0x3db86
movq 0x58(%rdi), %rcx
leaq 0x4b7ae(%rip), %rdx # 0x89310
movq 0x20658(%rdx), %rax
movq 0x358(%rdi), %rsi
testq %rcx, %rcx
je 0x3dbab
movq 0x21470(%rdx), %r8
movq 0x8(%rcx), %rdx
movq %rax, %rdi
jmpq *%r8
leaq 0x4b783(%rip), %rax # 0x89310
movq 0x21470(%ra... | /wjakob[P]glfw/src/x11_window.c |
google::protobuf::FileDescriptorTables::BuildLocationsByPath(std::pair<google::protobuf::FileDescriptorTables const*, google::protobuf::SourceCodeInfo const*>*) | void FileDescriptorTables::BuildLocationsByPath(
std::pair<const FileDescriptorTables*, const SourceCodeInfo*>* p) {
for (int i = 0, len = p->second->location_size(); i < len; ++i) {
const SourceCodeInfo_Location* loc = &p->second->location().Get(i);
p->first->locations_by_path_[absl::StrJoin(loc->path(),... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xba6e0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x50855
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xba700
movq %rax, %rdi
movl -0xc(%rbp), %esi
... | /protocolbuffers[P]protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::FieldDescriptor::FieldTypeNameDebugString[abi:cxx11]() const | std::string FieldDescriptor::FieldTypeNameDebugString() const {
switch (type()) {
case TYPE_MESSAGE:
case TYPE_GROUP:
if (IsGroupSyntax(file()->edition(), this)) {
return kTypeToName[type()];
}
return absl::StrCat(".", message_type()->full_name());
case TYPE_ENUM:
return ab... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x128(%rbp)
movq %rdi, %rax
movq %rax, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x1f470
movl %eax, %ecx
movl %ecx, %eax
addl $-0xa, %eax
movl %ecx, -0x110(%rbp)
subl $0... | /protocolbuffers[P]protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorBuilder::BuildMessage(google::protobuf::DescriptorProto const&, google::protobuf::Descriptor const*, google::protobuf::Descriptor*, google::protobuf::internal::FlatAllocator&) | void DescriptorBuilder::BuildMessage(const DescriptorProto& proto,
const Descriptor* parent,
Descriptor* result,
internal::FlatAllocator& alloc) {
const absl::string_view scope =
(parent == nullptr) ? ... | pushq %rbp
movq %rsp, %rbp
subq $0x660, %rsp # imm = 0x660
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x368(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x66b0e
movq -0x368(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0xbd... | /protocolbuffers[P]protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorBuilder::AllocateNameStrings(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, google::protobuf::Message const&, google::protobuf::internal::FlatAllocator&) | auto DescriptorBuilder::AllocateNameStrings(const absl::string_view scope,
const absl::string_view proto_name,
const Message& entity,
internal::FlatAllocator& alloc) {
if (auto names = a... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq 0x10(%rbp), %rax
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
movq %rdi, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x198(%rbp)
movq 0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
... | /protocolbuffers[P]protobuf/src/google/protobuf/descriptor.cc |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const** google::protobuf::(anonymous namespace)::FlatAllocatorImpl<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, google::protobuf::SourceCodeInfo, google::protobuf::FileDescriptorTables, google::protob... | U* AllocateArray(int array_size) {
constexpr bool trivial = std::is_trivially_destructible<U>::value;
using TypeToUse = typename std::conditional<trivial, char, U>::type;
// We can only allocate after FinalizePlanning has been called.
ABSL_CHECK(has_allocated());
TypeToUse*& data = pointers_.templ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movb $0x1, -0xd(%rbp)
callq 0x86a10
xorb $-0x1, %al
movb $0x0, -0x21(%rbp)
testb $0x1, %al
jne 0x6bedc
jmp 0x6bf11
leaq -0x20(%rbp), %rdi
leaq 0x4377e9(%rip), %rsi # 0x4a36d0
movl $0x1... | /protocolbuffers[P]protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorBuilder::CheckEnumValueUniqueness(google::protobuf::EnumDescriptorProto const&, google::protobuf::EnumDescriptor const*) | void DescriptorBuilder::CheckEnumValueUniqueness(
const EnumDescriptorProto& proto, const EnumDescriptor* result) {
// Check that enum labels are still unique when we remove the enum prefix from
// values that have it.
//
// This will fail for something like:
//
// enum MyEnum {
// MY_ENUM_FOO ... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x170(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbe5f0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0... | /protocolbuffers[P]protobuf/src/google/protobuf/descriptor.cc |
absl::lts_20250127::container_internal::raw_hash_set<absl::lts_20250127::container_internal::FlatHashSetPolicy<google::protobuf::FieldDescriptor const*>, google::protobuf::(anonymous namespace)::ParentNumberHash, google::protobuf::(anonymous namespace)::ParentNumberEq, std::allocator<google::protobuf::FieldDescriptor c... | iterator find_non_soo(const key_arg<K>& key, size_t hash) {
ABSL_SWISSTABLE_ASSERT(!is_soo());
auto seq = probe(common(), hash);
const ctrl_t* ctrl = control();
while (true) {
Group g{ctrl + seq.offset()};
for (uint32_t i : g.Match(H2(hash))) {
if (ABSL_PREDICT_TRUE(PolicyTraits::app... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x7ee10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x8b(%rbp)
jne 0x82460
movb $0x1, %al
movb %al, -0x8b(%rbp)
jmp 0x82460
movb -0x8b(%rbp), ... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/raw_hash_set.h |
std::conditional<std::is_const<char const>::value, std::tuple_element<2ul, std::tuple<absl::lts_20250127::container_internal::btree_node<absl::lts_20250127::container_internal::set_params<std::pair<long, long>, std::less<std::pair<long, long>>, std::allocator<std::pair<long, long>>, 256, false>>*, unsigned int, unsigne... | CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
using C = typename std::remove_const<Char>::type;
static_assert(
std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
std::is_same<C, signed char>(),
"The argument must be a pointer to [const] [signed|unsigned] char"... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x8, -0x18(%rbp)
movq -0x10(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0xee830
jmp 0xee84f
leaq 0x3aeedb(%rip), %rdi # 0x49d712
leaq 0x3aef04(%rip), %rsi # 0x49d742
movl... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/layout.h |
absl::lts_20250127::container_internal::raw_hash_set<absl::lts_20250127::container_internal::FlatHashSetPolicy<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, absl::lts_20250127::container_internal::StringHash, absl::lts_20250127::container_internal::StringEq, std::allocator<std::__cxx1... | void reserve(size_t n) {
const size_t max_size_before_growth =
is_soo() ? SooCapacity() : size() + growth_left();
if (n > max_size_before_growth) {
if (ABSL_PREDICT_FALSE(n > max_size())) {
HashTableSizeOverflow();
}
size_t m = GrowthToLowerboundCapacity(n);
resize(Normal... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xcb270
testb $0x1, %al
jne 0xefb03
jmp 0xefb0e
callq 0x45c40
movq %rax, -0x38(%rbp)
jmp 0xefb32
movq -0x30(%rbp), %rdi
callq 0xefc50
movq -0x30(%rbp), %rdi
movq %rax, -0x40(%rbp)
... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/raw_hash_set.h |
std::pair<absl::lts_20250127::container_internal::raw_hash_set<absl::lts_20250127::container_internal::FlatHashSetPolicy<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, absl::lts_20250127::container_internal::StringHash, absl::lts_20250127::container_internal::StringEq, std::allocator<s... | std::pair<iterator, bool> find_or_prepare_insert_soo(const K& key) {
if (empty()) {
const HashtablezInfoHandle infoz = try_sample_soo();
if (infoz.IsSampled()) {
resize_with_soo_infoz(infoz);
} else {
common().set_full_soo();
return {soo_iterator(), true};
}
} els... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, -0x98(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xb89f0
testb $0x1, %al
jne 0xf00e7
jmp 0xf015a
movq -0x90(%rbp), %rdi
callq 0xd6ab0
leaq -0x11(%rbp), %rdi
callq 0x46e40
testb $0x1, ... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/raw_hash_set.h |
void absl::lts_20250127::container_internal::HashSetResizeHelper::GrowSizeIntoSingleGroup<absl::lts_20250127::container_internal::hash_policy_traits<absl::lts_20250127::container_internal::FlatHashMapPolicy<std::pair<void const*, std::basic_string_view<char, std::char_traits<char>>>, google::protobuf::FieldDescriptor c... | void GrowSizeIntoSingleGroup(CommonFields& c, Alloc& alloc_ref) {
ABSL_SWISSTABLE_ASSERT(old_capacity_ < Group::kWidth / 2);
ABSL_SWISSTABLE_ASSERT(
IsGrowingIntoSingleGroupApplicable(old_capacity_, c.capacity()));
using slot_type = typename PolicyTraits::slot_type;
ABSL_SWISSTABLE_ASSERT(is_sin... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x48(%rbp)
xorl %eax, %eax
cmpq $0x8, 0x10(%rcx)
movb %al, -0x39(%rbp)
jae 0x10125f
movb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x10125f
movb -0x39(%rbp), %al
testb $0x1, %al
jn... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/raw_hash_set.h |
absl::lts_20250127::container_internal::raw_hash_set<absl::lts_20250127::container_internal::FlatHashMapPolicy<std::pair<void const*, void const*>, std::unique_ptr<google::protobuf::DescriptorPool::MemoBase, std::default_delete<google::protobuf::DescriptorPool::MemoBase>>>, absl::lts_20250127::hash_internal::Hash<std::... | inline void destroy_slots() {
ABSL_SWISSTABLE_ASSERT(!is_soo());
if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
IterateOverFullSlots(
common(), slot_array(),
[&](const ctrl_t*, slot_type* slot)
ABSL_ATTRIBUTE_ALWAYS_INLINE { this->destroy(slot); });
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xd0(%rbp)
movq -0xd0(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x10c820
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xd9(%rbp)
jne 0x10c97e
movb $0x1, %al
movb %al, -0xd9(%rbp)
jmp 0x10c97e
movb -0xd9(%rbp), %al
testb $0x1, %... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/raw_hash_set.h |
absl::lts_20250127::container_internal::raw_hash_set<absl::lts_20250127::container_internal::FlatHashMapPolicy<std::pair<void const*, void const*>, std::unique_ptr<google::protobuf::DescriptorPool::MemoBase, std::default_delete<google::protobuf::DescriptorPool::MemoBase>>>, absl::lts_20250127::hash_internal::Hash<std::... | inline void dealloc() {
ABSL_SWISSTABLE_ASSERT(capacity() != 0);
// Unpoison before returning the memory to the allocator.
SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
infoz().Unregister();
Deallocate<BackingArrayAlignment(alignof(slot_type))>(
&alloc_ref(), c... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x10c7c0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0xb(%rbp)
je 0x10cdae
movb $0x1, %al
movb %al, -0xb(%rbp)
jmp 0x10cdae
movb -0xb(%rbp), %al
testb $0x1, %al
jne 0x10cdb7
jmp 0x10cdb9
j... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/raw_hash_set.h |
absl::lts_20250127::container_internal::raw_hash_set<absl::lts_20250127::container_internal::FlatHashMapPolicy<std::pair<void const*, void const*>, std::unique_ptr<google::protobuf::DescriptorPool::MemoBase, std::default_delete<google::protobuf::DescriptorPool::MemoBase>>>, absl::lts_20250127::hash_internal::Hash<std::... | void AssertNotDebugCapacity() const {
if (ABSL_PREDICT_TRUE(capacity() <
InvalidCapacity::kAboveMaxValidCapacity)) {
return;
}
assert(capacity() != InvalidCapacity::kReentrance &&
"Reentrant container access during element construction/destruction "
"is ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x10c7c0
cmpq $-0x65, %rax
jae 0x10cf14
jmp 0x10cfa4
movq -0x10(%rbp), %rdi
callq 0x10c7c0
movq %rax, %rcx
xorl %eax, %eax
cmpq $-0x64, %rcx
movb %al, -0x11(%rbp)
je 0x10cf32
movb $0x1, %al
movb %al, -0x... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/raw_hash_set.h |
void absl::lts_20250127::container_internal::HashSetResizeHelper::GrowSizeIntoSingleGroup<absl::lts_20250127::container_internal::hash_policy_traits<absl::lts_20250127::container_internal::FlatHashMapPolicy<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool>, void>, std::allocator<std:... | void GrowSizeIntoSingleGroup(CommonFields& c, Alloc& alloc_ref) {
ABSL_SWISSTABLE_ASSERT(old_capacity_ < Group::kWidth / 2);
ABSL_SWISSTABLE_ASSERT(
IsGrowingIntoSingleGroupApplicable(old_capacity_, c.capacity()));
using slot_type = typename PolicyTraits::slot_type;
ABSL_SWISSTABLE_ASSERT(is_sin... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x48(%rbp)
xorl %eax, %eax
cmpq $0x8, 0x10(%rcx)
movb %al, -0x39(%rbp)
jae 0x10eccf
movb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x10eccf
movb -0x39(%rbp), %al
testb $0x1, %al
jn... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/raw_hash_set.h |
void absl::lts_20250127::container_internal::CommonFields::RunWithReentrancyGuard<absl::lts_20250127::container_internal::raw_hash_set<absl::lts_20250127::container_internal::FlatHashMapPolicy<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool>, absl::lts_20250127::container_internal::... | void RunWithReentrancyGuard(F f) {
#ifdef NDEBUG
f();
return;
#endif
const size_t cap = capacity();
set_capacity(InvalidCapacity::kReentrance);
f();
set_capacity(cap);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x46d00
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq $-0x64, %rsi
callq 0x477c0
movq -0x20(%rbp), %rdi
callq 0x10f100
movq -0x18(%rbp), %rdi
movq -0x10(... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/raw_hash_set.h |
auto absl::lts_20250127::container_internal::map_slot_policy<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool>::transfer<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>>(std::allocator<std::pair<std::__cxx11::basic... | static auto transfer(Allocator* alloc, slot_type* new_slot,
slot_type* old_slot) {
auto is_relocatable =
typename absl::is_trivially_relocatable<value_type>::type();
emplace(new_slot);
#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
if (is_relocatable) {
/... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x19(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x1d4a0
movq -0x10(%rbp), %rdi
callq 0x10f230
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10f250
movq -0x8(%rbp), %... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/container_memory.h |
absl::lts_20250127::container_internal::raw_hash_set<absl::lts_20250127::container_internal::FlatHashMapPolicy<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool>, absl::lts_20250127::container_internal::StringHash, absl::lts_20250127::container_internal::StringEq, std::allocator<std::... | static const PolicyFunctions& GetPolicyFunctions() {
static constexpr PolicyFunctions value = {
sizeof(slot_type),
// TODO(b/328722020): try to type erase
// for standard layout and alignof(Hash) <= alignof(CommonFields).
std::is_empty<hasher>::value ? &GetHashRefForEmptyHasher
... | pushq %rbp
movq %rsp, %rbp
leaq 0x637495(%rip), %rax # 0x7467a0
popq %rbp
retq
nopl (%rax)
| /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/raw_hash_set.h |
void absl::lts_20250127::container_internal::CommonFields::RunWithReentrancyGuard<void absl::lts_20250127::container_internal::raw_hash_set<absl::lts_20250127::container_internal::FlatHashMapPolicy<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool>, absl::lts_20250127::container_inter... | void RunWithReentrancyGuard(F f) {
#ifdef NDEBUG
f();
return;
#endif
const size_t cap = capacity();
set_capacity(InvalidCapacity::kReentrance);
f();
set_capacity(cap);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x46d00
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq $-0x64, %rsi
callq 0x477c0
movq -0x20(%rbp), %rdi
callq 0x10f4f0
movq -0x18(%rbp), %rdi
movq -0x10(... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/raw_hash_set.h |
void absl::lts_20250127::container_internal::map_slot_policy<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool>::construct<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>, std::piecewise_construct_t const&, std::tup... | static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
emplace(slot);
if (kMutableKeys::value) {
absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
std::forward<Args>(args)...);
} else {
absl::allocato... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10f230
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x10f6... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/container_memory.h |
absl::lts_20250127::container_internal::btree_node<absl::lts_20250127::container_internal::set_params<google::protobuf::Edition, std::less<google::protobuf::Edition>, std::allocator<google::protobuf::Edition>, 256, false>>::init_internal(unsigned char, absl::lts_20250127::container_internal::btree_node<absl::lts_202501... | void init_internal(field_type position, btree_node *parent) {
init_leaf(position, kNodeSlots, parent);
// Set `max_count` to a sentinel value to indicate that this node is
// internal.
set_max_count(kInternalNodeMaxCount);
absl::container_internal::SanitizerPoisonMemoryRegion(
&mutable_child... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb -0x9(%rbp), %al
movq -0x18(%rbp), %rcx
movl $0x3d, %edx
movzbl %al, %esi
callq 0x1f3ae0
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x1f40c0
mov... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/container/internal/btree.h |
google::protobuf::Reflection::SetString(google::protobuf::Message*, google::protobuf::FieldDescriptor const*, absl::lts_20250127::Cord const&) const | void Reflection::SetString(Message* message, const FieldDescriptor* field,
const absl::Cord& value) const {
USAGE_MUTABLE_CHECK_ALL(SetString, SINGULAR, STRING);
if (field->is_extension()) {
return absl::CopyCordToString(value,
MutableExtensionSet(mes... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e390
movq %rax, %rcx
movq -0xf0(%rbp), %rax
cmpq %rcx, %rax
je 0x208882
movq -0xf0... | /protocolbuffers[P]protobuf/src/google/protobuf/generated_message_reflection.cc |
google::protobuf::Reflection::UnsafeArenaReleaseMessage(google::protobuf::Message*, google::protobuf::FieldDescriptor const*, google::protobuf::MessageFactory*) const | Message* Reflection::UnsafeArenaReleaseMessage(Message* message,
const FieldDescriptor* field,
MessageFactory* factory) const {
USAGE_MUTABLE_CHECK_ALL(ReleaseMessage, SINGULAR, MESSAGE);
if (factory == nullptr) factory =... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e390
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0x20b340
movq -0x40(%rbp), %rax
movq (%rax)... | /protocolbuffers[P]protobuf/src/google/protobuf/generated_message_reflection.cc |
google::protobuf::Reflection::UnsafeArenaAddAllocatedMessage(google::protobuf::Message*, google::protobuf::FieldDescriptor const*, google::protobuf::Message*) const | void Reflection::UnsafeArenaAddAllocatedMessage(Message* message,
const FieldDescriptor* field,
Message* new_entry) const {
USAGE_MUTABLE_CHECK_ALL(UnsafeArenaAddAllocatedMessage, REPEATED, MESSAGE);
if (field->is_exten... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e390
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x20bc90
movq -0x30(%rbp), %rax
movq (%rax), ... | /protocolbuffers[P]protobuf/src/google/protobuf/generated_message_reflection.cc |
google::protobuf::PopulateTcParseLookupTable(google::protobuf::internal::TailCallTableInfo const&, unsigned short*) | static void PopulateTcParseLookupTable(
const internal::TailCallTableInfo& table_info, uint16_t* lookup_table) {
for (const auto& entry_block : table_info.num_to_entry_table.blocks) {
*lookup_table++ = entry_block.first_fnum & 0xFFFF;
*lookup_table++ = entry_block.first_fnum >> 16;
*lookup_table++ = e... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22e180
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22e1b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x... | /protocolbuffers[P]protobuf/src/google/protobuf/generated_message_reflection.cc |
void google::protobuf::internal::MapDynamicFieldVisitKey<google::protobuf::MapValueRef, auto void google::protobuf::internal::ReflectionVisit::VisitMessageFields<google::protobuf::Reflection::MaybePoisonAfterClear(google::protobuf::Message&) const::$_0>(google::protobuf::Message&, google::protobuf::Reflection::MaybePoi... | void MapDynamicFieldVisitKey(const MapKey& key, MapValueRefT& value,
const MapFieldCallback& user_cb) {
switch (key.type()) {
#define PROTOBUF_HANDLE_MAP_KEY_CASE(NAME, CPPTYPE) \
case FieldDescriptor::CPPTYPE_##CPPTYPE: { \
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2469f0
decl %eax
movl %eax, %ecx
movq %rcx, -0xb0(%rbp)
subl $0x8, %eax
ja 0x214237
movq -0xb0(%rbp), %rax
leaq 0x3525c2(%rip), %rcx # 0x5666c4
movslq (%rcx,%rax,4), %rax
addq... | /protocolbuffers[P]protobuf/src/google/protobuf/reflection_visit_field_info.h |
google::protobuf::RepeatedField<unsigned long>::Swap(google::protobuf::RepeatedField<unsigned long>*) | void RepeatedField<Element>::Swap(RepeatedField* other) {
if (this == other) return;
Arena* arena = GetArena();
Arena* other_arena = other->GetArena();
if (internal::CanUseInternalSwap(arena, other_arena)) {
InternalSwap(other);
} else {
RepeatedField<Element> temp(other_arena);
temp.MergeFrom(*th... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq -0x10(%rbp), %rax
jne 0x21ed93
jmp 0x21ee2f
movq -0x48(%rbp), %rdi
callq 0x1dabe0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dabe0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp... | /protocolbuffers[P]protobuf/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::SwapFieldHelper::SwapStringField<true>(google::protobuf::Reflection const*, google::protobuf::Message*, google::protobuf::Message*, google::protobuf::FieldDescriptor const*) | void SwapFieldHelper::SwapStringField(const Reflection* r, Message* lhs,
Message* rhs,
const FieldDescriptor* field) {
switch (field->cpp_string_type()) {
case FieldDescriptor::CppStringType::kCord:
// Always shallow swap for Cord.
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5d200
movl %eax, %ecx
movl %ecx, -0x44(%rbp)
subl $0x1, %eax
je 0x21f59b
jmp 0x21f54d
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0x21f564
jmp 0x21f557
movl... | /protocolbuffers[P]protobuf/src/google/protobuf/generated_message_reflection.cc |
void google::protobuf::internal::SwapFieldHelper::SwapRepeatedMessageField<true>(google::protobuf::Reflection const*, google::protobuf::Message*, google::protobuf::Message*, google::protobuf::FieldDescriptor const*) | void SwapFieldHelper::SwapRepeatedMessageField(const Reflection* r,
Message* lhs, Message* rhs,
const FieldDescriptor* field) {
if (IsMapFieldInApi(field)) {
auto* lhs_map = r->MutableRaw<MapFieldBase>(lhs, field);
a... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2004b0
testb $0x1, %al
jne 0x21fce7
jmp 0x21fd20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x220540
movq %rax, -0x28(%rbp)... | /protocolbuffers[P]protobuf/src/google/protobuf/generated_message_reflection.cc |
google::protobuf::Reflection::ScratchSpace::CopyFromCord(absl::lts_20250127::Cord const&) | absl::string_view CopyFromCord(const absl::Cord& cord) {
if (absl::optional<absl::string_view> flat = cord.TryFlat()) {
return *flat;
}
if (!buffer_) {
buffer_ = absl::make_unique<std::string>();
}
absl::CopyCordToString(cord, buffer_.get());
return *buffer_;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2268f0
leaq -0x38(%rbp), %rdi
callq 0x226990
testb $0x1, %al
jne 0x221904
jmp 0x22191e
leaq -0x38(%rbp), %rdi
callq 0x2269b0
movq ... | /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
google::protobuf::AssignDescriptorsHelper::AssignMessageDescriptor(google::protobuf::Descriptor const*) | void AssignMessageDescriptor(const Descriptor* descriptor) {
for (int i = 0; i < descriptor->nested_type_count(); i++) {
AssignMessageDescriptor(descriptor->nested_type(i));
}
// If there is no default instance we only want to initialize the descriptor
// without updating the reflection.
if (... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbda00
movl %eax, %ecx
movl -0x8c(%rbp), %eax
cmpl %ecx, %eax
jge 0x22f239
movq -0x10(%... | /protocolbuffers[P]protobuf/src/google/protobuf/generated_message_reflection.cc |
void google::protobuf::Reflection::VerifyFieldType<google::protobuf::RepeatedField<unsigned int>>(google::protobuf::FieldDescriptor const*) const | void Reflection::VerifyFieldType(const FieldDescriptor* field) const {
if constexpr (!internal::PerformDebugChecks()) {
return;
}
if constexpr (std::is_const_v<T>) {
return VerifyFieldType<std::remove_const_t<T>>(field);
}
// `char` and `void` are used in places where we don't know the type yet.
if... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e580
andb $0x1, %al
movb %al, -0x21(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x401d0
movq %rax, -0xb0(%rbp)
leaq 0x33a7f1(%rip), %rdi # 0x56b6d1
callq 0x230... | /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
google::protobuf::internal::FieldDescriptorLite::CppType google::protobuf::internal::GetCppType<float>() | constexpr FieldDescriptor::CppType GetCppType() {
if constexpr (IsRepeatedT<T>) {
return GetCppType<typename T::value_type>();
} else {
if (std::is_same_v<T, int32_t>) return FieldDescriptor::CPPTYPE_INT32;
if (std::is_same_v<T, int64_t>) return FieldDescriptor::CPPTYPE_INT64;
if (std::is_same_v<T, ... | pushq %rbp
movq %rsp, %rbp
movl $0x6, %eax
popq %rbp
retq
nopl (%rax,%rax)
| /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
bool google::protobuf::internal::SplitFieldHasExtraIndirectionStatic<google::protobuf::internal::RepeatedPtrFieldBase>(google::protobuf::FieldDescriptor const*) | bool SplitFieldHasExtraIndirectionStatic(const FieldDescriptor* field) {
if (std::is_base_of<RepeatedFieldBase, T>() ||
std::is_base_of<RepeatedPtrFieldBase, T>()) {
ABSL_DCHECK(SplitFieldHasExtraIndirection(field));
return true;
} else if (std::is_base_of<MessageLite, T>()) {
ABSL_DCHECK(!SplitFi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20ccc0
xorb $-0x1, %al
movb $0x0, -0x21(%rbp)
testb $0x1, %al
jne 0x234951
jmp 0x234986
leaq -0x20(%rbp), %rdi
leaq 0x32b229(%rip), %rsi # 0x55fb85
movl $0x65c, %edx # imm = 0x65C
leaq 0x3365db(%rip), %rcx #... | /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
void google::protobuf::Reflection::VerifyFieldType<absl::lts_20250127::Cord*>(google::protobuf::FieldDescriptor const*) const | void Reflection::VerifyFieldType(const FieldDescriptor* field) const {
if constexpr (!internal::PerformDebugChecks()) {
return;
}
if constexpr (std::is_const_v<T>) {
return VerifyFieldType<std::remove_const_t<T>>(field);
}
// `char` and `void` are used in places where we don't know the type yet.
if... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e580
andb $0x1, %al
movb %al, -0x21(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x401d0
mo... | /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
bool google::protobuf::internal::SplitFieldHasExtraIndirectionStatic<absl::lts_20250127::Cord*>(google::protobuf::FieldDescriptor const*) | bool SplitFieldHasExtraIndirectionStatic(const FieldDescriptor* field) {
if (std::is_base_of<RepeatedFieldBase, T>() ||
std::is_base_of<RepeatedPtrFieldBase, T>()) {
ABSL_DCHECK(SplitFieldHasExtraIndirection(field));
return true;
} else if (std::is_base_of<MessageLite, T>()) {
ABSL_DCHECK(!SplitFi... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20ccc0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
void google::protobuf::Reflection::VerifyFieldType<google::protobuf::internal::InlinedStringField>(google::protobuf::FieldDescriptor const*) const | void Reflection::VerifyFieldType(const FieldDescriptor* field) const {
if constexpr (!internal::PerformDebugChecks()) {
return;
}
if constexpr (std::is_const_v<T>) {
return VerifyFieldType<std::remove_const_t<T>>(field);
}
// `char` and `void` are used in places where we don't know the type yet.
if... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e580
andb $0x1, %al
movb %al, -0x21(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x401d0
movq %rax, -0xb0(%rbp)
leaq 0x335822(%rip), %rdi # 0x56bac2
callq 0x235... | /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
google::protobuf::internal::FieldDescriptorLite::CppType google::protobuf::internal::GetCppType<google::protobuf::internal::InlinedStringField>() | constexpr FieldDescriptor::CppType GetCppType() {
if constexpr (IsRepeatedT<T>) {
return GetCppType<typename T::value_type>();
} else {
if (std::is_same_v<T, int32_t>) return FieldDescriptor::CPPTYPE_INT32;
if (std::is_same_v<T, int64_t>) return FieldDescriptor::CPPTYPE_INT64;
if (std::is_same_v<T, ... | pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
| /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
bool google::protobuf::internal::SplitFieldHasExtraIndirectionStatic<google::protobuf::internal::InlinedStringField>(google::protobuf::FieldDescriptor const*) | bool SplitFieldHasExtraIndirectionStatic(const FieldDescriptor* field) {
if (std::is_base_of<RepeatedFieldBase, T>() ||
std::is_base_of<RepeatedPtrFieldBase, T>()) {
ABSL_DCHECK(SplitFieldHasExtraIndirection(field));
return true;
} else if (std::is_base_of<MessageLite, T>()) {
ABSL_DCHECK(!SplitFi... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20ccc0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
google::protobuf::internal::FieldDescriptorLite::CppType google::protobuf::internal::GetCppType<google::protobuf::internal::MicroString>() | constexpr FieldDescriptor::CppType GetCppType() {
if constexpr (IsRepeatedT<T>) {
return GetCppType<typename T::value_type>();
} else {
if (std::is_same_v<T, int32_t>) return FieldDescriptor::CPPTYPE_INT32;
if (std::is_same_v<T, int64_t>) return FieldDescriptor::CPPTYPE_INT64;
if (std::is_same_v<T, ... | pushq %rbp
movq %rsp, %rbp
movl $0x9, %eax
popq %rbp
retq
nopl (%rax,%rax)
| /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
google::protobuf::internal::FieldDescriptorLite::CppType google::protobuf::internal::GetCppType<google::protobuf::internal::ArenaStringPtr>() | constexpr FieldDescriptor::CppType GetCppType() {
if constexpr (IsRepeatedT<T>) {
return GetCppType<typename T::value_type>();
} else {
if (std::is_same_v<T, int32_t>) return FieldDescriptor::CPPTYPE_INT32;
if (std::is_same_v<T, int64_t>) return FieldDescriptor::CPPTYPE_INT64;
if (std::is_same_v<T, ... | pushq %rbp
movq %rsp, %rbp
movl $0x9, %eax
popq %rbp
retq
nopl (%rax,%rax)
| /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
bool google::protobuf::internal::SplitFieldHasExtraIndirectionStatic<google::protobuf::Message const*>(google::protobuf::FieldDescriptor const*) | bool SplitFieldHasExtraIndirectionStatic(const FieldDescriptor* field) {
if (std::is_base_of<RepeatedFieldBase, T>() ||
std::is_base_of<RepeatedPtrFieldBase, T>()) {
ABSL_DCHECK(SplitFieldHasExtraIndirection(field));
return true;
} else if (std::is_base_of<MessageLite, T>()) {
ABSL_DCHECK(!SplitFi... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20ccc0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
void google::protobuf::Reflection::VerifyFieldType<unsigned int>(google::protobuf::FieldDescriptor const*) const | void Reflection::VerifyFieldType(const FieldDescriptor* field) const {
if constexpr (!internal::PerformDebugChecks()) {
return;
}
if constexpr (std::is_const_v<T>) {
return VerifyFieldType<std::remove_const_t<T>>(field);
}
// `char` and `void` are used in places where we don't know the type yet.
if... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e580
andb $0x1, %al
movb %al, -0x21(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x401d0
movq %rax, -0xb0(%rbp)
leaq 0x332d77(%rip), %rdi # 0x56bb87
callq 0x235... | /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
void google::protobuf::Reflection::VerifyFieldType<unsigned long>(google::protobuf::FieldDescriptor const*) const | void Reflection::VerifyFieldType(const FieldDescriptor* field) const {
if constexpr (!internal::PerformDebugChecks()) {
return;
}
if constexpr (std::is_const_v<T>) {
return VerifyFieldType<std::remove_const_t<T>>(field);
}
// `char` and `void` are used in places where we don't know the type yet.
if... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e580
andb $0x1, %al
movb %al, -0x21(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x401d0
movq %rax, -0xb0(%rbp)
leaq 0x332a58(%rip), %rdi # 0x56bb88
callq 0x235... | /protocolbuffers[P]protobuf/src/google/protobuf/message.h |
google::protobuf::io::(anonymous namespace)::CommentCollector::GetBufferForLineComment[abi:cxx11]() | std::string* GetBufferForLineComment() {
// We want to combine with previous line comments, but not block comments.
if (has_comment_ && !is_line_comment_) {
Flush();
}
has_comment_ = true;
is_line_comment_ = true;
return &comment_buffer_;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x3d(%rax)
je 0x2ec10d
movq -0x10(%rbp), %rax
testb $0x1, 0x3e(%rax)
jne 0x2ec10d
movq -0x10(%rbp), %rdi
callq 0x2ec130
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movb $0x1, 0x3e(%rax)
addq $0x18... | /protocolbuffers[P]protobuf/src/google/protobuf/io/tokenizer.cc |
google::protobuf::io::Tokenizer::ParseInteger(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long*) | bool Tokenizer::ParseInteger(const std::string& text, uint64_t max_value,
uint64_t* output) {
// We can't just use strtoull() because (a) it accepts negative numbers,
// (b) We want additional range checks, (c) it reports overflows via errno.
#if 0
const char *str_begin = text.c_str(... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d1b0
movq %rax, -0x28(%rbp)
movl $0xa, -0x2c(%rbp)
movabsq $0x199999999999999a, %rax # imm = 0x199999999999999A
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %e... | /protocolbuffers[P]protobuf/src/google/protobuf/io/tokenizer.cc |
absl::lts_20250127::CordBuffer::IncreaseLengthBy(unsigned long) | inline void CordBuffer::IncreaseLengthBy(size_t n) {
ABSL_HARDENING_ASSERT(n <= capacity() && length() + n <= capacity());
if (rep_.is_short()) {
rep_.add_short_length(n);
} else {
rep_.rep()->length += n;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2effb0
movq -0x20(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x12(%rbp)
ja 0x2efef0
movq -0x28(%rbp), %r... | /protocolbuffers[P]protobuf/build_O0/_deps/absl-src/absl/strings/cord_buffer.h |
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.