name string | code string | asm string | file string |
|---|---|---|---|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> duckdb::StringUtil::Join<duckdb::vector<duckdb::unique_ptr<duckdb::ParsedExpression, std::default_delete<duckdb::ParsedExpression>, true>, true>, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> d... | static string Join(const C &input, S count, const string &separator, FUNC f) {
// The result
std::string result;
// If the input isn't empty, append the first element. We do this so we
// don't need to introduce an if into the loop.
if (count > 0) {
result += f(input[0]);
}
// Append the remaining in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movb $0x0, 0x10(%rdi)
testq %rdx, %rdx
je 0x1566e62
movq %r12, %rdi
xorl %esi, %esi
callq 0x10d27b0
leaq 0... | /duckdb[P]duckdb/src/include/duckdb/common/string_util.hpp |
duckdb::AddScalarFunctionOverloadInfo::Copy() const | unique_ptr<AlterInfo> AddScalarFunctionOverloadInfo::Copy() const {
return make_uniq_base<AlterInfo, AddScalarFunctionOverloadInfo>(
GetAlterEntryData(), unique_ptr_cast<CreateInfo, CreateScalarFunctionInfo>(new_overloads->Copy()));
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x106f640
addq $0x78, %r14
movq %r14, %rdi
callq 0x1019870
movq (%rax), %rcx
movq %rsp, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
movq (%rsp), %rax
andq $0x0, (%rsp)
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %r... | /duckdb[P]duckdb/src/parser/parsed_data/alter_scalar_function_info.cpp |
duckdb::SetCommentInfo::ToString[abi:cxx11]() const | string SetCommentInfo::ToString() const {
string result = "";
result += "COMMENT ON ";
result += ParseInfo::TypeToString(entry_catalog_type);
result += " ";
result += QualifierToString(catalog, schema, name);
result += " IS ";
result += comment_value.ToSQLString();
result += ";";
return result;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb12ffd(%rip), %rsi # 0x207acfd
leaq 0x8(%rsp), %rdx
callq 0x1063d80
leaq 0x9ac029(%rip), %rsi # 0x1f13d3a
movq %rbx, %rdi
callq 0x10c6240
movzbl 0x71(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x108d920
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
... | /duckdb[P]duckdb/src/parser/parsed_data/alter_table_info.cpp |
duckdb::RemoveFieldInfo::RemoveFieldInfo(duckdb::AlterEntryData, duckdb::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, true>, bool, bool) | RemoveFieldInfo::RemoveFieldInfo(AlterEntryData data, vector<string> column_path_p, bool if_column_exists, bool cascade)
: AlterTableInfo(AlterTableType::REMOVE_FIELD, std::move(data)), column_path(std::move(column_path_p)),
if_column_exists(if_column_exists), cascade(cascade) {
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x10d59a0
pushq $0xf
popq %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x10e51a0
movq %r12, %rdi
callq 0x10c2c50
movq 0x1181cc3(%rip), %rax #... | /duckdb[P]duckdb/src/parser/parsed_data/alter_table_info.cpp |
duckdb::ChangeColumnTypeInfo::ChangeColumnTypeInfo() | ChangeColumnTypeInfo::ChangeColumnTypeInfo() : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE) {
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x5
popq %rsi
callq 0x101e370
movq 0x118852d(%rip), %rax # 0x26f16e0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x88(%rbx), %rax
movq %rax, 0x78(%rbx)
andq $0x0, 0x80(%rbx)
leaq 0x78(%rbx), %r14
movb $0x0, 0x88(%rbx)
leaq 0x98(%rbx), %rdi
callq 0xffa590
andq $0x0, ... | /duckdb[P]duckdb/src/parser/parsed_data/alter_table_info.cpp |
duckdb::SetDefaultInfo::ToString[abi:cxx11]() const | string SetDefaultInfo::ToString() const {
string result = "";
result += "ALTER TABLE ";
if (if_not_found == OnEntryNotFound::RETURN_NULL) {
result += " IF EXISTS";
}
result += QualifierToString(catalog, schema, name);
result += " ALTER COLUMN ";
result += KeywordHelper::WriteOptionallyQuoted(column_name);
if ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb115e1(%rip), %rsi # 0x207acfd
leaq 0x8(%rsp), %rdx
callq 0x1063d80
leaq 0x9aa61e(%rip), %rsi # 0x1f13d4b
movq %rbx, %rdi
callq 0x10c6240
cmpb $0x1, 0xa(%r14)
jne 0x156974b
leaq 0x9aa615(%rip), %rsi # 0x1f13d58
movq %rbx, %rdi
callq ... | /duckdb[P]duckdb/src/parser/parsed_data/alter_table_info.cpp |
duckdb::AddConstraintInfo::Copy() const | unique_ptr<AlterInfo> AddConstraintInfo::Copy() const {
return make_uniq_base<AlterInfo, AddConstraintInfo>(GetAlterEntryData(), constraint->Copy());
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x106f640
addq $0x78, %r14
movq %r14, %rdi
callq 0x109b510
movq (%rax), %rcx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq *0x18(%rcx)
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x106b2a0
movq 0x8(%rsp)... | /duckdb[P]duckdb/src/parser/parsed_data/alter_table_info.cpp |
duckdb::AttachInfo::GetStorageOptions() const | StorageOptions AttachInfo::GetStorageOptions() const {
StorageOptions storage_options;
for (auto &entry : options) {
if (entry.first == "block_size") {
// Extract the block allocation size. This is NOT the actual memory available on a block (block_size),
// even though the corresponding option we expose to th... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x10(%rdi)
movq %rdi, 0x30(%rsp)
movdqu %xmm0, (%rdi)
addq $0x60, %r14
pushq $-0x1
popq %rax
movl $0x0, 0xc(%rsp)
leaq 0x9b90f8(%rip), %r15 # 0x1f23b50
leaq 0x98ba63(%rip), %r13 # ... | /duckdb[P]duckdb/src/parser/parsed_data/attach_info.cpp |
duckdb::CreateSequenceInfo::ToString[abi:cxx11]() const | string CreateSequenceInfo::ToString() const {
std::stringstream ss;
ss << "CREATE";
if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
ss << " OR REPLACE";
}
if (temporary) {
ss << " TEMPORARY";
}
ss << " SEQUENCE ";
if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
ss << " IF NOT EXISTS... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0x1019610
leaq 0x60(%rsp), %r15
leaq 0x9657fe(%rip), %rsi # 0x1ed3895
movq %r15, %rdi
callq 0x10b9320
cmpb $0x2, 0x50(%r14)
jne 0x156e0b5
leaq 0x9a5dec(%rip), %rsi # 0... | /duckdb[P]duckdb/src/parser/parsed_data/create_sequence_info.cpp |
duckdb::CreateSchemaInfo::ToString[abi:cxx11]() const | string CreateSchemaInfo::ToString() const {
string ret = "";
string qualified = QualifierToString(temporary ? "" : catalog, "", schema);
switch (on_conflict) {
case OnCreateConflict::ALTER_ON_CONFLICT: {
ret += "CREATE SCHEMA " + qualified + " ON CONFLICT INSERT OR REPLACE;";
break;
}
case OnCreateConflict::... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb0c978(%rip), %rsi # 0x207acfd
leaq 0x50(%rsp), %rdx
callq 0x1063d80
movb 0x51(%r14), %bpl
cmpb $0x1, %bpl
jne 0x156e3b1
leaq 0xb0c95d(%rip), %rsi # 0x207acfd
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1063d80
jmp 0x1... | /duckdb[P]duckdb/src/parser/parsed_data/create_schema_info.cpp |
duckdb::CreateScalarFunctionInfo::GetAlterInfo() const | unique_ptr<AlterInfo> CreateScalarFunctionInfo::GetAlterInfo() const {
return make_uniq_base<AlterInfo, AddScalarFunctionOverloadInfo>(
AlterEntryData(catalog, schema, name, OnEntryNotFound::RETURN_NULL),
unique_ptr_cast<CreateInfo, CreateScalarFunctionInfo>(Copy()));
} | pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rsi
leaq 0x50(%rsp), %rdi
callq 0x1025cf0
leaq 0x30(%r14), %rsi
leaq 0x30(%rsp), %rdi
callq 0x1025cf0
leaq 0x128(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0x1025cf0
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x... | /duckdb[P]duckdb/src/parser/parsed_data/create_scalar_function_info.cpp |
duckdb::CreateTableInfo::CreateTableInfo(duckdb::SchemaCatalogEntry&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | CreateTableInfo::CreateTableInfo(SchemaCatalogEntry &schema, string name_p)
: CreateTableInfo(schema.catalog.GetName(), schema.name, std::move(name_p)) {
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0xd8(%rsi), %rdi
callq 0x10e0f20
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x1025cf0
addq $0x20, %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1025cf0
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x104... | /duckdb[P]duckdb/src/parser/parsed_data/create_table_info.cpp |
duckdb::CreateTypeInfo::ToString[abi:cxx11]() const | string CreateTypeInfo::ToString() const {
string result = "";
result += "CREATE";
if (temporary) {
// These are created by PIVOT
throw NotImplementedException("CREATE TEMPORARY TYPE can't be parsed currently");
}
result += " TYPE ";
result += QualifierToString(temporary ? "" : catalog, schema, name);
if (typ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb0b619(%rip), %rsi # 0x207acfd
leaq 0x38(%rsp), %rdx
callq 0x1063d80
leaq 0x9641a0(%rip), %rsi # 0x1ed3895
movq %rbx, (%rsp)
movq %rbx, %rdi
callq 0x10c6240
cmpb $0x1, 0x51(%r14)
je 0x156f9d8
... | /duckdb[P]duckdb/src/parser/parsed_data/create_type_info.cpp |
duckdb::CreateViewInfo::Copy() const | unique_ptr<CreateInfo> CreateViewInfo::Copy() const {
auto result = make_uniq<CreateViewInfo>(catalog, schema, view_name);
CopyProperties(*result);
result->aliases = aliases;
result->types = types;
result->column_comments = column_comments;
result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Cop... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rsi
leaq 0x30(%r14), %rdx
leaq 0x128(%r14), %rcx
movq %rsp, %r15
movq %r15, %rdi
callq 0x10297c0
movq %r15, %rdi
callq 0x1076e50
movq %r14, %rdi
movq %rax, %rsi
callq 0x108ed90
movq %rsp, %rdi
callq 0xff1a30
movl $0x148, %ecx... | /duckdb[P]duckdb/src/parser/parsed_data/create_view_info.cpp |
duckdb::DropInfo::DropInfo(duckdb::DropInfo const&) | DropInfo::DropInfo(const DropInfo &info)
: ParseInfo(info.info_type), type(info.type), catalog(info.catalog), schema(info.schema), name(info.name),
if_not_found(info.if_not_found), cascade(info.cascade), allow_drop_internal(info.allow_drop_internal),
extra_drop_info(info.extra_drop_info ? info.extra_dro... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r15
movb 0x8(%rsi), %al
movb %al, 0x8(%rdi)
movq 0x117e6c6(%rip), %rax # 0x26eef90
addq $0x10, %rax
movq %rax, (%rdi)
movb 0x9(%rsi), %al
movb %al, 0x9(%rdi)
leaq 0x10(%rdi), %rbx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x1025cf0
leaq 0... | /duckdb[P]duckdb/src/parser/parsed_data/drop_info.cpp |
duckdb::SampleOptions::Equals(duckdb::SampleOptions*, duckdb::SampleOptions*) | bool SampleOptions::Equals(SampleOptions *a, SampleOptions *b) {
if (a == b) {
return true;
}
if (!a || !b) {
return false;
}
// if only one is valid, they are not equal
if (a->seed.IsValid() != b->seed.IsValid()) {
return false;
}
// if both are invalid, then they are technically the same
if (!a->seed.I... | movb $0x1, %al
cmpq %rsi, %rdi
je 0x1571180
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x1571177
movq 0x48(%r14), %rcx
cmpq $-0x1, %rcx
setne %sil
movq 0x48(%rbx), %rdx
cmpq $-0x1, %rdx
setne %dil
xorb %sil, %dil
jne 0x1571177
an... | /duckdb[P]duckdb/src/parser/parsed_data/sample_options.cpp |
duckdb::unique_ptr<duckdb::AlterInfo, std::default_delete<duckdb::AlterInfo>, true> duckdb::make_uniq_base<duckdb::AlterInfo, duckdb::DropNotNullInfo, duckdb::AlterEntryData, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(duckdb::AlterEntryData&&, std::__cxx11::basic_string<char,... | unique_ptr<S> make_uniq_base(ARGS &&... args) { // NOLINT: mimic std style
return unique_ptr<S>(new T(std::forward<ARGS>(args)...));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x98, %edi
callq 0x1087910
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x10d59a0
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1025cf0
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq ... | /duckdb[P]duckdb/src/include/duckdb/common/helper.hpp |
duckdb::unique_ptr<duckdb::AlterInfo, std::default_delete<duckdb::AlterInfo>, true> duckdb::make_uniq_base<duckdb::AlterInfo, duckdb::RenameViewInfo, duckdb::AlterEntryData, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(duckdb::AlterEntryData&&, std::__cxx11::basic_string<char, ... | unique_ptr<S> make_uniq_base(ARGS &&... args) { // NOLINT: mimic std style
return unique_ptr<S>(new T(std::forward<ARGS>(args)...));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x98, %edi
callq 0x1087910
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x10d59a0
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1025cf0
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq ... | /duckdb[P]duckdb/src/include/duckdb/common/helper.hpp |
duckdb::RecursiveCTENode::Copy() const | unique_ptr<QueryNode> RecursiveCTENode::Copy() const {
auto result = make_uniq<RecursiveCTENode>();
result->ctename = ctename;
result->union_all = union_all;
result->left = left->Copy();
result->right = right->Copy();
result->aliases = aliases;
for (auto &key : key_targets) {
result->key_targets.push_back(key... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x107d170
movq %r15, %rdi
callq 0x106d590
leaq 0x78(%r14), %rsi
addq $0x78, %rax
movq %rax, %rdi
callq 0x1077780
movb 0x98(%r14), %bl
leaq 0x8(%rsp), %rdi
c... | /duckdb[P]duckdb/src/parser/query_node/recursive_cte_node.cpp |
void duckdb::AggregateExecutor::UnaryUpdate<duckdb::FirstState<unsigned char>, unsigned char, duckdb::FirstFunction<false, true>>(duckdb::Vector&, duckdb::AggregateInputData&, unsigned char*, unsigned long) | static void UnaryUpdate(Vector &input, AggregateInputData &aggr_input_data, data_ptr_t state, idx_t count) {
switch (input.GetVectorType()) {
case VectorType::CONSTANT_VECTOR: {
if (OP::IgnoreNull() && ConstantVector::IsNull(input)) {
return;
}
auto idata = ConstantVector::GetData<INPUT_TYPE>(input);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movzbl (%rdi), %eax
testl %eax, %eax
je 0x15aed73
cmpl $0x2, %eax
jne 0x15aeda5
movq 0x20(%r12), %rsi
addq $0x28, %r12
leaq 0x8(%rsp), %rdx
movq %r15, (%rdx)
movq %r12, 0x8(%rdx)
andq ... | /duckdb[P]duckdb/src/include/duckdb/common/vector_operations/aggregate_executor.hpp |
void duckdb::AggregateExecutor::UnaryFlatLoop<duckdb::FirstState<unsigned int>, unsigned int, duckdb::FirstFunction<false, true>>(unsigned int const*, duckdb::AggregateInputData&, duckdb::FirstState<unsigned int>**, duckdb::ValidityMask&, unsigned long) | static inline void UnaryFlatLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
STATE_TYPE **__restrict states, ValidityMask &mask, idx_t count) {
if (OP::IgnoreNull() && !mask.AllValid()) {
AggregateUnaryInput input(aggr_input_data, mask);
auto &base_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq %rsp, %r12
movq %rsi, (%r12)
movq %rcx, 0x8(%r12)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
cmpq %rbx, %rax
jae 0x15af776
movq (%r14,%rax,8), %rdi
leaq (%r15,%rax,4), %rsi
movq %r12, %rdx
callq 0x1010550
movq 0x... | /duckdb[P]duckdb/src/include/duckdb/common/vector_operations/aggregate_executor.hpp |
duckdb::BindUnionToUnionCast(duckdb::BindCastInput&, duckdb::LogicalType const&, duckdb::LogicalType const&) | unique_ptr<BoundCastData> BindUnionToUnionCast(BindCastInput &input, const LogicalType &source,
const LogicalType &target) {
D_ASSERT(source.id() == LogicalTypeId::UNION);
D_ASSERT(target.id() == LogicalTypeId::UNION);
auto source_member_count = UnionType::GetMemberCou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq %rdx, %rdi
callq 0x103b240
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %r15
movq %rax, 0x28(%rsp)
movq %rax, %rsi
movq %r15, %rdx
callq... | /duckdb[P]duckdb/src/function/cast/union_casts.cpp |
duckdb::string_t duckdb::HugeintCastToVarInt::Operation<duckdb::uhugeint_t>(duckdb::uhugeint_t, duckdb::Vector&) | string_t HugeintCastToVarInt::Operation(uhugeint_t int_value, Vector &result) {
uint32_t data_byte_size;
if (int_value.upper != NumericLimits<uint64_t>::Maximum()) {
data_byte_size =
(int_value.upper == 0) ? 0 : static_cast<uint32_t>(std::ceil(std::log2(int_value.upper + 1) / 8.0));
} else {
data_byte_size... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
cmpq $-0x1, %rsi
je 0x15d9536
testq %r14, %r14
je 0x15d9558
leaq 0x1(%r14), %rdi
callq 0x10cb8f0
mulsd 0x9250d5(%rip), %xmm0 # 0x1efe618
callq 0x1066610
cvttsd2si %xmm0, %r13
testl %... | /duckdb[P]duckdb/src/function/cast/varint_casts.cpp |
duckdb::SkipWhitespace((anonymous namespace)::StringCastInputState&) | inline static void SkipWhitespace(StringCastInputState &input_state) {
auto &buf = input_state.buf;
auto &pos = input_state.pos;
auto &len = input_state.len;
while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
pos++;
input_state.escaped = false;
}
} | movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
movq (%rcx), %rsi
movabsq $0x100003e00, %r8 # imm = 0x100003E00
cmpq (%rdx), %rsi
jae 0x15d9b90
movzbl (%rax,%rsi), %r9d
cmpq $0x20, %r9
ja 0x15d9b90
btq %r9, %r8
jae 0x15d9b90
incq %rsi
movq %rsi, (%rcx)
movb $0x0, 0x18(%rdi)
jmp 0x15d9b6e
retq
| /duckdb[P]duckdb/src/function/cast/vector_cast_helpers.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> duckdb::CastExceptionText<duckdb::string_t, unsigned short>(duckdb::string_t) | static string CastExceptionText(SRC input) {
if (std::is_same<SRC, string_t>()) {
return "Could not convert string '" + ConvertToString::Operation<SRC>(input) + "' to " +
TypeIdToString(GetTypeId<DST>());
}
if (TypeIsNumber<SRC>() && TypeIsNumber<DST>()) {
return "Type " + TypeIdToString(GetTypeId<SRC>(... | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x10a5c30
leaq 0x9046b0(%rip), %rsi # 0x1ede6e4
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x1014ea0
leaq 0x9046b7(%rip), %rdx # 0x1ede6ff
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1025b00
leaq 0x8(%rsp),... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> duckdb::CastExceptionText<int, short>(int) | static string CastExceptionText(SRC input) {
if (std::is_same<SRC, string_t>()) {
return "Could not convert string '" + ConvertToString::Operation<SRC>(input) + "' to " +
TypeIdToString(GetTypeId<DST>());
}
if (TypeIsNumber<SRC>() && TypeIsNumber<DST>()) {
return "Type " + TypeIdToString(GetTypeId<SRC>(... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xc0(%rsp), %r14
pushq $0x7
popq %rsi
movq %r14, %rdi
callq 0x1022c80
leaq 0x9453c9(%rip), %rsi # 0x1f20101
leaq 0x40(%rsp), %rdi
movq %r14, %rdx
callq 0x1014ea0
leaq 0x8f993d(%rip), %rdx # 0x1ed4689
leaq 0x60(%rsp), %rdi
leaq ... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> duckdb::CastExceptionText<long, short>(long) | static string CastExceptionText(SRC input) {
if (std::is_same<SRC, string_t>()) {
return "Could not convert string '" + ConvertToString::Operation<SRC>(input) + "' to " +
TypeIdToString(GetTypeId<DST>());
}
if (TypeIsNumber<SRC>() && TypeIsNumber<DST>()) {
return "Type " + TypeIdToString(GetTypeId<SRC>(... | pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc0(%rsp), %r15
pushq $0x9
popq %rsi
movq %r15, %rdi
callq 0x1022c80
leaq 0x9450cd(%rip), %rsi # 0x1f20101
leaq 0x40(%rsp), %rdi
movq %r15, %rdx
callq 0x1014ea0
leaq 0x8f9641(%rip), %rdx # 0x1ed4689
leaq 0x60(%rsp), %rdi
leaq ... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> duckdb::CastExceptionText<unsigned int, unsigned char>(unsigned int) | static string CastExceptionText(SRC input) {
if (std::is_same<SRC, string_t>()) {
return "Could not convert string '" + ConvertToString::Operation<SRC>(input) + "' to " +
TypeIdToString(GetTypeId<DST>());
}
if (TypeIsNumber<SRC>() && TypeIsNumber<DST>()) {
return "Type " + TypeIdToString(GetTypeId<SRC>(... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xc0(%rsp), %r14
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x1022c80
leaq 0x944614(%rip), %rsi # 0x1f20101
leaq 0x40(%rsp), %rdi
movq %r14, %rdx
callq 0x1014ea0
leaq 0x8f8b88(%rip), %rdx # 0x1ed4689
leaq 0x60(%rsp), %rdi
leaq ... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
duckdb::MapCastInfo::GetEntry(duckdb::LogicalType const&, duckdb::LogicalType const&) | const optional_ptr<MapCastNode> GetEntry(const LogicalType &source, const LogicalType &target) {
auto source_type_id_entry = casts.find(source.id());
if (source_type_id_entry == casts.end()) {
source_type_id_entry = casts.find(LogicalTypeId::ANY);
if (source_type_id_entry == casts.end()) {
return nullptr;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
addq $0x8, %r14
movb (%rsi), %al
leaq 0x20(%rsp), %rsi
movb %al, (%rsi)
movq %r14, %rdi
callq 0x108e6f0
testq %rax, %rax
jne 0x15dc275
leaq 0x20(%rsp), %rsi
movb $0x3, (%rsi)
movq %r14, %rd... | /duckdb[P]duckdb/src/function/cast/cast_function_set.cpp |
duckdb::MapCastInfo::AddEntry(duckdb::LogicalType const&, duckdb::LogicalType const&, duckdb::MapCastNode) | void AddEntry(const LogicalType &source, const LogicalType &target, MapCastNode node) {
casts[source.id()][source][target.id()].insert(make_pair(target, std::move(node)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
addq $0x8, %rdi
movb (%rsi), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
callq 0xff9ce0
movq %rax, %rdi
movq %r15, %rsi
callq 0x105c040
movb (%r14), %cl
leaq 0x6(%rsp), %rsi
movb %cl, (%rsi)
movq %rax, %rdi
callq ... | /duckdb[P]duckdb/src/function/cast/cast_function_set.cpp |
void duckdb::UnaryExecutor::ExecuteFlat<long, unsigned char, duckdb::GenericUnaryWrapper, duckdb::VectorTryCastOperator<duckdb::NumericTryCast>>(long const*, unsigned char*, unsigned long, duckdb::ValidityMask&, duckdb::ValidityMask&, void*, bool) | static inline void ExecuteFlat(const INPUT_TYPE *__restrict ldata, RESULT_TYPE *__restrict result_data, idx_t count,
ValidityMask &mask, ValidityMask &result_mask, void *dataptr, bool adds_nulls) {
ASSERT_RESTRICT(ldata, ldata + count, result_data, result_data + count);
if (!mask.Al... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, (%rcx)
je 0x1639516
movq %r14, %rdi
cmpb $0x0, 0x80(%rsp)
je 0x1639541
movq 0x10(%rsp), %rsi
movq %r13, %rdx
callq 0x103... | /duckdb[P]duckdb/src/include/duckdb/common/vector_operations/unary_executor.hpp |
void duckdb::BinaryExecutor::ExecuteGeneric<duckdb::list_entry_t, short, int, duckdb::BinaryLambdaWrapperWithNulls, bool, unsigned long duckdb::ListSearchSimpleOp<short, true>(duckdb::Vector&, duckdb::Vector&, duckdb::Vector&, duckdb::Vector&, unsigned long)::'lambda'(duckdb::list_entry_t const&, short const&, duckdb::... | static void ExecuteGeneric(Vector &left, Vector &right, Vector &result, idx_t count, FUNC fun) {
UnifiedVectorFormat ldata, rdata;
left.ToUnifiedFormat(count, ldata);
right.ToUnifiedFormat(count, rdata);
result.SetVectorType(VectorType::FLAT_VECTOR);
auto result_data = FlatVector::GetData<RESULT_TYPE>(resul... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x80(%rsp), %rdi
callq 0x10cbc50
leaq 0x38(%rsp), %rdi
callq 0x10cbc50
leaq 0x80(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1057210
leaq 0x38(%rsp), %rdx
movq ... | /duckdb[P]duckdb/src/include/duckdb/common/vector_operations/binary_executor.hpp |
duckdb::unique_ptr<duckdb::BaseStatistics, std::default_delete<duckdb::BaseStatistics>, true> duckdb::DatePart::PropagateDatePartStatistics<duckdb::date_t, duckdb::DatePart::DecadeOperator, long>(duckdb::vector<duckdb::BaseStatistics, true>&, duckdb::LogicalType const&) | static unique_ptr<BaseStatistics> PropagateDatePartStatistics(vector<BaseStatistics> &child_stats,
const LogicalType &stats_type = LogicalType::BIGINT) {
// we can only propagate complex date part stats if the child has stats
auto &nstats = child_stats[... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x10b4630
movq %rax, %r12
movq %rax, %rdi
callq 0x1057e60
testb %al, %al
je 0x1bcaca5
movq %r12, %rdi
callq 0x105efa0
movl %eax, %ebp
movq %r12, %rdi
c... | /duckdb[P]duckdb/extension/core_functions/scalar/date/date_part.cpp |
duckdb::unique_ptr<duckdb::BaseStatistics, std::default_delete<duckdb::BaseStatistics>, true> duckdb::DatePart::PropagateDatePartStatistics<duckdb::timestamp_t, duckdb::DatePart::DecadeOperator, long>(duckdb::vector<duckdb::BaseStatistics, true>&, duckdb::LogicalType const&) | static unique_ptr<BaseStatistics> PropagateDatePartStatistics(vector<BaseStatistics> &child_stats,
const LogicalType &stats_type = LogicalType::BIGINT) {
// we can only propagate complex date part stats if the child has stats
auto &nstats = child_stats[... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x10b4630
movq %rax, %r13
movq %rax, %rdi
callq 0x1057e60
testb %al, %al
je 0x1bcae27
movq %r13, %rdi
callq 0x109f1c0
movq %rax, %r12
movq %r13, %rdi
c... | /duckdb[P]duckdb/extension/core_functions/scalar/date/date_part.cpp |
void duckdb::UnaryExecutor::ExecuteStandard<duckdb::date_t, long, duckdb::GenericUnaryWrapper, duckdb::DatePart::PartOperator<duckdb::DatePart::CenturyOperator>>(duckdb::Vector&, duckdb::Vector&, unsigned long, void*, bool, duckdb::FunctionErrors) | static inline void ExecuteStandard(Vector &input, Vector &result, idx_t count, void *dataptr, bool adds_nulls,
FunctionErrors errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR) {
switch (input.GetVectorType()) {
case VectorType::CONSTANT_VECTOR: {
result.SetVectorType(VectorTyp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r8d, %ebp
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movzbl (%rdi), %eax
testl %eax, %eax
je 0x1bcb0b5
cmpl $0x3, %eax
je 0x1bcb032
cmpl $0x2, %eax
jne 0x1bcb03b
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x103... | /duckdb[P]duckdb/src/include/duckdb/common/vector_operations/unary_executor.hpp |
void duckdb::UnaryExecutor::ExecuteFlat<duckdb::timestamp_t, long, duckdb::GenericUnaryWrapper, duckdb::DatePart::PartOperator<duckdb::DatePart::CenturyOperator>>(duckdb::timestamp_t const*, long*, unsigned long, duckdb::ValidityMask&, duckdb::ValidityMask&, void*, bool) | static inline void ExecuteFlat(const INPUT_TYPE *__restrict ldata, RESULT_TYPE *__restrict result_data, idx_t count,
ValidityMask &mask, ValidityMask &result_mask, void *dataptr, bool adds_nulls) {
ASSERT_RESTRICT(ldata, ldata + count, result_data, result_data + count);
if (!mask.Al... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, (%rcx)
je 0x1bcb782
movq %r14, %rdi
cmpb $0x0, 0x80(%rsp)
je 0x1bcb7ad
movq 0x10(%rsp), %rsi
movq %r13, %rdx
callq 0x103... | /duckdb[P]duckdb/src/include/duckdb/common/vector_operations/unary_executor.hpp |
void duckdb::UnaryExecutor::ExecuteFlat<duckdb::interval_t, long, duckdb::UnaryOperatorWrapper, duckdb::DatePart::CenturyOperator>(duckdb::interval_t const*, long*, unsigned long, duckdb::ValidityMask&, duckdb::ValidityMask&, void*, bool) | static inline void ExecuteFlat(const INPUT_TYPE *__restrict ldata, RESULT_TYPE *__restrict result_data, idx_t count,
ValidityMask &mask, ValidityMask &result_mask, void *dataptr, bool adds_nulls) {
ASSERT_RESTRICT(ldata, ldata + count, result_data, result_data + count);
if (!mask.Al... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, (%rcx)
je 0x1bcbc7a
movq %rcx, %r12
movq %r8, %rdi
movq %rcx, %rsi
cmpb $0x0, 0x40(%rsp)
je 0x1bcbc9f
movq %rbx, %rdx
callq 0x1034520
jmp 0x1bcbca4
xorl %ecx, %ecx
movl $0x4b0, %esi ... | /duckdb[P]duckdb/src/include/duckdb/common/vector_operations/unary_executor.hpp |
duckdb::StandardColumnWriter<duckdb::dtime_tz_t, long, duckdb::ParquetTimeTZOperator>::FinalizeAnalyze(duckdb::ColumnWriterState&) | void FinalizeAnalyze(ColumnWriterState &state_p) override {
const auto type = writer.GetType(SchemaIndex());
auto &state = state_p.Cast<StandardColumnWriterState<SRC, TGT, OP>>();
if (state.dictionary.GetSize() == 0 || state.dictionary.IsFull()) {
state.dictionary.Reset();
if (writer.GetParquetVersion() ==... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
movq 0x50(%rax), %rsi
callq 0x106f120
movl %eax, %ebp
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x1cfe148
cmpb $0x1, 0x180(%rbx)
jne 0x1cfe17d
leaq 0xe8(%rbx), %rdi
callq 0xfe8fb0
movq 0x8(%r14), %rdx
xorl %ecx, ... | /duckdb[P]duckdb/extension/parquet/include/writer/templated_column_writer.hpp |
duckdb::StandardColumnWriter<duckdb::hugeint_t, double, duckdb::ParquetHugeintOperator>::InitializeWriteState(duckdb_parquet::RowGroup&) | unique_ptr<ColumnWriterState> InitializeWriteState(duckdb_parquet::RowGroup &row_group) override {
auto result = make_uniq<StandardColumnWriterState<SRC, TGT, OP>>(writer, row_group, row_group.columns.size());
result->encoding = duckdb_parquet::Encoding::RLE_DICTIONARY;
RegisterToRowGroup(row_group);
return std... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdx), %rax
subq 0x8(%rdx), %rax
movq 0x8(%rsi), %rsi
movl $0x280, %ecx # imm = 0x280
cqto
idivq %rcx
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, ... | /duckdb[P]duckdb/extension/parquet/include/writer/templated_column_writer.hpp |
duckdb::PrimitiveDictionary<duckdb::hugeint_t, double, duckdb::ParquetHugeintOperator>::Lookup(duckdb::hugeint_t const&) const | primitive_dictionary_entry_t &Lookup(const SRC &value) const {
auto offset = Hash(value) & capacity_mask;
while (!dictionary[offset].IsEmpty() && dictionary[offset].value != value) {
++offset &= capacity_mask;
}
return dictionary[offset];
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x108c6c0
movq %rax, %r15
andq 0x20(%rbx), %r15
movq 0x90(%rbx), %rdi
imulq $0x18, %r15, %r12
cmpl $-0x1, 0x10(%rdi,%r12)
je 0x1cffd55
addq %r12, %rdi
movq %r14, %rsi
callq 0x104bff0
testb... | /duckdb[P]duckdb/src/include/duckdb/common/primitive_dictionary.hpp |
void duckdb::PrimitiveDictionary<duckdb::hugeint_t, double, duckdb::ParquetHugeintOperator>::IterateValues<duckdb::hugeint_t, 0>(std::function<void (duckdb::hugeint_t const&, double const&)> const&) const | void IterateValues(const std::function<void(const SRC &, const TGT &)> &fun) const {
const auto target_values = reinterpret_cast<const TGT *>(allocated_target.get());
for (idx_t i = 0; i < capacity; i++) {
auto &entry = dictionary[i];
if (entry.IsEmpty()) {
continue;
}
fun(entry.value, target_values... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rdi), %r15
xorl %r12d, %r12d
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
xorl %ebp, %ebp
cmpq 0x18(%r14), %rbp
jae 0x1d009c5
movq 0x90(%r14), %rsi
movl 0x10(%rsi,%r12), %eax
cmpq %r13, %rax
je 0x1... | /duckdb[P]duckdb/src/include/duckdb/common/primitive_dictionary.hpp |
duckdb::StandardColumnWriterState<duckdb::uhugeint_t, double, duckdb::ParquetUhugeintOperator>::StandardColumnWriterState(duckdb::ParquetWriter&, duckdb_parquet::RowGroup&, unsigned long) | StandardColumnWriterState(ParquetWriter &writer, duckdb_parquet::RowGroup &row_group, idx_t col_idx)
: PrimitiveColumnWriterState(writer, row_group, col_idx),
dictionary(BufferAllocator::Get(writer.GetContext()), writer.DictionarySizeLimit(),
writer.StringDictionaryPageSizeLimit()),
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x106a7b0
movq 0x9e6d38(%rip), %rax # 0x26e7f78
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%rbx)
andl $0x0, 0xe0(%rbx)
movq (%r14), %rdi
callq 0x10295f0
leaq 0xe8(%rbx), %rdi
movq 0x78(%r14), %rdx
movq 0x80(%r14), %r... | /duckdb[P]duckdb/extension/parquet/include/writer/templated_column_writer.hpp |
non-virtual thunk to cppcms::cppcms_error::~cppcms_error() | class CPPCMS_API cppcms_error : public booster::runtime_error {
std::string strerror(int err);
public:
///
/// Create an object with error code err (errno) and a message \a error
///
cppcms_error(int err,std::string const &error);
///
/// Create an object with message \a error
///
cppcms_error(std::string cons... | pushq %rbx
movq %rdi, %rbx
movq 0x15609(%rip), %rax # 0x22e70
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xd87c
callq 0xc480
addq $-0x10, %rbx
movq %rbx, %rdi
callq 0xc3a0
movq %rbx, %rdi
popq %rbx
jmp 0xc480
nop
| /artyom-beilis[P]cppcms/cppcms/cppcms_error.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cppcms::filters::streamable::to_string<cppcms::filters::urlencode>(std::basic_ios<char, std::char_traits<char>>&, void const*) | static std::string to_string(std::ios &out,void const *ptr)
{
T const *object=reinterpret_cast<T const *>(ptr);
std::ostringstream oss;
oss.copyfmt(out);
oss << *object;
return oss.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0xc8b0
movq (%r12), %rax
addq -0x18(%rax), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xc260
movq %rsp, %rsi
movq %r14, %rdi
callq 0xc1d0
leaq 0x8(... | /artyom-beilis[P]cppcms/cppcms/filters.h |
append_to_zip | int append_to_zip(FILE *zip_file, file_sorted_t *filep, FILE *ozip, BYTE *odir)
{
LocalFileHeader local;
uLong crc;
file_entry_t *file;
Byte *readbuf;
Byte *compbuf[2];
unsigned int comp_len[2];
int offset[2];
int method[2];
int best;
int slot;
FILE *lumpfile;
unsigned int readlen;
unsigned int len;
int i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, %rbp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x18(%rsp)
movq (%rsi), %r14
leaq 0x8(%r14), %rdi
callq 0x3050
leaq 0x20(%r14), %rsi
leaq 0x22(%r14), %rdx
movq %rax, %rdi
callq 0x4476
leaq 0x26(%r14), %r15
leaq 0x1... | /SeongGino[P]zdoom/tools/zipdir/zipdir.c |
method_name | const char *method_name(int method)
{
static char unkn[16];
if (method == METHOD_STORED)
{
return "Stored";
}
if (method == METHOD_DEFLATE)
{
return "Deflate";
}
if (method == METHOD_LZMA)
{
return "LZMA";
}
if (method == METHOD_PPMD)
{
return "PPMd";
}
if (method == METHOD_BZIP2)
{
return "BZ... | pushq %rbx
movl %edi, %edx
cmpl $0xb, %edi
jle 0x4751
cmpl $0xc, %edx
je 0x4763
cmpl $0xe, %edx
je 0x476c
cmpl $0x62, %edx
jne 0x477e
leaq 0xfbd7(%rip), %rbx # 0x14326
jmp 0x4796
testl %edx, %edx
je 0x4775
cmpl $0x8, %edx
jne 0x477e
leaq 0xfbb8(%rip), %rbx # 0x14319
jmp 0x4796
leaq 0xfbc1(%rip), %rbx # 0... | /SeongGino[P]zdoom/tools/zipdir/zipdir.c |
BZ2_blockSort | void BZ2_blockSort ( EState* s )
{
UInt32* ptr = s->ptr;
UChar* block = s->block;
UInt32* ftab = s->ftab;
Int32 nblock = s->nblock;
Int32 verb = s->verbosity;
Int32 wfact = s->workFactor;
UInt16* quadrant;
Int32 budget;
Int32 budgetInit;
Int32 i;
if (nblock < 100... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1298, %rsp # imm = 0x1298
movq %rdi, %rax
movq 0x28(%rdi), %r12
movq 0x38(%rdi), %rbp
movslq 0x6c(%rdi), %r15
cmpq $0x270f, %r15 # imm = 0x270F
movq %rdi, 0x70(%rsp)
jg 0xc3b4
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
movq %... | /SeongGino[P]zdoom/bzip2/blocksort.c |
mainGtU | static
__inline__
Bool mainGtU ( UInt32 i1,
UInt32 i2,
UChar* block,
UInt16* quadrant,
UInt32 nblock,
Int32* budget )
{
Int32 k;
UChar c1, c2;
UInt16 s1, s2;
AssertD ( i1 != i2, "mainGtU" );
/* 1 */
c1 = block[i1]; c2... | movl %edi, %eax
movl %esi, %r10d
movb (%rdx,%r10), %r10b
cmpb %r10b, (%rdx,%rax)
jne 0xdaa4
leal 0x1(%rdi), %eax
leal 0x1(%rsi), %r10d
movb (%rdx,%r10), %r10b
cmpb %r10b, (%rdx,%rax)
jne 0xdaa4
leal 0x2(%rdi), %eax
leal 0x2(%rsi), %r10d
movb (%rdx,%r10), %r10b
cmpb %r10b, (%rdx,%rax)
jne 0xdaa4
leal 0x3(%rdi), %eax
lea... | /SeongGino[P]zdoom/bzip2/blocksort.c |
LzmaEnc_Destruct | void LzmaEnc_Destruct(CLzmaEnc *p, ISzAlloc *alloc, ISzAlloc *allocBig)
{
#ifndef _7ZIP_ST
MatchFinderMt_Destruct(&p->matchFinderMt, allocBig);
#endif
MatchFinder_Free(&p->matchFinderBase, allocBig);
LzmaEnc_FreeLits(p, alloc);
RangeEnc_Free(&p->rc, alloc);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x100, %rdi # imm = 0x100
movq %rdx, %rsi
callq 0x1214b
movq 0x78(%r14), %rsi
movq %rbx, %rdi
callq *0x8(%rbx)
movq 0x3d348(%r14), %rsi
movq %rbx, %rdi
callq *0x8(%rbx)
xorl %r15d, %r15d
movq %r15, 0x78(%r14)
movq %r15, 0x3d348(%r14)
movq... | /SeongGino[P]zdoom/lzma/C/LzmaEnc.c |
LzmaEnc_InitPrices | void LzmaEnc_InitPrices(CLzmaEnc *p)
{
if (!p->fastMode)
{
FillDistancesPrices(p);
FillAlignPrices(p);
}
p->lenEnc.tableSize =
p->repLenEnc.tableSize =
p->numFastBytes + 1 - LZMA_MATCH_LEN_MIN;
LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, p->ProbPrices);
LenPriceEnc_UpdateTables(&p->rep... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x80(%rdi)
jne 0xe8ac
movq %rbx, %rdi
callq 0xe91f
movq %rbx, %rdi
callq 0xeb08
movl 0x44(%rbx), %eax
decl %eax
movl %eax, 0x38f04(%rbx)
movl %eax, 0x346bc(%rbx)
movb 0x68(%rbx), %cl
movl $0x1, %r12d
shll %cl, %r12d
leaq 0x342b8(%rbx), %r... | /SeongGino[P]zdoom/lzma/C/LzmaEnc.c |
LzmaEnc_Encode | SRes LzmaEnc_Encode(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress,
ISzAlloc *alloc, ISzAlloc *allocBig)
{
RINOK(LzmaEnc_Prepare(pp, outStream, inStream, alloc, allocBig));
return LzmaEnc_Encode2((CLzmaEnc *)pp, progress);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq %rdx, 0x148(%rdi)
movl $0x1, 0x90(%rdi)
movq %rsi, 0xe8(%rdi)
xorl %esi, %esi
movq %r8, %rdx
movq %r9, %rcx
callq 0xeb86
testl %eax, %eax
je 0x1149c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
po... | /SeongGino[P]zdoom/lzma/C/LzmaEnc.c |
LzmaEnc_Encode2 | static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress)
{
SRes res = SZ_OK;
#ifndef _7ZIP_ST
Byte allocaDummy[0x300];
allocaDummy[0] = 0;
allocaDummy[1] = allocaDummy[0];
#endif
for (;;)
{
res = LzmaEnc_CodeOneBlock(p, False, 0, 0);
if (res != SZ_OK || p->finished)
break;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xeebd
testl %eax, %eax
je 0x114cf
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %ebx, %ebx
cmpl $0x0, 0x88(%r15)
jne 0x114c7
testq %r14, %r14
je 0x1150d
movq 0x98(%r15), %rsi... | /SeongGino[P]zdoom/lzma/C/LzmaEnc.c |
ReadMatchDistances | static UInt32 ReadMatchDistances(CLzmaEnc *p, UInt32 *numDistancePairsRes)
{
UInt32 lenRes = 0, numPairs;
p->numAvail = p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
numPairs = p->matchFinder.GetMatches(p->matchFinderObj, p->matches);
#ifdef SHOW_STAT
printf("\n i = %u numPairs = %u ", g_STAT_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq *0x10(%r14)
movl %eax, 0x40(%r14)
movq (%r14), %rdi
leaq 0x32780(%r14), %rsi
callq *0x20(%r14)
movl %eax, %r15d
testl %eax, %eax
je 0x11b6b
leal -0x2(%r15), %eax
movl 0x32780(%r14,%rax,4), %r12d
cmpl 0x44(%r14... | /SeongGino[P]zdoom/lzma/C/LzmaEnc.c |
MatchFinder_Normalize3 | void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, size_t numItems)
{
size_t i;
for (i = 0; i < numItems; i++)
{
UInt32 value = items[i];
if (value <= subValue)
value = kEmptyHashValue;
else
value -= subValue;
items[i] = value;
}
} | testq %rdx, %rdx
je 0x12429
xorl %eax, %eax
xorl %ecx, %ecx
movl (%rsi,%rcx,4), %r8d
subl %edi, %r8d
cmovbl %eax, %r8d
movl %r8d, (%rsi,%rcx,4)
incq %rcx
cmpq %rcx, %rdx
jne 0x12412
retq
| /SeongGino[P]zdoom/lzma/C/LzFind.c |
Hc_GetMatchesSpec | static UInt32 * Hc_GetMatchesSpec(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue,
UInt32 *distances, UInt32 maxLen)
{
son[_cyclicBufferPos] = curMatch;
for (;;)
{
UInt32 delta = pos - curMatch;
if (cutV... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x50(%rsp), %r11d
movq 0x48(%rsp), %rax
movq %rax, -0x10(%rsp)
movl 0x40(%rsp), %r10d
movl 0x38(%rsp), %r13d
movl %r9d, %eax
movl %esi, (%r8,%rax,4)
leal -0x1(%rdi), %r14d
negq %r14
movl %r9d, -0x14(%rsp)
movq %r8, -0x8(%rsp)
xorl %r12d, %r12d
addl ... | /SeongGino[P]zdoom/lzma/C/LzFind.c |
Bt3_MatchFinder_Skip | static void Bt3_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
{
do
{
UInt32 h2;
UInt32 *hash;
SKIP_HEADER(3)
HASH3_CALC;
hash = p->hash;
curMatch = hash[kFix3HashSize + hv];
hash[h2] =
hash[kFix3HashSize + hv] = p->pos;
SKIP_FOOTER
}
while (--num != 0);
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x14(%r14), %edi
cmpl $0x2, %edi
ja 0x13094
movq %r14, %rdi
callq 0x12656
jmp 0x1310e
movq (%r14), %rcx
movzbl (%rcx), %eax
movzbl 0x1(%rcx), %edx
xorl 0x78(%r14,%rax,4), %edx
movzbl 0x2(%rcx), %eax
shll $0x8, %eax
xorl %edx, %eax
andl 0x38(%r14), %e... | /SeongGino[P]zdoom/lzma/C/LzFind.c |
log_printf | void log_printf(char const *format, ...)
{
va_list args;
va_start(args, format);
#ifdef ALLEGRO_ANDROID
char x[1024];
vsnprintf(x, sizeof x, format, args);
ALLEGRO_TRACE_CHANNEL_LEVEL("log", 1)("%s", x);
#else
vprintf(format, args);
#endif
va_end(args);
} | subq $0xd8, %rsp
testb %al, %al
je 0x251c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x1... | /guzmandrade[P]allegro5/examples/common.c |
main | int main(int argc, char **argv)
{
ALLEGRO_EVENT_QUEUE *queue;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Error initialising Allegro.\n");
}
if (!al_install_audio() || !al_reserve_samples(128)) {
abort_example("Error initialising audio.\n");
}
al_init_acodec_addon();
... | subq $0x48, %rsp
movl $0x0, 0x44(%rsp)
movl %edi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl $0x85020700, %edi # imm = 0x85020700
leaq 0x2f9f(%rip), %rsi # 0x5550
callq 0x22b0
testb $0x1, %al
jne 0x25c8
leaq 0x3bd3(%rip), %rdi # 0x6194
movb $0x0, %al
callq 0x23f0
callq 0x21f0
testb $0x1, %al
jne 0x25d3
jmp 0... | /guzmandrade[P]allegro5/examples/ex_haiku.c |
init_tokens | static void init_tokens(void)
{
const float token_w = token_size * token_scale;
const float token_x = game_board_x + token_w/2.0;
const float token_y = 80;
int i;
for (i = 0; i < NUM_TOKENS; i++) {
int tx = i % TOKENS_X;
int ty = i / TOKENS_X;
float px = token_x + tx * token_w;
f... | subq $0x28, %rsp
movss 0x368c(%rip), %xmm0 # 0x60a8
movss %xmm0, 0x24(%rsp)
movss 0x367a(%rip), %xmm0 # 0x60a4
movss %xmm0, 0x20(%rsp)
movss 0x3668(%rip), %xmm0 # 0x60a0
movss %xmm0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x80, 0x18(%rsp)
jge 0x2bca
movl 0x18(%rsp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
mov... | /guzmandrade[P]allegro5/examples/ex_haiku.c |
init_glow | static void init_glow(void)
{
init_sprite(&glow, IMG_GLOW, screen_w/2, screen_h, 1.0, 1.0);
glow.align_y = 1.0;
glow.r = glow.g = glow.b = 0.0;
init_sprite(&glow_overlay, IMG_GLOW_OVERLAY, 0.0, 0.0, 1.0, 1.0);
glow_overlay.align_x = 0.0;
glow_overlay.align_y = 0.0;
glow_overlay.r = glow_overlay.g ... | subq $0x48, %rsp
leaq 0x1d9a5(%rip), %rdi # 0x20700
movl $0x6, %esi
movss 0x335c(%rip), %xmm0 # 0x60c4
movss 0x3358(%rip), %xmm1 # 0x60c8
movss 0x333c(%rip), %xmm3 # 0x60b4
movss %xmm3, 0x4(%rsp)
movaps %xmm3, %xmm2
callq 0x3250
movss 0x4(%rsp), %xmm3
movl $0x3f800000, 0x1d982(%rip) # imm = 0x3F800000
m... | /guzmandrade[P]allegro5/examples/ex_haiku.c |
anim_full | static void anim_full(Sprite *spr, float *lval, float start_val, float end_val,
Interp func, float delay, float duration)
{
float start_time;
Anim *anim;
start_time = al_get_time() + delay;
fix_conflicting_anims(spr, lval, start_time, start_val);
anim = get_next_anim(spr);
anim->lval = lval;
a... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movss %xmm0, 0x24(%rsp)
movss %xmm1, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movss %xmm2, 0x18(%rsp)
movss %xmm3, 0x14(%rsp)
callq 0x2260
movss 0x18(%rsp), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x30(%rsp), ... | /guzmandrade[P]allegro5/examples/ex_haiku.c |
get_next_anim | static Anim *get_next_anim(Sprite *spr)
{
static Anim dummy_anim;
unsigned i;
for (i = 0; i < MAX_ANIMS; i++) {
if (spr->anims[i].lval == NULL)
return &spr->anims[i];
}
assert(false);
return &dummy_anim;
} | movq %rdi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0xa, -0x14(%rsp)
jae 0x36b8
movq -0x10(%rsp), %rax
addq $0x30, %rax
movl -0x14(%rsp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x36a9
movq -0x10(%rsp), %rax
addq $0x30, %rax
movl -0x14(%rsp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)... | /guzmandrade[P]allegro5/examples/ex_haiku.c |
update_anims | static void update_anims(float now)
{
Flair *fl;
int i;
for (i = 0; i < NUM_TOKENS; i++)
update_token_anims(&tokens[i], now);
for (i = 0; i < NUM_TYPES; i++)
update_token_anims(&buttons[i], now);
update_sprite_anims(&glow, now);
update_sprite_anims(&glow_overlay, now);
for (fl = fla... | subq $0x18, %rsp
movss %xmm0, 0x14(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x80, 0x4(%rsp)
jge 0x386a
movslq 0x4(%rsp), %rax
leaq 0x56b8(%rip), %rdi # 0x8f00
imulq $0x2f0, %rax, %rax # imm = 0x2F0
addq %rax, %rdi
movss 0x14(%rsp), %xmm0
callq 0x3c70
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x383... | /guzmandrade[P]allegro5/examples/ex_haiku.c |
on_mouse_axes | static void on_mouse_axes(float x, float y)
{
Token *token = get_touched_token(x, y);
if (token == hover_token)
return;
if (hover_token) {
Sprite *spr = &hover_token->bot;
anim_to(spr, &spr->opacity, 0.4, INTERP_DOUBLE_SLOW, 0.2);
}
hover_token = token;
if (hover_token) {
S... | subq $0x28, %rsp
movss %xmm0, 0x24(%rsp)
movss %xmm1, 0x20(%rsp)
movss 0x24(%rsp), %xmm0
movss 0x20(%rsp), %xmm1
callq 0x5230
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x46b6(%rip), %rax # 0x8198
jne 0x3ae9
jmp 0x3b79
cmpq $0x0, 0x46a7(%rip) # 0x8198
je 0x3b2b
movq 0x469e(%rip), %rax # 0x8198
addq... | /guzmandrade[P]allegro5/examples/ex_haiku.c |
draw_sprite | static void draw_sprite(const Sprite *spr)
{
ALLEGRO_BITMAP *bmp;
ALLEGRO_COLOR tint;
float cx, cy;
bmp = images[spr->image];
cx = spr->align_x * al_get_bitmap_width(bmp);
cy = spr->align_y * al_get_bitmap_height(bmp);
tint = al_map_rgba_f(spr->r, spr->g, spr->b, spr->opacity);
al_draw_tinted_... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x4bc7(%rip), %rax # 0x8d90
movq (%rax,%rcx,8), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2240
movss 0x10(%rsp), %xmm0
cvtsi2ss %ea... | /guzmandrade[P]allegro5/examples/ex_haiku.c |
mbedtls_aes_setkey_dec | int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits )
{
int i, j, ret;
mbedtls_aes_context cty;
uint32_t *RK;
uint32_t *SK;
AES_VALIDATE_RET( ctx != NULL );
AES_VALIDATE_RET( key != NULL );
mbedtls_aes_init( &cty );
#if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movl $0x120, %edx # imm = 0x120
movq %r12, %rdi
xorl %esi, %esi
callq 0x30d0
leaq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
movq %r12, ... | /ARMmbed[P]mbed-crypto/library/aes.c |
mbedtls_aes_crypt_ofb | int mbedtls_aes_crypt_ofb( mbedtls_aes_context *ctx,
size_t length,
size_t *iv_off,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
int ret = 0;
size... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq (%rdx), %rbx
movl $0xffffffdf, %eax # imm = 0xFFFFFFDF
cmpq $0xf, %rbx
ja 0x5999
movq %rsi, %r13
movq %rdx, 0x8(%rsp)
testq %rsi, %rsi
je 0x598f
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
xorl %ebp, %e... | /ARMmbed[P]mbed-crypto/library/aes.c |
mbedtls_aesni_gcm_mult | void mbedtls_aesni_gcm_mult( unsigned char c[16],
const unsigned char a[16],
const unsigned char b[16] )
{
unsigned char aa[16], bb[16], cc[16];
size_t i;
/* The inputs are in big-endian order, so byte-reverse them */
for( i = 0; i < 16; i++ )
{
aa[... | movl $0x10, %eax
xorl %ecx, %ecx
movb -0x1(%rsi,%rax), %r8b
movb %r8b, -0x18(%rsp,%rcx)
movb -0x1(%rdx,%rax), %r8b
movb %r8b, -0x28(%rsp,%rcx)
incq %rcx
decq %rax
jne 0x64c6
leaq -0x18(%rsp), %rax
leaq -0x28(%rsp), %rcx
leaq -0x38(%rsp), %rdx
movdqu (%rax), %xmm0
movdqu (%rcx), %xmm1
movdqa %xmm1, %xmm2
movdqa %xmm1, %... | /ARMmbed[P]mbed-crypto/library/aesni.c |
mbedtls_md_clone | int mbedtls_md_clone( mbedtls_md_context_t *dst,
const mbedtls_md_context_t *src )
{
if( dst == NULL || dst->md_info == NULL ||
src == NULL || src->md_info == NULL ||
dst->md_info != src->md_info )
{
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
}
switch( src->m... | movl $0xffffaf00, %eax # imm = 0xFFFFAF00
testq %rdi, %rdi
je 0x6a8a
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testq %rsi, %rsi
sete %r8b
orb %dl, %r8b
jne 0x6a8a
movq (%rsi), %rdx
cmpq %rdx, %rcx
je 0x6a8b
retq
pushq %rax
movl 0x8(%rdx), %ecx
addl $-0x3, %ecx
cmpl $0x6, %ecx
ja 0x6af2
leaq 0x6e4e(%rip), %rax ... | /ARMmbed[P]mbed-crypto/library/md.c |
mbedtls_md_hmac_starts | int mbedtls_md_hmac_starts( mbedtls_md_context_t *ctx, const unsigned char *key, size_t keylen )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
unsigned char sum[MBEDTLS_MD_MAX_SIZE];
unsigned char *ipad, *opad;
size_t i;
if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl $0xffffaf00, %ebp # imm = 0xFFFFAF00
testq %rdi, %rdi
je 0x6fec
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x6fec
cmpq $0x0, 0x10(%rbx)
je 0x6fec
movq %rdx, %r15
movq %rsi, %r14
movzbl 0xd(%rax), %eax
cmpq %rdx, %ra... | /ARMmbed[P]mbed-crypto/library/md.c |
mbedtls_ripemd160_update_ret | int mbedtls_ripemd160_update_ret( mbedtls_ripemd160_context *ctx,
const unsigned char *input,
size_t ilen )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t fill;
uint32_t left;
if( ilen == 0 )
return( 0 );
left =... | testq %rdx, %rdx
je 0x9406
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movl %ecx, %eax
andl $0x3f, %eax
movl %edx, %esi
addl %ecx, %esi
movl %esi, (%rdi)
jae 0x9375
incl 0x4(%r14)
xorl %ebp, %ebp
testl %eax, %eax
je 0x9393
movl $0x40, %r... | /ARMmbed[P]mbed-crypto/library/ripemd160.c |
mbedtls_ripemd160_ret | int mbedtls_ripemd160_ret( const unsigned char *input,
size_t ilen,
unsigned char output[20] )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
mbedtls_ripemd160_context ctx;
mbedtls_ripemd160_init( &ctx );
if( ( ret = mbedtls_ripemd160_starts_re... | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movaps %xmm0, 0x10(%r14)
movups %xmm0, 0x4c(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movabsq $-0x1032547698badcff, %rax # imm = 0xEFCDAB8... | /ARMmbed[P]mbed-crypto/library/ripemd160.c |
mbedtls_sha1_finish_ret | int mbedtls_sha1_finish_ret( mbedtls_sha1_context *ctx,
unsigned char output[20] )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
uint32_t used;
uint32_t high, low;
SHA1_VALIDATE_RET( ctx != NULL );
SHA1_VALIDATE_RET( (unsigned char *)output != NULL );
/*
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rbp
movl (%rdi), %edx
andl $0x3f, %edx
leaq 0x1c(%rdi), %r14
addq %rdx, %rdi
addq $0x1d, %rdi
movb $-0x80, -0x1(%rdi)
cmpl $0x37, %edx
ja 0xa8ba
movl $0x37, %eax
subl %edx, %eax
xorl %esi, %esi
movq %rax, %rdx
callq 0x30d0
jmp 0xa8e8
xorl $0x3f, %edx
xorl %es... | /ARMmbed[P]mbed-crypto/library/sha1.c |
mbedtls_sha1_self_test | int mbedtls_sha1_self_test( int verbose )
{
int i, j, buflen, ret = 0;
unsigned char buf[1024];
unsigned char sha1sum[20];
mbedtls_sha1_context ctx;
mbedtls_sha1_init( &ctx );
/*
* SHA-1
*/
for( i = 0; i < 3; i++ )
{
if( verbose != 0 )
mbedtls_printf( " S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x488, %rsp # imm = 0x488
movl %edi, %ebx
pxor %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movdqu %xmm0, 0x4c(%r14)
movdqa %xmm0, 0x40(%r14)
movdqa %xmm0, 0x30(%r14)
movdqa %xmm0, 0x20(%r14)
movdqa %xmm0, 0x10(%r14)
movdqa %xmm0, (%r14)
leaq 0x80... | /ARMmbed[P]mbed-crypto/library/sha1.c |
mbedtls_sha256_self_test | int mbedtls_sha256_self_test( int verbose )
{
int i, j, k, buflen, ret = 0;
unsigned char *buf;
unsigned char sha256sum[32];
mbedtls_sha256_context ctx;
buf = mbedtls_calloc( 1024, sizeof(unsigned char) );
if( NULL == buf )
{
if( verbose != 0 )
mbedtls_printf( "Buffer al... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edi, %ebp
movl $0x400, %edi # imm = 0x400
movl $0x1, %esi
callq 0x30e0
testq %rax, %rax
je 0xbb6b
movq %rax, %rbx
movl %ebp, 0xc(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movups %xmm0, 0x5c(%r14)
movaps %xmm0, 0x50(... | /ARMmbed[P]mbed-crypto/library/sha256.c |
PointDiffRetractation_invoker() | BOOST_AUTO_TEST_CASE(PointDiffRetractation)
{
SO3<ExpMapMatrix> S;
Eigen::MatrixXd J;
Eigen::MatrixXd Jtest(9, 3);
Jtest << 0, 0.003580526006716, -0.558259982176135, 0, 0.646068748944272,
0.634553549147103, 0, -0.763270824459509, 0.534497507539106,
-0.003580526006716, 0, -0.829658346630838, -0.64606... | pushq %rbp
movq %rsp, %rbp
subq $0x9c0, %rsp # imm = 0x9C0
movq 0x6941e(%rip), %rax # 0xee440
movq %rax, -0x8e8(%rbp)
leaq 0x3b241(%rip), %rsi # 0xc0271
leaq -0x10(%rbp), %rdi
movl $0x6a, %edx
callq 0x89000
leaq -0x1b8(%rbp), %rdi
movq %rdi, -0x8e0(%rbp)
xorl %esi, %esi
movl $0x198, %edx #... | /stanislas-brossette[P]manifolds/tests/PointTest.cpp |
PointDiffRetractation::test_method() | BOOST_AUTO_TEST_CASE(PointDiffRetractation)
{
SO3<ExpMapMatrix> S;
Eigen::MatrixXd J;
Eigen::MatrixXd Jtest(9, 3);
Jtest << 0, 0.003580526006716, -0.558259982176135, 0, 0.646068748944272,
0.634553549147103, 0, -0.763270824459509, 0.534497507539106,
-0.003580526006716, 0, -0.829658346630838, -0.64606... | pushq %rbp
movq %rsp, %rbp
subq $0x500, %rsp # imm = 0x500
movq %rdi, -0x8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x89e10
leaq -0xc0(%rbp), %rdi
callq 0x8a780
jmp 0x85639
movl $0x9, -0xec(%rbp)
movl $0x3, -0xf0(%rbp)
leaq -0xe8(%rbp), %rdi
leaq -0xec(%rbp), %rsi
leaq -0xf0(%rbp), %rdx
callq 0x8a7a0
jmp 0x85669
m... | /stanislas-brossette[P]manifolds/tests/PointTest.cpp |
PointApplyDiff::test_method() | BOOST_AUTO_TEST_CASE(PointApplyDiff)
{
int c = 5;
SO3<ExpMapMatrix> S;
Index dim = S.dim();
Index repDim = S.representationDim();
Eigen::MatrixXd Jf = Eigen::MatrixXd::Random(c, repDim);
Point x = S.getZero();
x.retractation(x, Eigen::VectorXd::Random(dim));
Eigen::MatrixXd expectedRes;
expectedRes = ... | pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp # imm = 0x400
movq %rdi, -0x8(%rbp)
movl $0x5, -0xc(%rbp)
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x3b0(%rbp)
callq 0x89e10
movq -0x3b0(%rbp), %rdi
callq 0x7b470
movq %rax, -0x3a8(%rbp)
jmp 0x864ee
movq -0x3a8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
c... | /stanislas-brossette[P]manifolds/tests/PointTest.cpp |
PointInvDiff_invoker() | BOOST_AUTO_TEST_CASE(PointInvDiff)
{
SO3<ExpMapMatrix> S;
Eigen::MatrixXd J;
Eigen::MatrixXd Jtest(3, 9);
Jtest << -0.064043491813865, 0, 0, 0, -0.064043491813865, 0.545030346992499,
0, -0.545030346992499, -0.064043491813865, -0.110117993664377, 0,
-0.545030346992499, 0, -0.110117993664377, 0, 0.545... | pushq %rbp
movq %rsp, %rbp
subq $0x9c0, %rsp # imm = 0x9C0
movq 0x67a5e(%rip), %rax # 0xee440
movq %rax, -0x8e8(%rbp)
leaq 0x39881(%rip), %rsi # 0xc0271
leaq -0x10(%rbp), %rdi
movl $0x6a, %edx
callq 0x89000
leaq -0x1b8(%rbp), %rdi
movq %rdi, -0x8e0(%rbp)
xorl %esi, %esi
movl $0x198, %edx #... | /stanislas-brossette[P]manifolds/tests/PointTest.cpp |
mnf::RealSpace::~RealSpace() | class MANIFOLDS_API RealSpace : public Manifold
{
public:
/// \brief Constructor
/// \param n the dimension of the realspace \f$\mathbb{R}^n\f$
RealSpace(Index n);
RealSpace(Index n, double magnitude);
RealSpace(Index n, const ConstRefVec& magnitude);
virtual size_t numberOfSubManifolds() const;
virtual... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq 0x64695(%rip), %rax # 0xedf70
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x68, %rdi
callq 0x89df0
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x89df0
movq -0x10(%rbp), %rdi
callq 0x7b460
addq $0x10, %... | /stanislas-brossette[P]manifolds/include/manifolds/RealSpace.h |
mnf::PointMemory::~PointMemory() | class MANIFOLDS_API PointMemory
{
protected:
PointMemory(Index size);
PointMemory(const ConstRefVec& v);
Eigen::VectorXd& getMem();
private:
Eigen::VectorXd mem_;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x89df0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /stanislas-brossette[P]manifolds/include/manifolds/Point.h |
swap_yuv2yuv420 | void swap_yuv2yuv420(swap_image_yuv_t *im) {
size_t w = im->w, h = im->h, i, j;
unsigned char *u = im->u, *v = im->v;
for (j = 0; j < h; j += 2)
for (i = 0; i < w; i += 2) {
int val;
size_t idx = (j / 2) * (w / 2) + (i / 2);
val = ((int) u[j * w + i] +
... | movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x7920
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x18(%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rcx, %rdi
shrq %rdi
leaq (%rsi,%rcx), %r8
incq %r8
leaq (%rcx,%rcx), %r9
leaq (%rdx,%rcx), %r10
incq %r10
leaq 0x1(%rsi), %r11
leaq 0x... | /Helioviewer-Project[P]fits2img/libsidc/libswap/swap_color.c |
jpeg_error_exit | static void jpeg_error_exit(j_common_ptr cinfo) {
char msg[JMSG_LENGTH_MAX];
/* fatal, subsequent code will not be executed */
cinfo->err->format_message(cinfo, msg);
P2SC_Msg(LVL_FATAL_INTERNAL_ERROR, "libjpeg: %s", msg);
/*
struct my_err_mgr *myerr = (struct my_err_mgr *) cinfo->err;
longjmp(... | pushq %rbx
subq $0xe0, %rsp
movq (%rdi), %rax
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq *0x18(%rax)
movq %rbx, (%rsp)
leaq 0x44e94(%rip), %rdi # 0x4d49c
leaq 0x44c3e(%rip), %rsi # 0x4d24d
leaq 0x44eda(%rip), %rcx # 0x4d4f0
leaq 0x44e8f(%rip), %r9 # 0x4d4ac
movl $0x81, %edx
movl $0x12c0, %r8d ... | /Helioviewer-Project[P]fits2img/libsidc/libswap/swap_file.c |
swap_read_pgm | guint16 *swap_read_pgm(const char *name, size_t *w, size_t *h) {
FILE *f;
int c, i, len, isize, width, height, maxval;
guint16 *ret = NULL;
if (!(f = fopen(name, "rb")))
P2SC_Msg(LVL_FATAL_FILESYSTEM, "%s: %s", name, g_strerror(errno));
c = fgetc(f);
if (c != 'P')
P2SC_Msg(LVL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x449d6(%rip), %rsi # 0x4d323
callq 0x5210
testq %rax, %rax
je 0x8b37
movq %rax, %r12
movq %rax, %rdi
callq 0x53f0
cmpl $0x50, %eax
jne 0x8b6f
movq %r12, %rdi
callq 0x53f0
cmpl $0x... | /Helioviewer-Project[P]fits2img/libsidc/libswap/swap_file.c |
p2sc_free_keyfile | void p2sc_free_keyfile(p2sc_keyfile_t *k) {
if (k) {
if (k->key)
g_key_file_free(k->key);
g_free(k->name);
memset(k, 0, sizeof *k);
g_free(k);
}
} | testq %rdi, %rdi
je 0xa09f
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa087
callq 0x5720
movq 0x8(%rbx), %rdi
callq 0x5890
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x5890
retq
| /Helioviewer-Project[P]fits2img/libsidc/libp2sc/p2sc_file.c |
p2sc_strip_strings | void p2sc_strip_strings(char ***sss) {
char **ss = *sss, *s;
guint i, n = g_strv_length(ss);
GArray *a = g_array_sized_new(TRUE, FALSE, sizeof(char *), n);
for (i = 0; i < n; ++i) {
s = g_strstrip(ss[i]);
if (!*s)
g_free(s);
else
g_array_append_val(a, s);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
callq 0x52c0
movl %eax, %ebp
movl $0x1, %edi
xorl %esi, %esi
movl $0x8, %edx
movl %eax, %ecx
callq 0x54d0
movq %rax, %r15
testl %ebp, %ebp
je 0xab6c
movl %ebp, %r13d
xorl %ebp, %ebp
movq %rsp, ... | /Helioviewer-Project[P]fits2img/libsidc/libp2sc/p2sc_file.c |
p2sc_dirscan | char **p2sc_dirscan(const char *name) {
gboolean segfree = TRUE;
char **ret = NULL;
if (far)
P2SC_Msg(LVL_FATAL_INTERNAL_ERROR, "far != NULL");
else
far = g_array_new(TRUE, FALSE, sizeof(char *));
if (nftw(name, descend, 64, 0) == -1)
P2SC_Msg(LVL_FATAL_FILESYSTEM, "nftw(%s... | pushq %rbx
cmpq $0x0, 0x56def(%rip) # 0x61c58
jne 0xaebc
movq %rdi, %rbx
movl $0x1, %edi
xorl %esi, %esi
movl $0x8, %edx
callq 0x51f0
movq %rax, 0x56dd2(%rip) # 0x61c58
leaq 0xad(%rip), %rsi # 0xaf3a
movq %rbx, %rdi
movl $0x40, %edx
xorl %ecx, %ecx
callq 0x5810
cmpl $-0x1, %eax
je 0xaeec
movq 0x56db0(%ri... | /Helioviewer-Project[P]fits2img/libsidc/libp2sc/p2sc_file.c |
set_signals | static inline void set_signals(sig_t handler) {
signal(SIGABRT, handler);
signal(SIGILL, handler);
signal(SIGSEGV, handler);
signal(SIGFPE, handler);
signal(SIGBUS, handler);
signal(SIGPIPE, handler);
} | pushq %rbx
movq %rdi, %rbx
movl $0x6, %edi
movq %rbx, %rsi
callq 0x54c0
movl $0x4, %edi
movq %rbx, %rsi
callq 0x54c0
movl $0xb, %edi
movq %rbx, %rsi
callq 0x54c0
movl $0x8, %edi
movq %rbx, %rsi
callq 0x54c0
movl $0x7, %edi
movq %rbx, %rsi
callq 0x54c0
movl $0xd, %edi
movq %rbx, %rsi
popq %rbx
jmp 0x54c0
| /Helioviewer-Project[P]fits2img/libsidc/libp2sc/p2sc_stdlib.c |
p2sc_init | void p2sc_init(const char *prgname, const char *appname, const char *filename, const char *runid) {
/* change of prg/appname/runid not allowed */
if (prgname && !p2sc_get_string("prgname"))
p2sc_set_string("prgname", prgname);
if (appname && !p2sc_get_string("appname"))
p2sc_set_string("appn... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
testq %rdi, %rdi
je 0xb4b4
movq %rdi, %r12
movq 0x567d1(%rip), %rdi # 0x61c60
testq %rdi, %rdi
je 0xb4a5
leaq 0x42b6b(%rip), %rsi # 0x4e006
callq 0x55c0
testq %rax, %rax
jne 0xb4b4
leaq 0x42b5a(%rip), %rdi ... | /Helioviewer-Project[P]fits2img/libsidc/libp2sc/p2sc_stdlib.c |
p2sc_spawn_many | void p2sc_spawn_many(const char **cmd, int num) {
int i, status;
GError *err = NULL;
GPid *pid = (GPid *) g_malloc(num * sizeof *pid);
for (i = 0; i < num; ++i) {
gint argc;
gchar **argv;
if (!g_shell_parse_argv(cmd[i], &argc, &argv, &err)) {
if (err && err->message... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movslq %esi, %rbx
leaq (,%rbx,4), %rdi
callq 0x5270
movq %rax, %r14
testl %ebx, %ebx
jle 0xba79
movl %ebp, 0x24(%rsp)
movl %ebp, %eax
movq %rax, 0x28(%rsp)
leaq (,%rax,4), %rbx
x... | /Helioviewer-Project[P]fits2img/libsidc/libp2sc/p2sc_stdlib.c |
prepare_for_pass | METHODDEF(void)
prepare_for_pass (j_compress_ptr cinfo)
{
my_master_ptr master = (my_master_ptr) cinfo->master;
switch (master->pass_type) {
case main_pass:
/* Initial pass: will collect input data, and do either Huffman
* optimization or data output for the first scan.
*/
select_scan_parameter... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1f0(%rdi), %r14
movl 0x20(%r14), %eax
cmpl $0x2, %eax
je 0xe1c4
cmpl $0x1, %eax
je 0xe161
testl %eax, %eax
jne 0xe19e
movq %rbx, %rdi
callq 0xe2e5
movq %rbx, %rdi
callq 0xe46a
cmpl $0x0, 0x120(%rbx)
jne 0xe102
movq 0x218(%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
m... | /Helioviewer-Project[P]fits2img/support/jpeg/jpeg-8d/jcmaster.c |
jpeg_set_colorspace | GLOBAL(void)
jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
{
jpeg_component_info * compptr;
int ci;
#define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \
(compptr = &cinfo->comp_info[index], \
compptr->component_id = (id), \
compptr->h_samp_factor = (hsamp), \
compptr->v_sam... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x24(%rdi), %eax
cmpl $0x64, %eax
je 0xeab4
movq (%rbx), %rcx
movl $0x15, 0x28(%rcx)
movl %eax, 0x2c(%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl %ebp, 0x60(%rbx)
xorl %eax, %eax
movl %eax, 0x144(%rbx)
movl %eax, 0x150(%rbx)
cmpl $0x5, ... | /Helioviewer-Project[P]fits2img/support/jpeg/jpeg-8d/jcparam.c |
jinit_c_prep_controller | GLOBAL(void)
jinit_c_prep_controller (j_compress_ptr cinfo, boolean need_full_buffer)
{
my_prep_ptr prep;
int ci;
jpeg_component_info * compptr;
if (need_full_buffer) /* safety check */
ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
prep = (my_prep_ptr)
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r12
testl %esi, %esi
je 0xf1e9
movq (%r12), %rax
movl $0x3, 0x28(%rax)
movq %r12, %rdi
callq *(%rax)
movq 0x8(%r12), %rax
movl $0x70, %edx
movq %r12, %rdi
movl $0x1, %esi
callq *(%rax)
movq %rax, 0x200(%r12)
leaq 0x1f2(%rip),... | /Helioviewer-Project[P]fits2img/support/jpeg/jpeg-8d/jcprepct.c |
pre_process_context | METHODDEF(void)
pre_process_context (j_compress_ptr cinfo,
JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
JDIMENSION in_rows_avail,
JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
JDIMENSION out_row_groups_avail)
{
my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
int numrows, ci;
int... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x40(%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, 0x38(%rsp)
movl 0x80(%rsp), %eax
cmpl %eax, (%r9)
jae 0xf681
movq %r9, %r12
movl %ecx, %ebx
movq %rdi, %r13
movq 0x200(%rdi), %rdx
movl 0x160(%rdi), %eax
leal (%rax,%rax,2), %eax
movl... | /Helioviewer-Project[P]fits2img/support/jpeg/jpeg-8d/jcprepct.c |
h2v2_downsample | METHODDEF(void)
h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
JSAMPARRAY input_data, JSAMPARRAY output_data)
{
int inrow, outrow;
JDIMENSION outcol;
JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size;
register JSAMPROW inptr0, inptr1, outptr;
register int... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl 0x24(%rsi), %r13d
imull 0x1c(%rsi), %r13d
movslq 0x160(%rdi), %rbp
testq %rbp, %rbp
movq %rdi, 0x8(%rsp)
jle 0x101bb
movl 0x30(%rdi), %ebx
leal (,%r13,2), %r12d
movl %r12d, %eax
subl %ebx, %eax
testl %eax, %eax
jle 0... | /Helioviewer-Project[P]fits2img/support/jpeg/jpeg-8d/jcsample.c |
empty_output_buffer | METHODDEF(boolean)
empty_output_buffer (j_compress_ptr cinfo)
{
my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) !=
(size_t) OUTPUT_BUF_SIZE)
ERREXIT(cinfo, JERR_FILE_WRITE);
dest->pub.next_output_byte = dest->buffer;
dest->pub.free_in_buffer = ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x28(%r14), %rcx
movq 0x30(%r14), %rdi
movl $0x1, %esi
movl $0x1000, %edx # imm = 0x1000
callq 0x5780
cmpq $0x1000, %rax # imm = 0x1000
je 0x10460
movq (%rbx), %rax
movl $0x26, 0x28(%rax)
movq %rbx, %rdi
callq *(%rax)
movq 0... | /Helioviewer-Project[P]fits2img/support/jpeg/jpeg-8d/jdatadst.c |
emit_message | METHODDEF(void)
emit_message (j_common_ptr cinfo, int msg_level)
{
struct jpeg_error_mgr * err = cinfo->err;
if (msg_level < 0) {
/* It's a warning message. Since corrupt files may generate many warnings,
* the policy implemented here is to show only the first warning,
* unless trace_level >= 3.
... | movq (%rdi), %rcx
testl %esi, %esi
js 0x10734
cmpl %esi, 0x7c(%rcx)
jge 0x10763
retq
pushq %rbx
movq 0x80(%rcx), %rax
testq %rax, %rax
je 0x10747
cmpl $0x3, 0x7c(%rcx)
jl 0x10757
movq %rcx, %rbx
callq *0x10(%rcx)
movq %rbx, %rcx
movq 0x80(%rbx), %rax
incq %rax
movq %rax, 0x80(%rcx)
popq %rbx
retq
jmpq *0x10(%rcx)
| /Helioviewer-Project[P]fits2img/support/jpeg/jpeg-8d/jerror.c |
alloc_small | METHODDEF(void *)
alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
/* Allocate a "small" object */
{
my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
small_pool_ptr hdr_ptr, prev_hdr_ptr;
char * data_ptr;
size_t odd_bytes, min_request, slop;
/* Check for unsatisfiable request (do now to ensure no ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x8(%rdi), %r15
cmpq $0x3b9ac9e9, %rdx # imm = 0x3B9AC9E9
jb 0x10a5e
movq (%r14), %rax
movabsq $0x100000038, %rcx # imm = 0x100000038
movq %rcx, 0x28(%rax)
movq (%r14), %rax... | /Helioviewer-Project[P]fits2img/support/jpeg/jpeg-8d/jmemmgr.c |
alloc_sarray | METHODDEF(JSAMPARRAY)
alloc_sarray (j_common_ptr cinfo, int pool_id,
JDIMENSION samplesperrow, JDIMENSION numrows)
/* Allocate a 2-D sample array */
{
my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
JSAMPARRAY result;
JSAMPROW workspace;
JDIMENSION rowsperchunk, currow, i;
long ltemp;
/* Calculate max # o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r13d
movl %esi, 0x4(%rsp)
movq %rdi, %r14
movq 0x8(%rdi), %r12
movl $0x3b9ac9e8, %eax # imm = 0x3B9AC9E8
xorl %edx, %edx
divl %r13d
movl %eax, %r15d
cmpl $0x3b9ac9e9, %r13d # imm = 0x3B9AC9E9
jb 0x10c8b
m... | /Helioviewer-Project[P]fits2img/support/jpeg/jpeg-8d/jmemmgr.c |
alloc_barray | METHODDEF(JBLOCKARRAY)
alloc_barray (j_common_ptr cinfo, int pool_id,
JDIMENSION blocksperrow, JDIMENSION numrows)
/* Allocate a 2-D coefficient-block array */
{
my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
JBLOCKARRAY result;
JBLOCKROW workspace;
JDIMENSION rowsperchunk, currow, i;
long ltemp;
/* Calc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ecx
movl %esi, 0x4(%rsp)
movq %rdi, %r14
movq 0x8(%rdi), %r12
movl %edx, %r13d
shlq $0x7, %r13
movl $0x3b9ac9e8, %eax # imm = 0x3B9AC9E8
xorl %edx, %edx
divq %r13
movq %rax, %r15
cmpl $0x773594, %ecx #... | /Helioviewer-Project[P]fits2img/support/jpeg/jpeg-8d/jmemmgr.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.