name string | code string | asm string | file string |
|---|---|---|---|
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());
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, (%rsp)
movq %rdi, %r14
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xd54dc
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xd55a0
movq %r15, %rdi
movq %r12, %rsi
callq 0xd3720
testb %al, %al
jne 0x... | /ggerganov[P]llama/common/chat.cpp |
expect_tool_parameters(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 long, double, st... | static void expect_tool_parameters(const std::string & name, const json & parameters, const std::vector<std::string> & expected_properties) {
if (!parameters.is_object() || !parameters.contains("type") || parameters.at("type") != "object" || !parameters.contains("properties") || !parameters.contains("required")) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x48(%rsp)
cmpb $0x1, (%rsi)
jne 0xaee6d
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x73076(%rip), %rsi # 0x121bac
movq %rbx, %rdi
callq 0xb581a
testb %al, %al
je 0xaee6d
leaq 0x7305f(%rip), %rsi # ... | /ggerganov[P]llama/common/chat.cpp |
process_tool_call(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::al... | static common_chat_tool_call process_tool_call(const json & tool_call) {
const auto & arguments = tool_call.at("arguments");
return {
/* .name = */ tool_call.at("name"),
/* .arguments = */ arguments.is_string() ? arguments.get<std::string>() : arguments.dump(),
/* .id = */ tool_call.cont... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x74885(%rip), %rsi # 0x125ab9
movq %r14, %rdi
callq 0xb6138
movq %rax, %r15
leaq 0x76c39(%rip), %rsi # 0x127e7f
movq %r14, %rdi
callq 0xb587c
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc46ce
leaq 0x20(%rbx), %rdi
cmpb $0x3, (%r... | /ggerganov[P]llama/common/chat.cpp |
bool 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<unsig... | constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
} | cmpb $0x1, (%rdi)
jne 0xb585e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movq (%r12), %r15
movq 0x8(%r12), %rax
cmpq %rax, %r15
je 0xb5864
movq %rsi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x22090
testl %eax, %eax
je 0xb5861
addq $0x30, %r15
movq 0x8(%r12), %rax
cmpq... | /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... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xb58d8
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xb58bd
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22090
testl %eax, %eax
je 0xb58ba
addq $0x30, %rbx
jmp 0xb5... | /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... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xb5de6
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xb5dcb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22090
testl %eax, %eax
je 0xb5dc8
addq $0x30, %rbx
jmp 0xb5... | /ggerganov[P]llama/common/json.hpp |
bool 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<unsig... | constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
} | cmpb $0x1, (%rdi)
jne 0xb5f74
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movq (%r12), %r15
movq 0x8(%r12), %rax
cmpq %rax, %r15
je 0xb5f7a
movq %rsi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x22090
testl %eax, %eax
je 0xb5f77
addq $0x30, %r15
movq 0x8(%r12), %rax
cmpq... | /ggerganov[P]llama/common/json.hpp |
bool 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<unsig... | constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
} | cmpb $0x1, (%rdi)
jne 0xb65a2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movq (%r12), %r15
movq 0x8(%r12), %rax
cmpq %rax, %r15
je 0xb65a8
movq %rsi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x22090
testl %eax, %eax
je 0xb65a5
addq $0x30, %r15
movq 0x8(%r12), %rax
cmpq... | /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... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xb661c
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xb6601
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22090
testl %eax, %eax
je 0xb65fe
addq $0x30, %rbx
jmp 0xb6... | /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[](T* key) const
{
return operator[](typename object_t::key_type(key));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x67012
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc1476
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xba39f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
movq %rbx, %r... | /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(KeyType && key)
{
// 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<KeyType>(ke... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xbbc10
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xbbbf5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22090
testl %eax, %eax
je 0xbbbf2
addq $0x30, %rbx
jmp 0xbb... | /ggerganov[P]llama/common/json.hpp |
minja::Context::make(minja::Value&&, std::shared_ptr<minja::Context> const&) | inline std::shared_ptr<Context> Context::make(Value && values, const std::shared_ptr<Context> & parent) {
return std::make_shared<Context>(values.is_null() ? Value::object() : std::move(values), parent);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq 0x10(%rsi), %rdx
movq 0x20(%rsi), %rax
movq %rax, %rcx
orq %rdx, %rcx
sete %cl
cmpb $0x0, 0x40(%rsi)
movq %rdi, %rbx
sete %sil
andb %cl, %sil
movq 0x30(%r15), %rcx
testq %rcx, %rcx
sete %bpl
andb %sil... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Value::callable(std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)> const&) | static Value callable(const CallableType & callable) {
return Value(std::make_shared<CallableType>(callable));
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0xd1ce8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd1c0c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xc131e
callq 0x74e98
movq %rbx, %rax
addq $0... | /ggerganov[P]llama/common/minja/minja.hpp |
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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::all... | ~iteration_proxy_value() = default; | pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0xc13ce
movq (%rax), %rsi
incq %rsi
callq 0x21180
movq 0x30(%rbx), %rdi
addq $0x40, %rbx
cmpq %rbx, %rdi
je 0xc13e7
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x21180
popq %rbx
retq
nop
| /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::type_error nlohmann::json_abi_v3_11_3::detail::type_error::create<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::alloc... | static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x5f8b1(%rip), %rsi # 0x120e90
leaq 0x5f8b4(%rip), %rdx # 0x120e9a
leaq 0x28(%rsp), %rdi
callq 0x2d5b8
leaq 0x48(%rsp), %rdi
leaq 0... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::operator==(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<u... | constexpr value_t type() const noexcept
{
return m_data.m_type;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movzbl (%rdi), %eax
movb (%rsi), %cl
cmpb %cl, %al
jne 0xc184b
cmpl $0x8, %eax
ja 0xc1a59
movb $0x1, %bl
movl %eax, %eax
leaq 0x62f93(%rip), %rcx # 0x1247c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jm... | /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
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0xc1cd6
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x21230
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x898e8
cmpb $0x2, (%r14)
jne 0xc1d1d
... | /ggerganov[P]llama/common/json.hpp |
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... | 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... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xc2a13
movq %rdi, %r14
cmpb $0x1, (%rax)
jne 0xc29b5
movq 0x8(%r14), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x216a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x1... | /ggerganov[P]llama/common/json.hpp |
minja::Value::dump(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int, bool) const | void dump(std::ostringstream & out, int indent = -1, int level = 0, bool to_json = false) const {
auto print_indent = [&](int level) {
if (indent > 0) {
out << "\n";
for (int i = 0, n = level * indent; i < n; ++i) out << ' ';
}
};
auto print_sub_sep = [&]() {
out << ','... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %r13d
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %rbx
xorl %ecx, %ecx
testl %r8d, %r8d
sete %sil
movq 0x10(%rdi), %r8
movq 0x20(%rdi), %rdx
movq %rdx, %rax
orq %r8, %rax
sete %r10b
movb 0x40(%rdi), %al
testb %al, %al
sete %r... | /ggerganov[P]llama/common/minja/minja.hpp |
bool minja::Value::get<bool>() const | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0xc415a
cmpq $0x0, 0x20(%r14)
jne 0xc415a
cmpq $0x0, 0x30(%r14)
jne 0xc415a
addq $0x40, %r14
movq %rsp, %rbx
movb $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc4499
movb (%rbx), %al
addq $0x40, %rsp
popq %rbx
popq %r14
p... | /ggerganov[P]llama/common/minja/minja.hpp |
void nlohmann::json_abi_v3_11_3::detail::from_json<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, s... | inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
{
if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
{
JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
}
b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>(... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x4, (%rdi)
jne 0xc44b8
movb 0x8(%r14), %al
movb %al, (%rsi)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x216a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x8f182
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x61354(%rip),... | /ggerganov[P]llama/common/json.hpp |
minja::Context::get(minja::Value const&) | virtual Value get(const Value & key) {
if (values_.contains(key)) return values_.at(key);
if (parent_) return parent_->get(key);
return Value();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsi), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0xc529c
testb %al, %al
je 0xc50dc
movq %r12, %rdi
movq %r14, %rsi
callq 0xc54da
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc3134
jmp 0xc512f
movq 0x68(%r15), %r... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Value::at(minja::Value const&) | Value& at(const Value & index) {
if (!index.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
if (is_array()) return array_->at(index.get<int>());
if (is_object()) return object_->at(index.primitive_);
throw std::runtime_error("Value is not an array or object: " + dump());
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x0, 0x10(%rsi)
jne 0xc5561
cmpq $0x0, 0x20(%rsi)
jne 0xc5561
cmpq $0x0, 0x30(%rsi)
jne 0xc5561
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0xc5547
movq %rsi, %rdi
callq 0xc595c
movslq %eax, %rsi
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx... | /ggerganov[P]llama/common/minja/minja.hpp |
nlohmann::json_abi_v3_11_3::ordered_map<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<... | T& operator[](const key_type& key)
{
return emplace(key, T{}).first->second;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x40(%rsp), %r14
movq $0x0, 0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%r14)
movaps %xmm0, -0x30(%r14)
movaps %xmm0, -0x20(%r14)
movaps %xmm0, -0x10(%r14)
movb $0x0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x898e8
movq %r1... | /ggerganov[P]llama/common/json.hpp |
long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const | T get(const std::string & key, T default_value) const {
if (!contains(key)) return default_value;
return at(key).get<T>();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xc6f9c
testb %al, %al
je 0xc6f7c
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc1284
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc54da
movq %rax, %rdi
callq 0xc70d0
movq %rax, %rbx
leaq 0x40(%rsp), %r14
movq %... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Value::contains(char const*) const | bool contains(const char * key) const { return contains(std::string(key)); } | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x67012
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc6f9c
movl %eax, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc7b38
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
movl %ebx, %e... | /ggerganov[P]llama/common/minja/minja.hpp |
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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::all... | const string_type& key() const
{
JSON_ASSERT(anchor.m_object != nullptr);
switch (anchor.m_object->type())
{
// use integer array index as key
case value_t::array:
{
if (array_index != array_index_last)
{
... | pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xc7c8e
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xc7c7c
cmpl $0x2, %eax
jne 0xc7c85
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0xc7c76
leaq 0x30(%rbx), %rdi
callq 0xc8119
movq 0x20(%rbx), %rax
movq %rax, 0x28(%rbx)
addq $0x30, %rbx
jmp 0xc7c89
movq %rb... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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::all... | explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
noexcept(std::is_nothrow_move_constructible<IteratorType>::value
&& std::is_nothrow_default_constructible<string_type>::value)
: anchor(std::move(it))
, array_index(array_index_)
{} | pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
leaq 0x59382(%rip), %rsi # 0x121471
leaq 0x5937c(%rip), %rdx # 0x121472
callq 0x2d5b8
le... | /ggerganov[P]llama/common/json.hpp |
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... | 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... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xc8261
movq %rdi, %r14
cmpb $0x1, (%rax)
jne 0xc8203
movq 0x8(%r14), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x216a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x1... | /ggerganov[P]llama/common/json.hpp |
minja::ArgumentsValue::get_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Value get_named(const std::string & name) {
for (const auto & [key, value] : kwargs) {
if (key == name) return value;
}
return Value();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rsi), %r14
movq 0x20(%rsi), %r12
cmpq %r12, %r14
sete %bpl
je 0xc9655
movq (%rdx), %r15
movq 0x8(%rdx), %r13
movq 0x8(%r14), %rdx
cmpq %r13, %rdx
jne 0xc9631
testq %rdx, %rdx
je 0xc9640
movq (%r14), %rdi
movq %r15, %... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Value::operator<(minja::Value const&) const | bool operator<(const Value & other) const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_number() && other.is_number()) return get<double>() < other.get<double>();
if (is_string() && other.is_string()) return get<std::string>() < other.get<std::string>();
throw s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x20(%rdi)
movb 0x40(%rdi), %al
jne 0xcae3d
cmpq $0x0, 0x10(%r15)
jne 0xcae3d
testb %al, %al
jne 0xcae3d
cmpq $0x0, 0x30(%r15)
je 0xcaf3b
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0xcae75
movb 0x40(%r14), %cl
addb $-0x... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Value::to_int() const | int64_t to_int() const {
if (is_null()) return 0;
if (is_boolean()) return get<bool>() ? 1 : 0;
if (is_number()) return static_cast<int64_t>(get<double>());
if (is_string()) {
try {
return std::stol(get<std::string>());
} catch (const std::exception &) {
return 0;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rsi
cmpq $0x0, 0x20(%rdi)
movb 0x40(%rdi), %al
jne 0xccb72
cmpq $0x0, 0x10(%rsi)
jne 0xccb72
testb %al, %al
jne 0xccb72
cmpq $0x0, 0x30(%rsi)
jne 0xccb72
xorl %ebx, %ebx
jmp 0xccc14
cmpb $0x4, %al
jne 0xccb86
movq %rsi, %rdi
callq 0xc41... | /ggerganov[P]llama/common/minja/minja.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... | inline json Value::get<json>() const {
if (is_primitive()) return primitive_;
if (is_null()) return json();
if (array_) {
std::vector<json> res;
for (const auto& item : *array_) {
res.push_back(item.get<json>());
}
return res;
}
if (object_) {
json res = json::object();
for (cons... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x20(%rsi), %rcx
movq %rax, %rsi
orq %rcx, %rsi
movq 0x30(%r14), %rdx
orq %rdx, %rsi
jne 0xcd29c
addq $0x40, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8dd16
jmp 0xcd4f2
testq ... | /ggerganov[P]llama/common/minja/minja.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [56], char const*>(char const (&) [56], char const*&&) | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x216d0
movq %rax, %r12
movq (%r14), %rdi
callq 0x216d0
addq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x... | /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[](typename object_t::key_type key)
{
// implicitly convert null value to an empty object
if (is_null())
{
m_data.m_type = value_t::object;
m_data.m_value.object = create<object_t>();
assert_invariant();
}
// operator[] o... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0xcdec0
movb $0x1, (%r14)
movl $0x20, %edi
callq 0x21230
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x898e8
cmpb $0x1, (%r14)
j... | /ggerganov[P]llama/common/json.hpp |
bool minja::Value::get<bool>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const | T get(const std::string & key, T default_value) const {
if (!contains(key)) return default_value;
return at(key).get<T>();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0xc6f9c
testb %al, %al
je 0xd05dc
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc1284
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc54da
movq %rax, %rdi
callq 0xc411a
movl %eax, %ebx
leaq 0x40(%rsp), %r14
movq %... | /ggerganov[P]llama/common/minja/minja.hpp |
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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::all... | explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
noexcept(std::is_nothrow_move_constructible<IteratorType>::value
&& std::is_nothrow_default_constructible<string_type>::value)
: anchor(std::move(it))
, array_index(array_index_)
{} | pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
leaq 0x4f218(%rip), %rsi # 0x121471
leaq 0x4f212(%rip), %rdx # 0x121472
callq 0x2d5b8
le... | /ggerganov[P]llama/common/json.hpp |
bool 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<unsig... | constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
} | cmpb $0x1, (%rdi)
jne 0xd319c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movq (%r12), %r15
movq 0x8(%r12), %rax
cmpq %rax, %r15
je 0xd31a2
movq %rsi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x22090
testl %eax, %eax
je 0xd319f
addq $0x30, %r15
movq 0x8(%r12), %rax
cmpq... | /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 emplace_back(Args&& ... args)
{
// emplace_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
}
//... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0xd3368
cmpl $0x2, %eax
je 0xd3395
movl $0x20, %edi
callq 0x216a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x8f182
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x52e29(%rip), %rsi # 0x126157
leaq 0x... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::serializer<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::... | void dump(const BasicJsonType& val,
const bool pretty_print,
const bool ensure_ascii,
const unsigned int indent_step,
const unsigned int current_indent = 0)
{
switch (val.m_data.m_type)
{
case value_t::object:
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movzbl (%rsi), %eax
cmpq $0x9, %rax
ja 0xd4a4e
movl %r9d, %ebp
movl %r8d, %r13d
movl %ecx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x5064f(%rip), %rcx # 0x124864
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %... | /ggerganov[P]llama/common/json.hpp |
void nlohmann::json_abi_v3_11_3::detail::serializer<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, ... | void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
{{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
{{'1', '0'}... | testl %esi, %esi
je 0xd5074
cmpb $0x64, %sil
movl $0x3, %eax
sbbq $0x0, %rax
cmpb $0xa, %sil
movl $0x1, %ecx
cmovaeq %rax, %rcx
movzbl %sil, %r8d
leaq (%rdi,%rcx), %r9
addq $0x10, %r9
cmpb $0x64, %sil
jb 0xd504d
movabsq $0x28f5c28f5c28f5d, %rdx # imm = 0x28F5C28F5C28F5D
movq %r8, %rax
mulq %rdx
leaq 0x53d92(%rip), %rax... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::serializer<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::... | static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
{
static const std::array<std::uint8_t, 400> utf8d =
{
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
... | pushq %rax
movl %edx, %ecx
leaq 0x5381f(%rip), %rax # 0x128c37
movzbl (%rax,%rcx), %ecx
cmpb $0x0, (%rdi)
je 0xd5432
andb $0x3f, %dl
movzbl %dl, %r8d
movl (%rsi), %edx
shll $0x6, %edx
orl %r8d, %edx
jmp 0xd5441
movl $0xff, %r8d
shrl %cl, %r8d
movzbl %dl, %edx
andl %r8d, %edx
movl %edx, (%rsi)
movzbl (%rdi), %edx
sh... | /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 push_back(const typename object_t::value_type& val)
{
// push_back only works for null objects or objects
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
{
JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movb (%rdi), %al
cmpb $0x2, %al
jae 0xd6005
movq %rsi, %rbx
testb %al, %al
jne 0xd5ff1
movb $0x1, (%r14)
movl $0x20, %edi
callq 0x21230
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
cal... | /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, ... | std::pair<iterator, bool> insert( const value_type& value )
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, value.first))
{
return {it, false};
}
}
Container::push_back(value);
return {--t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x8(%rdi), %r13
cmpq %r13, %rbx
sete %bpl
je 0xd6173
movq (%rsp), %rax
movq (%rax), %r12
movq 0x8(%rax), %r15
movq 0x8(%rbx), %rdx
cmpq %r15, %rdx
jne 0xd615e
testq %rdx, %rdx
je 0xd616d... | /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;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %rdi
movq %rax, %rsi
callq 0x2d528
movq $0x0, 0x20(%rsp)
movl $0x30, %edi
callq 0x21230
movabsq $0x100000001, %rcx # imm =... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::chat_template::try_raw_render(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<uns... | std::string try_raw_render(
const nlohmann::ordered_json & messages,
const nlohmann::ordered_json & tools,
bool add_generation_prompt,
const nlohmann::ordered_json & extra_context = nlohmann::ordered_json()) const
{
try {
chat_template_inputs inputs;
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
xorl %r13d, %r13d
leaq 0x48(%rsp), %r14
movb %r13b, (%r14)
movq %r13, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x898e8
mov... | /ggerganov[P]llama/common/minja/chat-template.hpp |
minja::Parser::Parser(std::shared_ptr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, minja::Options const&) | Parser(const std::shared_ptr<std::string>& template_str, const Options & options) : template_str(template_str), options(options) {
if (!template_str) throw std::runtime_error("Template string is null");
start = it = this->template_str->begin();
end = this->template_str->end();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0xdf3de
movq 0x89bb8(%rip), %rcx # 0x168f88
cmpb $0x0, (%rcx)
je 0xdf3da
incl 0x8(%rax)
jmp 0xdf3de
lock
incl 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq ... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseExpression(bool) | std::shared_ptr<Expression> parseExpression(bool allow_if_expr = true) {
auto left = parseLogicalOr();
if (it == end) return left;
if (!allow_if_expr) return left;
static std::regex if_tok(R"(if\b)");
if (consumeToken(if_tok).empty()) {
return left;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xe478a
movq 0x20(%r14), %rax
cmpq 0x18(%r14), %rax
je 0xe33f6
testb %bpl, %bpl
je 0xe33f6
leaq 0x87188(%rip), %rax # 0x16a510
movb (%rax), %al
testb %al, %al
je 0xe34d3
leaq... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling) | std::string consumeToken(const std::regex & regex, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
std::smatch match;
if (std::regex_search(it, end, match, regex) && match.position() == 0) {
it += match[0].length();
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %r12
movq %rsi, %rdi
movl %ecx, %esi
callq 0xe4452
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdi
movq %r15, %rcx
xo... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseVarNames[abi:cxx11]() | std::vector<std::string> parseVarNames() {
static std::regex varnames_regex(R"(((?:\w+)(?:\s*,\s*(?:\w+))*)\s*)");
std::vector<std::string> group;
if ((group = consumeTokenGroups(varnames_regex)).empty()) throw std::runtime_error("Expected variable names");
std::vector<std::string> varnames;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x86f7a(%rip), %rax # 0x16a740
movb (%rax), %al
testb %al, %al
je 0xe39bb
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x86f38(%rip), %rdx ... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling) | std::string consumeToken(const std::string & token, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
if (std::distance(it, end) >= (int64_t) token.size() && std::string(it, it + token.size()) == token) {
it += token.size();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq %rax, (%rsp)
movq %rsi, %rdi
movl %ecx, %esi
callq 0xe4452
movq 0x18(%r15), %rbp
movq 0x20(%r15), %rsi
subq %rsi, %rbp
movq 0x8(%r14), %r13
cmpq %r13, %rbp
jl 0xe... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::CommentTemplateToken::~CommentTemplateToken() | CommentTemplateToken(const Location & loc, SpaceHandling pre, SpaceHandling post, const std::string& t) : TemplateToken(Type::Comment, loc, pre, post), text(t) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x831b5(%rip), %rax # 0x1678c8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0xe4732
movq (%rax), %rsi
incq %rsi
callq 0x21180
leaq 0x831d7(%rip), %rax # 0x167910
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %r... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseIfExpression() | std::pair<std::shared_ptr<Expression>, std::shared_ptr<Expression>> parseIfExpression() {
auto condition = parseLogicalOr();
if (!condition) throw std::runtime_error("Expected condition expression");
static std::regex else_tok(R"(else\b)");
std::shared_ptr<Expression> else_expr;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0xe478a
cmpq $0x0, (%r15)
je 0xe4b36
leaq 0x85cd5(%rip), %rax # 0x16a718
movb (%rax), %al
testb %al, %al
je 0xe4b68
leaq 0x85ca4(%rip), %rdx # 0x16a6f8
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
mo... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseLogicalNot() | std::shared_ptr<Expression> parseLogicalNot() {
static std::regex not_tok(R"(not\b)");
auto location = get_location();
if (!consumeToken(not_tok).empty()) {
auto sub = parseLogicalNot();
if (!sub) throw std::runtime_error("Expected expression after 'not' keyword");
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x856a0(%rip), %rax # 0x16a588
movb (%rax), %al
testb %al, %al
je 0xe4ffd
movq (%r14), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0xe4f1d
movq 0x84079(%rip), %rcx # 0x168f88
cmpb... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::UnaryOpExpr::UnaryOpExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, minja::UnaryOpExpr::Op) | Expression(const Location & location) : location(location) {} | leaq 0x820eb(%rip), %rax # 0x1679d0
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0xe5916
movq 0x83681(%rip), %r8 # 0x168f88
cmpb $0x0, (%r8)
je 0xe5912
incl 0x8(%rax)
jmp 0xe5916
lock
incl 0x8(%rax)
movq 0x10(%rsi), %ra... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Value::operator-() const | Value operator-() const {
if (is_number_integer())
return -get<int64_t>();
else
return -get<double>();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x40(%rsi), %al
addb $-0x5, %al
leaq 0x40(%rdi), %r14
movq %rsi, %rdi
cmpb $0x1, %al
ja 0xe5de8
callq 0xc70d0
negq %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movq %... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseMathPow() | std::shared_ptr<Expression> parseMathPow() {
auto left = parseMathPlusMinus();
if (!left) throw std::runtime_error("Expected left side of 'math pow' expression");
while (!consumeToken("**").empty()) {
auto right = parseMathPlusMinus();
if (!right) throw std::runtime_erro... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xe633e
cmpq $0x0, (%rbx)
je 0xe6290
leaq 0x30(%rsp), %rbp
leaq 0x20(%rsp), %r13
leaq 0x81df8(%rip), %rax # 0x167f00
addq $0x10, %rax
movq %rax, 0x40(%rsp)
movq %rbp, 0x20(%rsp)
movq %r13, %rdi
l... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseMathUnaryPlusMinus() | std::shared_ptr<Expression> parseMathUnaryPlusMinus() {
static std::regex unary_plus_minus_tok(R"(\+|-(?![}%#]\}))");
auto op_str = consumeToken(unary_plus_minus_tok);
auto expr = parseExpansion();
if (!expr) throw std::runtime_error("Expected expr of 'unary plus/minus/expansion' express... | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x83a02(%rip), %rax # 0x16a678
movb (%rax), %al
testb %al, %al
je 0xe6db4
leaq 0x839d1(%rip), %rdx # 0x16a658
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0xe3578
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xe6f32
movq 0x... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseValueExpression()::'lambda'()::operator()() const | std::shared_ptr<Expression> parseValueExpression() {
auto parseValue = [&]() -> std::shared_ptr<Expression> {
auto location = get_location();
auto constant = parseConstant();
if (constant) return std::make_shared<LiteralExpr>(location, *constant);
static std::regex null_regex(R"(n... | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
movq (%r14), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0xe7ff9
movq 0x80f9d(%rip), %rcx # 0x168f88
cmpb $0x0, (%rcx)
je 0xe7ff5
incl 0x8(%rax)
jmp 0xe7ff9
lock
incl 0x8(%rax)
movq 0x20... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseCallArgs() | ArgumentsExpression parseCallArgs() {
consumeSpaces();
if (consumeToken("(").empty()) throw std::runtime_error("Expected opening parenthesis in call args");
ArgumentsExpression result;
while (it != end) {
if (!consumeToken(")").empty()) {
return result;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, 0x40(%rsp)
movq 0x18(%rsi), %rbx
movq 0x20(%rsi), %r14
cmpq %rbx, %r14
je 0xe8505
movsbl (%r14), %edi
callq 0x21de0
testl %eax, %eax
je 0xe8505
incq %r14
movq %r14, 0x20(%r15)
jmp 0xe84ea
leaq 0x10(%rsp), %r13
... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseConstant() | std::shared_ptr<Value> parseConstant() {
auto start = it;
consumeSpaces();
if (it == end) return nullptr;
if (*it == '"' || *it == '\'') {
auto str = parseString();
if (str) return std::make_shared<Value>(*str);
}
static std::regex prim_tok(R"(true\b|True\b|false\b|Fa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsi), %r14
movq 0x18(%rsi), %r12
movq 0x20(%rsi), %r13
cmpq %r12, %r13
je 0xe8ab0
movq %r13, %rbp
movsbl (%rbp), %edi
callq 0x21de0
testl %eax, %eax
je 0xe8ab0
incq %rbp
movq %rbp, (%r14)
cmpq %... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseBracedExpressionOrArray() | std::shared_ptr<Expression> parseBracedExpressionOrArray() {
if (consumeToken("(").empty()) return nullptr;
auto expr = parseExpression();
if (!expr) throw std::runtime_error("Expected expression in braced expression");
if (!consumeToken(")").empty()) {
return expr; // Dro... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %r13
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x42a77(%rip), %rsi # 0x12b86d
leaq 0x42a71(%rip), %rdx # 0x12b86e
movq %rsp, %rdi
callq 0x2d5b8
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movq %r14, %... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseArray() | std::shared_ptr<Expression> parseArray() {
if (consumeToken("[").empty()) return nullptr;
std::vector<std::shared_ptr<Expression>> elements;
if (!consumeToken("]").empty()) {
return std::make_shared<ArrayExpr>(get_location(), std::move(elements));
}
auto first_expr =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x37d38(%rip), %rsi # 0x1210aa
leaq 0x37d32(%rip), %rdx # 0x1210ab
movq %rsp, %rdi
callq 0x2d5b8
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movq %r14, %... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseNumber(__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&) | json parseNumber(CharIterator& it, const CharIterator& end) {
auto before = it;
consumeSpaces();
auto start = it;
bool hasDecimal = false;
bool hasExponent = false;
if (it != end && (*it == '-' || *it == '+')) ++it;
while (it != end) {
if (std::isdigit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsi), %rbp
movq 0x20(%rsi), %r13
cmpq %rbp, %r13
je 0xe9eff
movq %rsi, %r12
movsbl (%r13), %edi
callq 0x21de0
testl %eax, %eax
je 0xe9eff
i... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseString[abi:cxx11]()::'lambda'(char)::operator()[abi:cxx11](char) const | std::unique_ptr<std::string> parseString() {
auto doParse = [&](char quote) -> std::unique_ptr<std::string> {
if (it == end || *it != quote) return nullptr;
std::string result;
bool escape = false;
for (++it; it != end; ++it) {
if (escape) {
escape = false;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %r12
movq 0x20(%r12), %rax
cmpq 0x18(%r12), %rax
je 0xea3e1
movl %edx, %ebp
cmpb %bpl, (%rax)
jne 0xea3e1
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0x1(%rax), %... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::LiteralExpr::LiteralExpr(minja::Location const&, minja::Value const&) | LiteralExpr(const Location & loc, const Value& v)
: Expression(loc), value(v) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x7d04d(%rip), %r15 # 0x1679d0
addq $0x10, %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0xea9b3
movq 0x7e5e3(%rip), %rcx # 0x168f88
cmpb $0x0, (%rcx)
je 0xea9af
incl 0x8(%rax)
jm... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::LiteralExpr::~LiteralExpr() | LiteralExpr(const Location & loc, const Value& v)
: Expression(loc), value(v) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7d098(%rip), %rax # 0x167ab0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x60(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x898e8
movq %r14, %rdi
callq 0x8e276
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xeaa43
callq 0x74e98
movq 0x48(%rbx), %rdi
testq %rdi, ... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::SliceExpr::~SliceExpr() | SliceExpr(const Location & loc, std::shared_ptr<Expression> && s, std::shared_ptr<Expression> && e)
: Expression(loc), start(std::move(s)), end(std::move(e)) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x7c493(%rip), %rax # 0x167c60
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0xeb7e2
callq 0x74e98
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xeb7f0
callq 0x74e98
leaq 0x7c1d9(%rip), %rax # 0x1679d0
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx)... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::SubscriptExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!base) throw std::runtime_error("SubscriptExpr.base is null");
if (!index) throw std::runtime_error("SubscriptExpr.index is null");
auto target_value = base->evaluate(context);
if (auto slice = dynamic_cast<... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0xebe48
cmpq $0x0, 0x30(%r14)
je 0xebe66
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
callq 0xe5c28
movq 0x30(%r14), %r13
testq %r13, %r13
je 0x... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::MethodCallExpr::MethodCallExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::VariableExpr>&&, minja::ArgumentsExpression&&) | Expression(const Location & location) : location(location) {} | leaq 0x7b251(%rip), %rax # 0x1679d0
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0xec7b0
movq 0x7c7e7(%rip), %r9 # 0x168f88
cmpb $0x0, (%r9)
je 0xec7ac
incl 0x8(%rax)
jmp 0xec7b0
lock
incl 0x8(%rax)
movq 0x10(%rsi), %ra... | /ggerganov[P]llama/common/minja/minja.hpp |
nlohmann::json_abi_v3_11_3::ordered_map<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<... | iterator erase(iterator first, iterator last)
{
if (first == last)
{
return first;
}
const auto elements_affected = std::distance(first, last);
const auto offset = std::distance(Container::begin(), first);
// This is the start situation. We need to delet... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq %rdx, %rsi
je 0xef87e
movq %rdx, %r15
movq %rdi, %r14
subq %rbx, %r15
movq %r15, %rbp
sarq $0x5, %rbp
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rbp
movq (%rdi), %rax
movq %rax, (%rsp)
movq ... | /ggerganov[P]llama/common/json.hpp |
minja::BinaryOpExpr::BinaryOpExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&, minja::BinaryOpExpr::Op) | Expression(const Location & location) : location(location) {} | leaq 0x76e95(%rip), %rax # 0x1679d0
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0xf0b6c
movq 0x7842b(%rip), %r9 # 0x168f88
cmpb $0x0, (%r9)
je 0xf0b68
incl 0x8(%rax)
jmp 0xf0b6c
lock
incl 0x8(%rax)
movq 0x10(%rsi), %ra... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!left) throw std::runtime_error("BinaryOpExpr.left is null");
if (!right) throw std::runtime_error("BinaryOpExpr.right is null");
auto l = left->evaluate(context);
auto do_eval = [&](const Value & l) -> Val... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r15
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0xf0d77
cmpq $0x0, 0x30(%r15)
je 0xf0d95
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0xe5c28
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
cmpq $0x0, 0x30(%r12)
je 0xf0cc3
... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Value::operator/(minja::Value const&) const | Value operator/(const Value& rhs) const {
if (is_number_integer() && rhs.is_number_integer())
return get<int64_t>() / rhs.get<int64_t>();
else
return get<double>() / rhs.get<double>();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movb 0x40(%rsi), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0xf2101
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0xf2101
movq %rsi, %rdi
callq 0xc70d0
movq %rax, %r15
movq %r14, %rdi
callq 0xc70d0
movq %rax, %rcx
movq %r15, %rax
cqto... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::IfExpr::IfExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&) | Expression(const Location & location) : location(location) {} | leaq 0x753e9(%rip), %rax # 0x1679d0
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0xf2618
movq 0x7697f(%rip), %r9 # 0x168f88
cmpb $0x0, (%r9)
je 0xf2614
incl 0x8(%rax)
jmp 0xf2618
lock
incl 0x8(%rax)
movq 0x10(%rsi), %ra... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::IfTemplateToken::~IfTemplateToken() | IfTemplateToken(const Location & loc, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && c) : TemplateToken(Type::If, loc, pre, post), condition(std::move(c)) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x7570d(%rip), %rax # 0x168068
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0xf2970
callq 0x74e98
leaq 0x74f99(%rip), %rax # 0x167910
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xf298d
popq %rbx
jmp 0x74e98
popq %r... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::ElifTemplateToken::~ElifTemplateToken() | ElifTemplateToken(const Location & loc, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && c) : TemplateToken(Type::Elif, loc, pre, post), condition(std::move(c)) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x756bb(%rip), %rax # 0x1680a0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0xf29fa
callq 0x74e98
leaq 0x74f0f(%rip), %rax # 0x167910
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xf2a17
popq %rbx
jmp 0x74e98
popq %r... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::SetTemplateToken::SetTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, 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::ba... | SetTemplateToken(const Location & loc, SpaceHandling pre, SpaceHandling post, const std::string & ns, const std::vector<std::string> & vns, std::shared_ptr<Expression> && v)
: TemplateToken(Type::Set, loc, pre, post), ns(ns), var_names(vns), value(std::move(v)) {} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r14
movq %rdi, %rbx
leaq 0x74c32(%rip), %r12 # 0x167910
addq $0x10, %r12
movq %r12, (%rdi)
movl $0xa, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rdi)
testq %rax, %rax
je 0xf2d15
movq 0x76281(%rip), %rdi ... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::VariableExpr::VariableExpr(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | VariableExpr(const Location & location, const std::string& n)
: Expression(location), name(n) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x74a2f(%rip), %r15 # 0x1679d0
addq $0x10, %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0xf2fd1
movq 0x75fc5(%rip), %rcx # 0x168f88
cmpb $0x0, (%rcx)
je 0xf2fcd
incl 0x8(%rax)
jm... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::MacroTemplateToken::~MacroTemplateToken() | MacroTemplateToken(const Location & loc, SpaceHandling pre, SpaceHandling post, std::shared_ptr<VariableExpr> && n, Expression::Parameters && p)
: TemplateToken(Type::Macro, loc, pre, post), name(std::move(n)), params(std::move(p)) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x74e55(%rip), %rax # 0x168310
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x40, %rdi
callq 0xe4422
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xf34d9
callq 0x74e98
leaq 0x74430(%rip), %rax # 0x167910
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xf34f... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::FilterTemplateToken::~FilterTemplateToken() | FilterTemplateToken(const Location & loc, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && filter)
: TemplateToken(Type::Filter, loc, pre, post), filter(std::move(filter)) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x74d89(%rip), %rax # 0x168380
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0xf360c
callq 0x74e98
leaq 0x742fd(%rip), %rax # 0x167910
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xf3629
popq %rbx
jmp 0x74e98
popq %r... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::unexpected(minja::TemplateToken const&) const | std::runtime_error unexpected(const TemplateToken & token) const {
return std::runtime_error("Unexpected " + TemplateToken::typeToString(token.type)
+ error_location_suffix(*template_str, token.location.pos));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdx), %esi
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0xf446c
leaq 0x340ae(%rip), %rcx # 0x127fa4
movl $0xb, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21260
leaq 0x38(%rsp), %r1... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::ExpressionNode::ExpressionNode(minja::Location const&, std::shared_ptr<minja::Expression>&&) | TemplateNode(const Location & location) : location_(location) {} | leaq 0x71221(%rip), %rax # 0x168500
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0xf730f
movq 0x71c87(%rip), %rcx # 0x168f88
cmpb $0x0, (%rcx)
je 0xf730b
incl 0x8(%rax)
jmp 0xf730f
lock
incl 0x8(%rax)
movq 0x10(%rsi), %r... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::SetNode::SetNode(minja::Location const&, 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>>... | SetNode(const Location & loc, const std::string & ns, const std::vector<std::string> & vns, std::shared_ptr<Expression> && v)
: TemplateNode(loc), ns(ns), var_names(vns), value(std::move(v)) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x70d33(%rip), %r13 # 0x168500
addq $0x10, %r13
movq %r13, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0xf77fd
movq 0x7179... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::MacroNode::MacroNode(minja::Location const&, std::shared_ptr<minja::VariableExpr>&&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | MacroNode(const Location & loc, std::shared_ptr<VariableExpr> && n, Expression::Parameters && p, std::shared_ptr<TemplateNode> && b)
: TemplateNode(loc), name(std::move(n)), params(std::move(p)), body(std::move(b)) {
for (size_t i = 0; i < params.size(); ++i) {
const auto & name = params[i].fi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x6ff90(%rip), %rax # 0x168500
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0xf85a0
movq 0x709f6(%rip), %rdi # 0x168... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::FilterNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const | void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
if (!filter) throw std::runtime_error("FilterNode.filter is null");
if (!body) throw std::runtime_error("FilterNode.body is null");
auto filter_value = filter->evaluate(context);
if (!filt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %rbx
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0xf9d6e
movq %rdi, %r14
cmpq $0x0, 0x30(%rdi)
je 0xf9d8c
movq %rdx, %r15
leaq 0xc0(%rsp), %r12
movq %r12, %rdi
callq 0xe5c28
cmpq $0x0, 0x30(%r12)
je 0xf9dbe
movq 0... | /ggerganov[P]llama/common/minja/minja.hpp |
cpu_get_num_math() | int32_t cpu_get_num_math() {
#if defined(__x86_64__) && defined(__linux__) && !defined(__ANDROID__)
int n_cpu = sysconf(_SC_NPROCESSORS_ONLN);
if (n_cpu < 1) {
return cpu_get_num_physical_cores();
}
if (is_hybrid_cpu()) {
cpu_set_t affinity;
if (!pthread_getaffinity_np(pthread_se... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movl $0x54, %edi
callq 0x219d0
movq %rax, %rbx
testl %ebx, %ebx
jle 0xfadd4
movl $0x7, %eax
xorl %ecx, %ecx
movq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
testw %dx, %dx
jns 0xfadd4
callq 0x21ca0
movq %rax, %r14
leaq 0x80(%rsp), %... | /ggerganov[P]llama/common/common.cpp |
parse_cpu_mask(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool (&) [512]) | bool parse_cpu_mask(const std::string & mask, bool (&boolmask)[GGML_MAX_N_THREADS]) {
// Discard potential 0x prefix
size_t start_i = 0;
if (mask.length() >= 2 && mask.substr(0, 2) == "0x") {
start_i = 2;
}
size_t num_digits = mask.length() - start_i;
if (num_digits > 128) num_digits = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %r12
cmpq $0x2, %r12
jb 0xfb1f8
movq %rsp, %rbx
movl $0x2, %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x22200
leaq 0x25f4f(%rip), %rsi # 0x121134
movq %rbx, %rdi
callq 0x22090
xorl... | /ggerganov[P]llama/common/common.cpp |
common_init() | void common_init() {
llama_log_set([](ggml_log_level level, const char * text, void * /*user_data*/) {
if (LOG_DEFAULT_LLAMA <= common_log_verbosity_thold) {
common_log_add(common_log_main(), level, "%s", text);
}
}, NULL);
#ifdef NDEBUG
const char * build_type = "";
#else
c... | pushq %rax
leaq 0x4805(%rip), %rdi # 0xffb3a
xorl %esi, %esi
callq 0x220b0
leaq 0x6f6dd(%rip), %rax # 0x16aa20
cmpl $0x0, (%rax)
js 0xfb397
callq 0x112a5f
leaq 0x6ec3c(%rip), %rcx # 0x169f90
movl (%rcx), %ecx
leaq 0x6ec3b(%rip), %rdx # 0x169f98
movq (%rdx), %r8
leaq 0x6ec39(%rip), %rdx # 0x169fa0
m... | /ggerganov[P]llama/common/common.cpp |
common_params_get_system_info[abi:cxx11](common_params const&) | std::string common_params_get_system_info(const common_params & params) {
std::ostringstream os;
os << "system_info: n_threads = " << params.cpuparams.n_threads;
if (params.cpuparams_batch.n_threads != -1) {
os << " (n_threads_batch = " << params.cpuparams_batch.n_threads << ")";
}
#if defined(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x22140
leaq 0x2eeaf(%rip), %rsi # 0x12a26e
movl $0x19, %edx
movq %r15, %rdi
callq 0x221a0
movl 0x274(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x21530
cmpl $-0x1, 0x48... | /ggerganov[P]llama/common/common.cpp |
string_join(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string string_join(const std::vector<std::string> & values, const std::string & separator) {
std::ostringstream result;
for (size_t i = 0; i < values.size(); ++i) {
if (i > 0) {
result << separator;
}
result << values[i];
}
return result.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x22140
movq 0x8(%r15), %rax
cmpq (%r15), %rax
je 0xfbc31
movl $0x8, %r13d
xorl %ebp, %ebp
movq %rsp, %r12
testq %rbp, %rbp
je 0xfbc06
movq (... | /ggerganov[P]llama/common/common.cpp |
string_repeat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | std::string string_repeat(const std::string & str, size_t n) {
if (n == 0) {
return "";
}
std::string result;
result.reserve(str.length() * n);
for (size_t i = 0; i < n; ++i) {
result += str;
}
return result;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
testq %rdx, %rdx
je 0xfbe1a
movq %rdx, %r14
movq %rsi, %r15
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%rsi), %rsi
imulq %rdx, %rsi
movq %rbx, %rdi
callq 0x21f40
movq (%r15), %rsi
movq 0x8(%r15), %rdx... | /ggerganov[P]llama/common/common.cpp |
string_from[abi:cxx11](bool) | std::string string_from(bool value) {
return value ? "true" : "false";
} | pushq %rbx
movq %rdi, %rbx
leaq 0x1d794(%rip), %rcx # 0x1195fb
leaq 0x20730(%rip), %rax # 0x11c59e
testl %esi, %esi
cmovneq %rcx, %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movl %esi, %edx
xorq $0x5, %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x2d5b8
movq %rbx, %rax
popq %rbx
retq
| /ggerganov[P]llama/common/common.cpp |
fs_get_cache_directory[abi:cxx11]() | std::string fs_get_cache_directory() {
std::string cache_directory = "";
auto ensure_trailing_slash = [](std::string p) {
// Make sure to add trailing slash
if (p.back() != DIRECTORY_SEPARATOR) {
p += DIRECTORY_SEPARATOR;
}
return p;
};
if (getenv("LLAMA_CACHE... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x19cd1(%rip), %rdx # 0x117143
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x2d5b8
leaq 0x2cfe8(%rip), %rdi # 0x12a46e
callq 0x21db0
testq %rax, %rax
je 0xfd4bc
movq %rax, %r... | /ggerganov[P]llama/common/common.cpp |
ggml_threadpool_params_from_cpu_params(cpu_params const&) | struct ggml_threadpool_params ggml_threadpool_params_from_cpu_params(const cpu_params & params) {
struct ggml_threadpool_params tpp;
ggml_threadpool_params_init(&tpp, params.n_threads); // setup the defaults
if (params.mask_valid) {
std::memcpy(&tpp.cpumask, ¶ms.cpumask, GGML_MAX_N_THREADS);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x22440
cmpb $0x1, 0x204(%r14)
jne 0xfeefb
leaq 0x4(%r14), %rsi
movl $0x200, %edx # imm = 0x200
movq %rbx, %rdi
callq 0x210f0
movl 0x208(%r14), %eax
movl %eax, 0x204(%rbx)
movl 0x210(%r14), %eax
movl %eax, 0x208(%rbx)
mo... | /ggerganov[P]llama/common/common.cpp |
common_batch_add(llama_batch&, int, int, std::vector<int, std::allocator<int>> const&, bool) | void common_batch_add(
struct llama_batch & batch,
llama_token id,
llama_pos pos,
const std::vector<llama_seq_id> & seq_ids,
bool logits) {
GGML_ASSERT(batch.seq_id[batch.n_tokens] && "llama_batch size exceed... | pushq %rax
movq 0x28(%rdi), %rax
movslq (%rdi), %r9
cmpq $0x0, (%rax,%r9,8)
je 0xfefa7
movq 0x8(%rdi), %r10
movl %esi, (%r10,%r9,4)
movq 0x18(%rdi), %rsi
movslq (%rdi), %r9
movl %edx, (%rsi,%r9,4)
movq (%rcx), %rdx
movq 0x8(%rcx), %rsi
movq %rsi, %rcx
subq %rdx, %rcx
sarq $0x2, %rcx
movq 0x20(%rdi), %r9
movslq (%rdi), ... | /ggerganov[P]llama/common/common.cpp |
common_tokenize(llama_vocab const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool) | std::vector<llama_token> common_tokenize(
const struct llama_vocab * vocab,
const std::string & text,
bool add_special,
bool parse_special) {
// upper limit for the number of tokens
int n_tokens = text.length() + 2 * add_special;
std::vector... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leal (%r14,%r14), %eax
addl 0x8(%rdx), %eax
movslq %eax, %rsi
leaq 0x17(%rsp), %rdx
callq 0xffde6
movq (%r12), %rsi
movl 0x8(%r12), %edx
movq (%rbx), %rcx
m... | /ggerganov[P]llama/common/common.cpp |
common_kv_cache_dump_view(llama_kv_cache_view const&, int) | void common_kv_cache_dump_view(const llama_kv_cache_view & view, int row_size) {
static const char slot_chars[] = ".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+";
printf("=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, largest emp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %esi
movl 0x4(%rdi), %edx
movl 0xc(%rdi), %ecx
movl 0x8(%rdi), %r8d
movl 0x10(%rdi), %r9d
movl 0x14(%rdi), %eax
movl %eax, (%rsp)
leaq 0x2b3e6(%rip), %rdi # 0x12a941
xorl %eax, %eax
callq 0x210d... | /ggerganov[P]llama/common/common.cpp |
common_embd_normalize(float const*, float*, int, int) | void common_embd_normalize(const float * inp, float * out, int n, int embd_norm) {
double sum = 0.0;
switch (embd_norm) {
case -1: // no normalisation
sum = 1.0;
break;
case 0: // max absolute
for (int i = 0; i < n; i++) {
if (sum < std::abs(i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x18b39(%rip), %xmm3 # 0x118418
movapd %xmm3, %xmm0
cmpl $-0x1, %ecx
je 0xff9f4
testl %ecx, %ecx
je 0xff932
cmpl $0x2, %ecx
jne 0xff968
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testl %ebp, %ebp
... | /ggerganov[P]llama/common/common.cpp |
common_embd_similarity_cos(float const*, float const*, int) | float common_embd_similarity_cos(const float * embd1, const float * embd2, int n){
double sum = 0.0;
double sum1 = 0.0;
double sum2 = 0.0;
for (int i = 0; i < n; i++) {
sum += embd1[i] * embd2[i];
sum1 += embd1[i] * embd1[i];
sum2 += embd2[i] * embd2[i];
}
// Handle t... | xorpd %xmm1, %xmm1
testl %edx, %edx
jle 0xffa7b
movl %edx, %eax
xorpd %xmm0, %xmm0
xorpd %xmm5, %xmm5
xorl %ecx, %ecx
movss (%rdi,%rcx,4), %xmm2
movss (%rsi,%rcx,4), %xmm3
movaps %xmm2, %xmm4
mulss %xmm3, %xmm4
cvtss2sd %xmm4, %xmm4
unpcklps %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
mulps %xmm2, ... | /ggerganov[P]llama/common/common.cpp |
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.