name string | code string | asm string | file string |
|---|---|---|---|
cfg_append_printable_line | int
cfg_append_printable_line(struct autobuf *autobuf, const char *fmt, ...) {
unsigned char *_value;
size_t len;
int rv;
va_list ap;
if (autobuf == NULL)
return 0;
_value = (unsigned char *)abuf_getptr(autobuf) + abuf_getlen(autobuf);
len = abuf_getlen(autobuf);
va_start(ap, fmt);
rv = abuf_va... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x4840d
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rs... | /OLSR[P]OONF/src/libconfig/cfg.c |
cfg_avlcmp_keys | int
cfg_avlcmp_keys(const void *p1, const void *p2) {
const char *str1 = p1;
const char *str2 = p2;
if (str1 == NULL) {
return str2 == NULL ? 0 : -1;
}
if (str2 == NULL) {
return 1;
}
return strcasecmp(str1, str2);
} | testq %rdi, %rdi
je 0x484d8
testq %rsi, %rsi
jne 0x19080
pushq $0x1
popq %rax
retq
xorl %eax, %eax
negq %rsi
sbbl %eax, %eax
retq
| /OLSR[P]OONF/src/libconfig/cfg.c |
oonf_cfg_init | int
oonf_cfg_init(int argc, char **argv, const char *default_cfg_handler) {
struct oonf_subsystem *plugin;
_oonf_cfg_instance.default_io = default_cfg_handler;
cfg_add(&_oonf_cfg_instance);
/* initialize default for lockfile */
_global_entries[IDX_LOCKFILE].def.value = oonf_log_get_appdata()->default_lockfi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq %rdx, 0x56e58(%rip) # 0x9f3f8
leaq 0x56e29(%rip), %rdi # 0x9f3d0
callq 0x482fc
callq 0x49564
movq 0x20(%rax), %rax
movq %rax, 0x403d4(%rip) # 0x88990
callq 0x49564
movq 0x20(%rax), %rdi
callq 0x191b0... | /OLSR[P]OONF/src/libcore/oonf_cfg.c |
oonf_cfg_update_globalcfg | int
oonf_cfg_update_globalcfg(bool raw) {
struct cfg_named_section *named;
int result;
named = cfg_db_find_namedsection(raw ? _oonf_raw_db : _oonf_work_db, CFG_SECTION_GLOBAL, NULL);
result = cfg_schema_tobin(&config_global, named, _global_entries, ARRAYSIZE(_global_entries));
/* set plugin path */
oonf_... | pushq %rbx
leaq 0x566d1(%rip), %rax # 0x9f460
leaq 0x566d2(%rip), %rcx # 0x9f468
testl %edi, %edi
cmovneq %rax, %rcx
movq (%rcx), %rdi
leaq 0x14e66(%rip), %rsi # 0x5dc0c
xorl %edx, %edx
callq 0x45f54
leaq 0x566bc(%rip), %rdi # 0x9f470
leaq 0x3f865(%rip), %rdx # 0x88620
pushq $0x6
popq %rcx
movq %rax... | /OLSR[P]OONF/src/libcore/oonf_cfg.c |
oonf_cfg_rollback | int
oonf_cfg_rollback(void) {
struct cfg_db *db;
/* remember old db */
db = _oonf_raw_db;
OONF_INFO(LOG_CONFIG, "Rollback configuration");
_oonf_raw_db = cfg_db_duplicate(_oonf_work_db);
if (_oonf_raw_db == NULL) {
OONF_WARN(LOG_CONFIG, "Cannot create raw configuration database.");
_oonf_raw_db =... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x56674(%rip), %rbx # 0x9f460
leaq 0x5672d(%rip), %r13 # 0x9f520
testb $0x2, 0x3(%r13)
je 0x48e24
leaq 0x14df4(%rip), %rax # 0x5dbf5
movq %rax, (%rsp)
leaq 0x14c80(%rip), %rdx # 0x5da8c
pushq $0x2
popq %rdi
pushq $0x3
popq %rsi... | /OLSR[P]OONF/src/libcore/oonf_cfg.c |
oonf_cfg_clear_rawdb | int
oonf_cfg_clear_rawdb(void) {
struct cfg_db *db;
/* remember old db */
db = _oonf_raw_db;
/* initialize database */
if ((_oonf_raw_db = cfg_db_add()) == NULL) {
OONF_WARN(LOG_CONFIG, "Cannot create raw configuration database.");
_oonf_raw_db = db;
return -1;
}
/* free old db */
cfg_db_... | pushq %rbx
subq $0x10, %rsp
movq 0x56595(%rip), %rbx # 0x9f460
callq 0x45abc
movq %rax, 0x56589(%rip) # 0x9f460
testq %rax, %rax
je 0x48efa
movq %rbx, %rdi
callq 0x45ae6
movq 0x56575(%rip), %rax # 0x9f460
leaq 0x5650e(%rip), %rcx # 0x9f400
movq %rcx, 0x28(%rax)
xorl %eax, %eax
jmp 0x48f3b
leaq 0x5661f(%... | /OLSR[P]OONF/src/libcore/oonf_cfg.c |
oonf_log_register_source | int
oonf_log_register_source(const char *name) {
size_t i, len;
/* maybe the source is already there ? */
for (i = 0; i < _source_count; i++) {
if (strcmp(name, LOG_SOURCE_NAMES[i]) == 0) {
return i;
}
}
if (i == LOG_MAXIMUM_SOURCES) {
OONF_WARN(LOG_LOGGING,
"Maximum number of loggin... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x3f8ad(%rip), %r12 # 0x88ad0
movq 0x562a6(%rip), %rbx # 0x9f4d0
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x4924b
movq (%r12), %rsi
movq %r14, %rdi
callq 0x19360
testl %eax, %eax
je 0x4927f
incq %r15
addq $0x8, %r12
jmp 0x4922d
cmpq $0x80, ... | /OLSR[P]OONF/src/libcore/oonf_logging.c |
oonf_logcfg_cleanup | void
oonf_logcfg_cleanup(void) {
/* clean up former handlers */
if (list_is_node_added(&_stderr_handler._node)) {
oonf_log_removehandler(&_stderr_handler);
}
if (list_is_node_added(&_syslog_handler._node)) {
oonf_log_removehandler(&_syslog_handler);
}
if (list_is_node_added(&_file_handler._node)) {
... | pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x3f827(%rip) # 0x88fc8
je 0x497b9
cmpq $0x0, 0x3f825(%rip) # 0x88fd0
je 0x497b9
leaq 0x3f814(%rip), %rdi # 0x88fc8
callq 0x4913a
cmpq $0x0, 0x3f927(%rip) # 0x890e8
je 0x497d9
cmpq $0x0, 0x3f925(%rip) # 0x890f0
je 0x497d9
leaq 0x3f914(%rip), %rdi # 0x8... | /OLSR[P]OONF/src/libcore/oonf_logging_cfg.c |
apply_log_setting | static void
_apply_log_setting(struct cfg_named_section *named, const char *entry_name, enum oonf_log_severity severity) {
struct cfg_entry *entry;
char *ptr;
size_t i;
entry = cfg_db_get_entry(named, entry_name);
if (entry) {
strarray_for_each_element(&entry->val, ptr) {
for (i = 0; i < oonf_log_g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
addq $0x48, %rdi
callq 0x424c4
testq %rax, %rax
je 0x49bf0
movq %rax, %r14
movq 0x40(%rax), %r15
leaq 0x3ef30(%rip), %r12 # 0x88ad0
leaq 0x55bf9(%rip), %r13 # 0x9f7a0
testq %r15, %r15
je 0x49bf0
movq 0x48(%r14), %rax
ad... | /OLSR[P]OONF/src/libcore/oonf_logging_cfg.c |
oonf_subsystem_init | int
oonf_subsystem_init(void) {
if (abuf_init(&_dlopen_data_buffer)) {
return -1;
}
_init_plugin_tree();
/* load predefined values for dlopen templates */
_dlopen_data[IDX_DLOPEN_PRE].value = oonf_log_get_libdata()->sharedlibrary_prefix;
_dlopen_data[IDX_DLOPEN_POST].value = oonf_log_get_libdata()->sh... | pushq %rax
leaq 0x55018(%rip), %rdi # 0x9f8e0
callq 0x41ea0
testl %eax, %eax
je 0x4a8d6
pushq $-0x1
popq %rax
jmp 0x4a90c
callq 0x4a90e
callq 0x4956c
movq 0x10(%rax), %rax
movq %rax, 0x3f0cd(%rip) # 0x899b8
callq 0x4956c
movq 0x18(%rax), %rax
movq %rax, 0x3f0d5(%rip) # 0x899d0
callq 0x4956c
movq (%rax), %ra... | /OLSR[P]OONF/src/libcore/oonf_subsystem.c |
oonf_subsystem_configure | void
oonf_subsystem_configure(struct cfg_schema *schema, struct oonf_subsystem *subsystem) {
struct cfg_schema_section *schema_section;
OONF_ASSERT(subsystem->name, LOG_SUBSYSTEMS, "Subsystem name is not set");
OONF_INFO(LOG_SUBSYSTEMS, "Configure subsystem %s", subsystem->name);
/* add logging source */
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r10
testq %r10, %r10
setne %cl
leaq 0x54ad2(%rip), %rax # 0x9f520
movb 0x5(%rax), %al
testb $0x8, %al
sete %dl
orb %cl, %dl
je 0x4abb2
movq %rsi, %r15
movq %rdi, %r14
testb $0x2, %al
je 0x4aa94
leaq 0x1423a(%rip), %r11 # ... | /OLSR[P]OONF/src/libcore/oonf_subsystem.c |
oonf_subsystem_load | struct oonf_subsystem *
oonf_subsystem_load(const char *libname) {
struct oonf_subsystem *plugin;
void *dlhandle;
int idx;
/* see if the plugin is there */
if ((plugin = oonf_subsystem_get(libname)) == NULL) {
/* attempt to load the plugin */
dlhandle = _open_plugin(libname, &idx);
if (dlhandle ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x54a69(%rip), %rdi # 0x9f900
movq %rbx, %rsi
callq 0x424c4
testq %rax, %rax
je 0x4aeb0
movq %rax, %r12
addq $-0x70, %r12
jmp 0x4af86
xorl %r15d, %r15d
pushq $0x1
popq %rbp
cmpq $0x4, %r15
je 0x4aeff
movq %rbx, %rdi
movl %r15d, %esi
movl %e... | /OLSR[P]OONF/src/libcore/oonf_subsystem.c |
init_plugin | static int
_init_plugin(struct oonf_subsystem *plugin) {
struct oonf_subsystem *dep;
size_t i;
int result;
if (plugin->_initialized) {
return 0;
}
/* mark plugin */
plugin->_dependency_missing = true;
for (i = 0; i < plugin->dependencies_count; i++) {
dep = oonf_subsystem_get(plugin->dependen... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebp, %ebp
cmpb $0x0, 0x58(%rdi)
jne 0x4b1e6
movq %rdi, %rbx
movb $0x1, 0x5a(%rdi)
xorl %r15d, %r15d
leaq 0x54948(%rip), %r14 # 0x9f900
cmpq 0x10(%rbx), %r15
jae 0x4b006
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x424c4
testq %rax... | /OLSR[P]OONF/src/libcore/oonf_subsystem.c |
open_plugin_template | static void *
_open_plugin_template(const char *filename, int template, int mode) {
struct abuf_template_storage table;
void *result;
_dlopen_data[IDX_DLOPEN_LIB].value = filename;
abuf_template_init(&table, _dlopen_data, ARRAYSIZE(_dlopen_data), DLOPEN_PATTERNS[template]);
abuf_clear(&_dlopen_data_buffer)... | pushq %r15
pushq %r14
pushq %rbx
subq $0x620, %rsp # imm = 0x620
movl %edx, %ebx
movq %rdi, 0x3e753(%rip) # 0x89988
leaq 0x3e744(%rip), %rax # 0x89980
movslq %esi, %rcx
leaq 0x13d2a(%rip), %rdx # 0x5ef70
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
movq %rsp, %rsi
movq %rax, (%rsi)
movq $0x5, 0x8(%... | /OLSR[P]OONF/src/libcore/oonf_subsystem.c |
cleanup_plugin | static void
_cleanup_plugin(struct oonf_subsystem *plugin) {
struct oonf_subsystem *rdep;
size_t i;
if (!plugin->_initialized) {
return;
}
/* handle reverse dependencies */
avl_for_each_element(&oonf_plugin_tree, rdep, _node) {
/* look for reverse dependency */
for (i = 0; i < rdep->dependenci... | cmpb $0x1, 0x58(%rdi)
jne 0x4b3fc
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x54599(%rip), %r15 # 0x9f900
movq (%r15), %r15
movq 0x8(%r15), %rax
cmpq 0x54593(%rip), %rax # 0x9f908
je 0x4b3a5
leaq -0x70(%r15), %r14
xorl %r12d, %r12d
cmpq -0x60(%r15), %r12
jae 0x4b367
movq -0x68(... | /OLSR[P]OONF/src/libcore/oonf_subsystem.c |
os_core_linux_get_random | int
os_core_linux_get_random(void *dst, size_t length) {
int random_fd;
ssize_t result;
uint8_t *u8ptr;
u8ptr = dst;
/* open urandom */
random_fd = open("/dev/urandom", O_RDONLY);
if (random_fd == -1) {
return -1;
}
while (length > 0) {
result = read(random_fd, u8ptr, length);
if (resul... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x13b4a(%rip), %rdi # 0x5efaa
xorl %esi, %esi
xorl %eax, %eax
callq 0x194e0
cmpl $-0x1, %eax
je 0x4b492
movl %eax, %ebp
pushq $-0x1
popq %rbx
testq %r14, %r14
je 0x4b497
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq ... | /OLSR[P]OONF/src/libcore/os_linux/os_core_linux.c |
os_core_linux_create_lockfile | int
os_core_linux_create_lockfile(const char *path) {
int lock_fd;
/* create file for lock */
lock_fd = open(path, O_RDWR | O_CREAT, S_IRWXU);
if (lock_fd == -1) {
return -1;
}
if (flock(lock_fd, LOCK_EX | LOCK_NB)) {
close(lock_fd);
return -1;
}
/* lock will be released when process ends... | pushq %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
pushq $0x42
popq %rsi
movl $0x1c0, %edx # imm = 0x1C0
xorl %eax, %eax
callq 0x194e0
pushq $-0x1
popq %r14
cmpl $-0x1, %eax
je 0x4b4e2
movl %eax, %ebp
pushq $0x6
popq %rsi
movl %eax, %edi
callq 0x19520
testl %eax, %eax
je 0x4b4e5
movl %ebp, %edi
callq 0x192b0
m... | /OLSR[P]OONF/src/libcore/os_linux/os_core_linux.c |
rfc5497_timetlv_get_from_vector | uint8_t
rfc5497_timetlv_get_from_vector(const uint8_t *vector, size_t vector_length, uint8_t hopcount) {
size_t i;
/* handle illegal vector length */
if ((vector_length & 1) == 0) {
/* return infinite value */
return 255;
}
for (i = 1; i < vector_length; i += 2) {
/* find our position in the vec... | movb $-0x1, %al
testb $0x1, %sil
je 0x4b50b
pushq $0x1
popq %rax
cmpq %rsi, %rax
jae 0x4b507
cmpb %dl, (%rdi,%rax)
jae 0x4b507
addq $0x2, %rax
jmp 0x4b4f7
movb -0x1(%rdi,%rax), %al
retq
| /OLSR[P]OONF/src/librfc5444/rfc5444.c |
rfc5497_timetlv_encode | uint8_t
rfc5497_timetlv_encode(uint64_t decoded) {
uint32_t a, b;
/*
* t = (1 + a/8) * 2^b * 1000 / 1024
* = (1000 + 125 * a) * (2^b / 2^10)
* = (1000 + 125 * a) * 2 ^ (b-10)
*/
if (decoded < RFC5497_TIMETLV_MIN) {
return 0;
}
if (decoded > RFC5497_TIMETLV_MAX) {
return 255;
}
b ... | testq %rdi, %rdi
je 0x4b562
movb $-0x1, %cl
movl $0xdac00000, %eax # imm = 0xDAC00000
cmpq %rax, %rdi
ja 0x4b564
movb $0xa, %cl
cmpq $0x3e7, %rdi # imm = 0x3E7
ja 0x4b540
cmpq $0x3e7, %rdi # imm = 0x3E7
ja 0x4b549
decb %cl
addq %rdi, %rdi
jmp 0x4b528
incb %cl
incq %rdi
shrq %rdi
cmpq $0x754,... | /OLSR[P]OONF/src/librfc5444/rfc5444.c |
rfc5444_strerror | const char *
rfc5444_strerror(enum rfc5444_result result) {
const char *UNKNOWN = "Unknown RFC5444-API result";
if (result >= RFC5444_OKAY && result <= RFC5444_RESULT_MAX) {
return _rfc5444_positive_result_texts[result];
}
if (result < RFC5444_OKAY && result >= RFC5444_RESULT_MIN) {
return _rfc5444_nega... | cmpl $0x5, %edi
ja 0x4b63c
movl %edi, %eax
leaq 0x2c6ba(%rip), %rcx # 0x77cf0
leaq (%rcx,%rax,8), %rax
jmp 0x4b64e
cmpl $-0x14, %edi
jb 0x4b652
negl %edi
leaq 0x2c6d6(%rip), %rax # 0x77d20
leaq (%rax,%rdi,8), %rax
movq (%rax), %rax
retq
leaq 0x1395e(%rip), %rax # 0x5efb7
retq
nop
| /OLSR[P]OONF/src/librfc5444/rfc5444_context.c |
rfc5444_writer_set_msg_header | void
rfc5444_writer_set_msg_header(struct rfc5444_writer *writer, struct rfc5444_writer_message *msg, bool has_originator,
bool has_hopcount, bool has_hoplimit, bool has_seqno) {
#if WRITER_STATE_MACHINE == true
assert(writer->_state == RFC5444_WRITER_ADD_HEADER);
#endif
msg->has_origaddr = has_originator;
msg... | cmpl $0x3, 0x138(%rdi)
jne 0x4c135
movb %dl, 0x67(%rsi)
movb %r8b, 0x65(%rsi)
movb %cl, 0x63(%rsi)
movb %r9b, 0x78(%rsi)
movq $0x6, 0x108(%rdi)
testb %dl, %dl
je 0x4c101
movzbl 0x8(%rdi), %eax
addq $0x6, %rax
movq %rax, 0x108(%rdi)
jmp 0x4c104
pushq $0x6
popq %rax
movl %r8d, %edx
orb %cl, %dl
orb %r9b, %dl
cmpb $0x1, %... | /OLSR[P]OONF/src/librfc5444/rfc5444_msg_generator.c |
rfc5444_writer_forward_msg | enum rfc5444_result
rfc5444_writer_forward_msg(
struct rfc5444_writer *writer, struct rfc5444_reader_tlvblock_context *context, const uint8_t *msg, size_t len)
{
struct rfc5444_writer_target *target;
struct rfc5444_writer_message *rfc5444_msg;
struct rfc5444_writer_forward_handler *handler;
int cnt, hopcount,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl $0x0, 0x138(%rdi)
jne 0x4cedb
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x58, %rdi
addq $0x30, %rsi
callq 0x424c4
testq %rax, %rax
je 0x4cd29
cmpq $0x0, 0xe8(%rax)
je 0x4cec0
movq %r12, 0x8(%rsp)
movq %ra... | /OLSR[P]OONF/src/librfc5444/rfc5444_msg_generator.c |
write_addresstlv | static uint8_t *
_write_addresstlv(struct rfc5444_writer_tlvtype *tlvtype, struct rfc5444_writer_address *addr_first,
struct rfc5444_writer_address *addr_last, uint8_t *ptr) {
struct rfc5444_writer_addrtlv *tlv_first, *tlv_last, *tlv;
uint16_t total_len;
uint8_t *flag;
/* get edge tlvs */
tlv_first = list_... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x88(%rdi), %r15
movq 0x90(%rdi), %rdi
movb (%r14), %al
movb %al, (%rcx)
movb $0x0, 0x1(%rcx)
cmpb $0x0, 0x1(%r14)
je 0x4d0e0
movb $-0x80, 0x1(%rcx)
movb 0x1(%r14), %al
leaq 0x3(%rcx), %rbx
movb %al, 0x2(%rcx)
movb $-0x80, %al
jmp 0x4d0e6
leaq ... | /OLSR[P]OONF/src/librfc5444/rfc5444_msg_generator.c |
cb_print_pkt_tlv | enum rfc5444_result
_cb_print_pkt_tlv(struct rfc5444_reader_tlvblock_entry *tlv, struct rfc5444_reader_tlvblock_context *context)
{
struct rfc5444_print_session *session;
assert(context->type == RFC5444_CONTEXT_PACKET);
session = container_of(context->consumer, struct rfc5444_print_session, _pkt);
abuf_puts(... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x10(%rsi)
jne 0x4d82d
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq -0x10(%r14), %rdi
leaq 0x12d52(%rip), %rsi # 0x604e8
callq 0x4202d
movq -0x10(%r14), %rdi
movzbl 0x39(%rbx), %edx
leaq 0x12d4d(%rip), %rsi # 0x604f7
xorl %eax, %eax
callq 0x41f9c
movq -0x10(%r14), %rdi
m... | /OLSR[P]OONF/src/librfc5444/rfc5444_print.c |
cb_print_msg_tlv | enum rfc5444_result
_cb_print_msg_tlv(struct rfc5444_reader_tlvblock_entry *tlv, struct rfc5444_reader_tlvblock_context *context)
{
struct rfc5444_print_session *session;
assert(context->type == RFC5444_CONTEXT_MESSAGE);
session = container_of(context->consumer, struct rfc5444_print_session, _msg);
abuf_puts... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, 0x10(%rsi)
jne 0x4da9a
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq -0x88(%r14), %rdi
leaq 0x12d71(%rip), %rsi # 0x60762
callq 0x4202d
movq -0x88(%r14), %rdi
movzbl 0x39(%rbx), %edx
leaq 0x12d6e(%rip), %rsi # 0x60776
xorl %eax, %eax
callq 0x41f9c
movq -0x88(%r14), %rdi
m... | /OLSR[P]OONF/src/librfc5444/rfc5444_print.c |
rfc5444_print_direct | enum rfc5444_result
rfc5444_print_direct(struct autobuf *out, void *buffer, size_t length)
{
struct rfc5444_reader reader;
struct rfc5444_print_session session;
enum rfc5444_result result;
memset(&reader, 0, sizeof(reader));
memset(&session, 0, sizeof(session));
session.output = out;
rfc5444_reader_ini... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x40(%r12)
movaps ... | /OLSR[P]OONF/src/librfc5444/rfc5444_print.c |
rfc5444_reader_init | void
rfc5444_reader_init(struct rfc5444_reader *context) {
avl_init(&context->packet_consumer, _consumer_avl_comp, true);
avl_init(&context->message_consumer, _consumer_avl_comp, true);
if (context->malloc_addrblock_entry == NULL)
context->malloc_addrblock_entry = _malloc_addrblock_entry;
if (context->mall... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x68(%rip), %r14 # 0x4e926
pushq $0x1
popq %rbp
movq %r14, %rsi
movl %ebp, %edx
callq 0x424ac
leaq 0x28(%rbx), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x424ac
cmpq $0x0, 0x60(%rbx)
jne 0x4e8eb
leaq 0x6b(%rip), %rax # 0x4e952
movq %rax, 0x60(%rbx)
cm... | /OLSR[P]OONF/src/librfc5444/rfc5444_reader.c |
rfc5444_get_u16 | static uint8_t
_rfc5444_get_u8(const uint8_t **ptr, const uint8_t *end, enum rfc5444_result *error) {
uint8_t result;
if (*error != RFC5444_OKAY) {
return 0;
}
if (*ptr >= end) {
*error = RFC5444_END_OF_BUFFER;
return 0;
}
result = **ptr;
*ptr += 1;
return result;
} | cmpl $0x0, (%rdx)
jne 0x4f570
movq (%rdi), %r8
cmpq %rsi, %r8
jae 0x4f56a
leaq 0x1(%r8), %rax
movzbl (%r8), %ecx
movq %rax, (%rdi)
shll $0x8, %ecx
cmpl $0x0, (%rdx)
jne 0x4f572
cmpq %rsi, %rax
jae 0x4f57a
movzbl 0x1(%r8), %eax
addq $0x2, %r8
movq %r8, (%rdi)
jmp 0x4f574
movl $0xfffffffe, (%rdx) # imm = 0xFFFFFFFE
x... | /OLSR[P]OONF/src/librfc5444/rfc5444_reader.c |
parse_tlvblock | static enum rfc5444_result
_parse_tlvblock(struct rfc5444_reader *parser, struct avl_tree *tlvblock, const uint8_t **ptr, const uint8_t *eob,
uint8_t addr_count) {
enum rfc5444_result result = RFC5444_OKAY;
struct rfc5444_reader_tlvblock_entry *tlv1 = NULL;
struct rfc5444_reader_tlvblock_entry entry;
const ui... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %r15d
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, 0x40(%rsp)
movq %rdi, 0x48(%rsp)
leaq 0x34(%rsp), %rdx
andl $0x0, (%rdx)
movq (%r12), %rbx
movq %r12, %rdi
movq %rcx, %rsi
callq 0x4f537
movzwl %ax, %eax
addq %rbx, %rax
addq $0... | /OLSR[P]OONF/src/librfc5444/rfc5444_reader.c |
rfc5444_tlv_writer_init | void
_rfc5444_tlv_writer_init(struct rfc5444_tlv_writer_data *data, size_t max, size_t mtu __attribute__((unused))) {
data->header = 0;
data->added = 0;
data->allocated = 0;
data->set = 0;
data->max = max;
#if DEBUG_CLEANUP == true
memset(data->buffer, 0, mtu);
#endif
} | xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movq %rsi, 0x28(%rdi)
retq
| /OLSR[P]OONF/src/librfc5444/rfc5444_tlv_writer.c |
write_tlv | static void
_write_tlv(uint8_t *ptr, uint8_t type, uint8_t exttype, uint8_t idx1, uint8_t idx2, const void *value, size_t length) {
uint8_t flags = 0;
/* calculate flags field */
if (exttype > 0) {
flags |= RFC5444_TLV_FLAG_TYPEEXT;
}
if (idx1 == idx2) {
flags |= RFC5444_TLV_FLAG_SINGLE_IDX;
}
el... | movl %edx, %eax
movq %r8, %rdx
testl %eax, %eax
setne %r8b
shlb $0x7, %r8b
leal 0x8(%r8), %r9d
cmpq $0x100, %rdx # imm = 0x100
movzbl %r9b, %r9d
movzbl %r8b, %r8d
cmovbl %r8d, %r9d
orb $0x10, %r9b
testq %rdx, %rdx
movzbl %r9b, %r9d
cmovel %r8d, %r9d
movb %sil, (%rdi)
movb %r9b, 0x1(%rdi)
testl %eax, %eax
je ... | /OLSR[P]OONF/src/librfc5444/rfc5444_tlv_writer.c |
rfc5444_tlv_writer_set | enum rfc5444_result
_rfc5444_tlv_writer_set(
struct rfc5444_tlv_writer_data *data, uint8_t type, uint8_t exttype, const void *value, size_t length)
{
size_t s;
s = _calc_tlv_size(exttype != 0, length);
if (data->allocated - data->set < s) {
/* not enough space reserved */
return RFC5444_MTU_TOO_SMALL;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, %edx
pushq $0x3
popq %rax
sbbq $0x0, %rax
testq %r8, %r8
leaq 0x1(%rax,%r8), %rdi
cmoveq %rax, %rdi
cmpq $0x100, %r8 # imm = 0x100
leaq 0x2(%rax,%r8), %r14
cmovbq %rdi, %r14
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rax
subq %rax, %rdi
cmpq %r14, %rd... | /OLSR[P]OONF/src/librfc5444/rfc5444_tlv_writer.c |
rfc5444_writer_cleanup | void
rfc5444_writer_cleanup(struct rfc5444_writer *writer) {
struct rfc5444_writer_message *msg, *safe_msg;
struct rfc5444_writer_pkthandler *pkt, *safe_pkt;
struct rfc5444_writer_content_provider *provider, *safe_prv;
struct rfc5444_writer_tlvtype *tlvtype, *safe_tt;
struct rfc5444_writer_target *interf, *sa... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x50287
movq %rdi, %rbx
cmpl $0x0, 0x138(%rdi)
jne 0x502a6
movq 0x80(%rbx), %rsi
movq 0x8(%rsi), %rax
cmpq 0x88(%rbx), %rax
je 0x50193
movq (%rsi), %r14
movq %rbx, %rdi
callq 0x502c5
movq %r14, %rsi
jmp 0x50176
movq 0xe0(%rbx), %rsi
movq 0x8(%rs... | /OLSR[P]OONF/src/librfc5444/rfc5444_writer.c |
rfc5444_writer_unregister_target | void
rfc5444_writer_unregister_target(
struct rfc5444_writer *writer __attribute__((unused)), struct rfc5444_writer_target *interf) {
#if WRITER_STATE_MACHINE == true
assert(writer->_state == RFC5444_WRITER_NONE);
#endif
/* remove interface from writer */
if (list_is_node_added(&interf->_target_node)) {
li... | cmpl $0x0, 0x138(%rdi)
jne 0x5033a
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x50339
movq 0x38(%rsi), %rcx
testq %rcx, %rcx
je 0x50339
addq $0x30, %rsi
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
retq
pushq %rax
leaq 0xefab(%rip), %rdi # 0x5f2ed
leaq 0x108b6(%rip), %rsi # 0x6... | /OLSR[P]OONF/src/librfc5444/rfc5444_writer.c |
lazy_free_message | static void
_lazy_free_message(struct rfc5444_writer *writer, struct rfc5444_writer_message *msg) {
if (!msg->_registered && list_is_empty(&msg->_addr_head) && list_is_empty(&msg->_msgspecific_tlvtype_head) &&
avl_is_empty(&msg->_provider_tree)) {
avl_remove(&writer->_msgcreators, &msg->_msgcreator_node);
... | pushq %rbx
cmpb $0x0, 0x60(%rsi)
jne 0x508d7
movq %rsi, %rbx
leaq 0x90(%rsi), %rax
cmpq %rax, 0x90(%rsi)
jne 0x508d7
cmpq %rax, 0x98(%rbx)
jne 0x508d7
leaq 0xc8(%rbx), %rax
cmpq %rax, 0xc8(%rbx)
jne 0x508d7
cmpq %rax, 0xd0(%rbx)
jne 0x508d7
cmpl $0x0, 0x50(%rbx)
je 0x508d9
popq %rbx
retq
addq $0x58, %rdi
movq %rbx, %rs... | /OLSR[P]OONF/src/librfc5444/rfc5444_writer.c |
rfc5444_writer_register_msgcontentprovider | int
rfc5444_writer_register_msgcontentprovider(struct rfc5444_writer *writer, struct rfc5444_writer_content_provider *cpr,
struct rfc5444_writer_tlvtype *addrtlvs, size_t addrtlvs_count) {
struct rfc5444_writer_message *msg;
size_t i;
#if WRITER_STATE_MACHINE == true
assert(writer->_state == RFC5444_WRITER_NON... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x0, 0x138(%rdi)
jne 0x50966
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movzbl 0x4(%rsi), %esi
callq 0x50729
testq %rax, %rax
je 0x50959
movq %rax, %r13
subq $0x1, %r14
jb 0x5093a
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x50... | /OLSR[P]OONF/src/librfc5444/rfc5444_writer.c |
AliHttpRequest::WaitResponseHeaderComplete() | int AliHttpRequest::WaitResponseHeaderComplete() {
char Read_buf[4096] = {};
int last_Read = 0;
http_parser_init_(parser_, HTTP_RESPONSE);
parser_->data = this;
do{
memset(Read_buf, 0, sizeof(Read_buf));
last_Read = this->connection_->Read(Read_buf, sizeof(Read_buf));
if(last_Read < 0) {... | pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp # imm = 0x1020
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1020(%rbp)
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx # imm = 0x1000
callq 0x366a0
movq -0x1020(%rbp), %rax
movl $0x0, -0x1014(%rbp)
movq 0x200(%rax), %rdi
movl $... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/http/ali_http_request.cc |
AliTcpConnection::Close() | void AliTcpConnection::Close() {
if(fd_) {
#ifdef WIN32
closesocket(fd_);
#else
::close(fd_);
#endif
}
delete this;
return;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x8(%rax)
je 0x45cb6
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x3a760
movq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x45cd7
movq -0x10(%rbp), %rdi
callq 0x36fe0
movq -0x10(%rbp), %rdi
movl $0x3... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/http/ali_tcp_connection.cc |
mbedtls_base64_decode | int mbedtls_base64_decode( unsigned char *dst, size_t dlen, size_t *olen,
const unsigned char *src, size_t slen )
{
size_t i, n;
uint32_t j, x;
unsigned char *p;
/* First pass: check for validity and get output length */
for( i = n = j = 0; i < slen; i++ )
{
/* Skip s... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x44(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x466a8
movl $0x0, -0x48(%rbp)
movq -0x38(%rbp), %rcx
xorl %... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/base64.c |
mbedtls_ctr_drbg_update | void mbedtls_ctr_drbg_update( mbedtls_ctr_drbg_context *ctx,
const unsigned char *additional, size_t add_len )
{
unsigned char add_input[MBEDTLS_CTR_DRBG_SEEDLEN];
if( add_len > 0 )
{
/* MAX_INPUT would be more logical here, but we have to match
* block_cipher_df()'s ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x46d3b
cmpq $0x180, -0x18(%rbp) # imm = 0x180
jbe 0x46d1d
movq $0x180, -0x18(%rbp) # imm = 0x180
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ctr_drbg.c |
ctr_drbg_update_internal | static int ctr_drbg_update_internal( mbedtls_ctr_drbg_context *ctx,
const unsigned char data[MBEDTLS_CTR_DRBG_SEEDLEN] )
{
unsigned char tmp[MBEDTLS_CTR_DRBG_SEEDLEN];
unsigned char *p = tmp;
int i, j;
memset( tmp, 0, MBEDTLS_CTR_DRBG_SEEDLEN );
for( j = 0; j < MBEDTL... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x366a0
movl $0x0, -0x50(%rbp)
cmpl $0x30, -0x50(%rbp)
jge 0x471bf
movl $0x10, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jle 0x471... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ctr_drbg.c |
mbedtls_entropy_write_seed_file | int mbedtls_entropy_write_seed_file( mbedtls_entropy_context *ctx, const char *path )
{
int ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
FILE *f;
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
if( ( f = fopen( path, "wb" ) ) == NULL )
return( MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR );
if( ( ret = mb... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xffffffc1, -0x1c(%rbp) # imm = 0xFFFFFFC1
movq -0x18(%rbp), %rdi
leaq 0x792ee(%rip), %rsi # 0xc1260
callq 0x382c0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x47f8a
movl $0xffffffc1, -0x4(%rbp) # imm = 0xFFFFFFC1
jmp 0x... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/entropy.c |
check_version_3_17_plus | static int check_version_3_17_plus( void )
{
int minor;
struct utsname un;
const char *ver;
/* Get version information */
uname(&un);
ver = un.release;
/* Check major version; assume a single digit */
if( ver[0] < '3' || ver[0] > '9' || ver [1] != '.' )
return( -1 );
if( v... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
leaq -0x18e(%rbp), %rdi
callq 0x352b0
leaq -0x18e(%rbp), %rax
addq $0x82, %rax
movq %rax, -0x198(%rbp)
movq -0x198(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x33, %eax
jl 0x48499
movq -0x198(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x48499
mov... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/entropy_poll.c |
mbedtls_ripemd160_process | void mbedtls_ripemd160_process( mbedtls_ripemd160_context *ctx, const unsigned char data[64] )
{
uint32_t A, B, C, D, E, Ap, Bp, Cp, Dp, Ep, X[16];
GET_UINT32_LE( X[ 0], data, 0 );
GET_UINT32_LE( X[ 1], data, 4 );
GET_UINT32_LE( X[ 2], data, 8 );
GET_UINT32_LE( X[ 3], data, 12 );
GET_UINT32_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ripemd160.c |
mbedtls_ripemd160 | void mbedtls_ripemd160( const unsigned char *input, size_t ilen,
unsigned char output[20] )
{
mbedtls_ripemd160_context ctx;
mbedtls_ripemd160_init( &ctx );
mbedtls_ripemd160_starts( &ctx );
mbedtls_ripemd160_update( &ctx, input, ilen );
mbedtls_ripemd160_finish( &ctx, output );
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x74(%rbp), %rdi
callq 0x3a860
leaq -0x74(%rbp), %rdi
callq 0x36070
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x74(%rbp), %rdi
callq 0x35fb0
movq -0x18(%rbp), %rsi
leaq -0x74(%rbp), %rdi
callq ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ripemd160.c |
mbedtls_sha1_finish | void mbedtls_sha1_finish( mbedtls_sha1_context *ctx, unsigned char output[20] )
{
uint32_t last, padn;
uint32_t high, low;
unsigned char msglen[8];
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT32_BE( high, msglen, 0 );
PUT_UINT3... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x1d, %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
shll $0x3, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shll $0x3, %eax
movl %eax, -0x20(%rbp... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/sha1.c |
mbedtls_sha256 | void mbedtls_sha256( const unsigned char *input, size_t ilen,
unsigned char output[32], int is224 )
{
mbedtls_sha256_context ctx;
mbedtls_sha256_init( &ctx );
mbedtls_sha256_starts( &ctx, is224 );
mbedtls_sha256_update( &ctx, input, ilen );
mbedtls_sha256_finish( &ctx, output );
mb... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x36c70
movl -0x1c(%rbp), %esi
leaq -0x88(%rbp), %rdi
callq 0x39ee0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x3a1b0
movq -... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/sha256.c |
Diligent::RenderDeviceVkImpl::AllocateMemory(unsigned long, unsigned long, unsigned int, unsigned int) | VulkanUtilities::VulkanMemoryAllocation AllocateMemory(VkDeviceSize Size, VkDeviceSize Alignment, uint32_t MemoryTypeIndex, VkMemoryAllocateFlags AllocateFlags = 0)
{
const auto& MemoryProps = m_PhysicalDevice->GetMemoryProperties();
VERIFY_EXPR(MemoryTypeIndex < MemoryProps.memoryTypeCount);
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x1c68, %rdi # ... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.hpp |
void Diligent::LogError<true, char [39], char const*, char [3]>(bool, char const*, char const*, int, char const (&) [39], char const* const&, char const (&) [3]) | void LogError(bool IsFatal, const char* Function, const char* FullFilePath, int Line, const ArgsType&... Args)
{
std::string FileName(FullFilePath);
auto LastSlashPos = FileName.find_last_of("/\\");
if (LastSlashPos != std::string::npos)
FileName.erase(0, LastSlashPos + 1);
auto Msg = FormatStr... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movb %dil, %al
movq 0x10(%rbp), %rdi
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x51(%rbp), ... | /DiligentGraphics[P]DiligentCore/Primitives/interface/Errors.hpp |
Diligent::BufferViewVkImpl* Diligent::MakeNewRCObj<Diligent::BufferViewVkImpl, Diligent::FixedBlockMemoryAllocator>::operator()<Diligent::RenderDeviceVkImpl*, Diligent::BufferViewDesc&, Diligent::BufferVkImpl*, VulkanUtilities::VulkanObjectWrapper<VkBufferView_T*, (VulkanUtilities::VulkanHandleTypeId)3>, bool&>(Diligen... | ObjectType* operator()(CtorArgTypes&&... CtorArgs)
{
RefCountersImpl* pNewRefCounters = nullptr;
IReferenceCounters* pRefCounters = nullptr;
if (m_pOwner != nullptr)
pRefCounters = m_pOwner->GetReferenceCounters();
else
{
// Constructor of RefCou... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, 0x8(%rax)
je 0xebd56
movq -0x60(%rbp), ... | /DiligentGraphics[P]DiligentCore/Common/interface/RefCountedObjectImpl.hpp |
Diligent::BufferBase<Diligent::EngineVkImplTraits>::GetDefaultView(Diligent::BUFFER_VIEW_TYPE) | GetDefaultView(BUFFER_VIEW_TYPE ViewType) override
{
switch (ViewType)
{
case BUFFER_VIEW_SHADER_RESOURCE: return m_pDefaultSRV.get();
case BUFFER_VIEW_UNORDERED_ACCESS: return m_pDefaultUAV.get();
default: UNEXPECTED("Unknown view type"); return nullptr;
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movzbl -0x11(%rbp), %eax
movl %eax, -0x48(%rbp)
subl $0x1, %eax
je 0xed1e2
jmp 0xed1d8
movl -0x48(%rbp), %eax
subl $0x2, %eax
je 0xed1f5
jmp 0xed208
movq -0x50(%rbp), %rd... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngine/include/BufferBase.hpp |
Diligent::IBuffer::IBuffer() | DILIGENT_BEGIN_INTERFACE(IBuffer, IDeviceObject)
{
#if DILIGENT_CPP_INTERFACE
/// Returns the buffer description used to create the object
virtual const BufferDesc& METHOD(GetDesc)() const override = 0;
#endif
/// Creates a new buffer view
/// \param [in] ViewDesc - View description. See Diligent::Buf... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xef730
movq -0x10(%rbp), %rax
leaq 0xeddffc(%rip), %rcx # 0xfcd710
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngine/interface/Buffer.h |
Diligent::RenderDeviceBase<Diligent::EngineVkImplTraits>::RecycleDynamicBufferId(unsigned int) | void RecycleDynamicBufferId(Uint32 Id)
{
Threading::SpinLockGuard Guard{m_RecycledDynamicBufferIdsLock};
m_RecycledDynamicBufferIds.push_back(Id);
#ifdef DILIGENT_DEBUG
VERIFY(m_DbgRecycledDynamicBufferIds.emplace(Id).second, "Dynamic buffer ID ", Id, " has already been recycled. This appear... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x70(%rbp)
addq $0x1be8, %rsi # imm = 0x1BE8
leaq -0x18(%rbp), %rdi
callq 0xf1a40
movq -0x70(%rbp), %rdi
addq $0x1bf0, %rdi # imm = 0x1BF0
leaq -0xc(%rbp), %rsi
callq 0xf2b10
jmp... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngine/include/RenderDeviceBase.hpp |
Diligent::CommandPoolManager::AllocateCommandPool(char const*) | VulkanUtilities::CommandPoolWrapper CommandPoolManager::AllocateCommandPool(const char* DebugName)
{
std::lock_guard<std::mutex> LockGuard{m_Mutex};
VulkanUtilities::CommandPoolWrapper CmdPool;
if (!m_CmdPools.empty())
{
CmdPool = std::move(m_CmdPools.front());
m_CmdPools.pop_front();
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x98(%rbp)
addq $0x30, %rsi
leaq -0x20(%rbp), %rdi
callq 0xf5d50
movq -0x90(%rbp), %rdi
movb $0x0, -0x21(%rbp)
... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/CommandPoolManager.cpp |
Diligent::CommandQueueVkImpl::GetNextFenceValue() const | GetNextFenceValue() const override final { return m_NextFenceValue.load(); } | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x8(%rbp)
movl $0x5, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi # imm = 0xFFFF
callq 0xdc660
movl %eax, -0x24(%rbp)
jmp 0x107c79
movl -0x... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/include/CommandQueueVkImpl.hpp |
Diligent::RefCountedObject<Diligent::ICommandQueueVk>::~RefCountedObject() | virtual ~RefCountedObject()
{
// WARNING! m_pRefCounters may be expired in scenarios like this:
//
// A ==sp==> B ---wp---> A
//
// RefCounters_A.ReleaseStrongRef(){ // NumStrongRef == 0, NumWeakRef == 1
// bDestroyThis = (m_NumWeakReferences == 0) == false... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
ud2
nopw (%rax,%rax)
| /DiligentGraphics[P]DiligentCore/Common/interface/RefCountedObjectImpl.hpp |
Diligent::DescriptorPoolManager::DescriptorPoolManager(Diligent::RenderDeviceVkImpl&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<VkDescriptorPoolSize, std::allocator<VkDescriptorPoolSize>>, unsigned int, bool) | DescriptorPoolManager::DescriptorPoolManager(RenderDeviceVkImpl& DeviceVkImpl,
std::string PoolName,
std::vector<VkDescriptorPoolSize> PoolSizes,
uin... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, -0x40(%rbp)
movq %rsi, %rdx
movq -0x40(%rbp), %rsi
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
andb $0x1, %al
movb %al, -0x25(%rbp)
movq -0x8(%rbp), %rdi
mov... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DescriptorPoolManager.cpp |
Diligent::AllocateDescriptorSet(VulkanUtilities::VulkanLogicalDevice const&, VkDescriptorPool_T*, VkDescriptorSetLayout_T*, char const*) | static VkDescriptorSet AllocateDescriptorSet(const VulkanUtilities::VulkanLogicalDevice& LogicalDevice,
VkDescriptorPool Pool,
VkDescriptorSetLayout SetLayout,
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0xd7340
movl $0x22, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0x30(%rbp)... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DescriptorPoolManager.cpp |
Diligent::DescriptorSetAllocator::FreeDescriptorSet(VkDescriptorSet_T*, VkDescriptorPool_T*, unsigned long)::DescriptorSetDeleter::DescriptorSetDeleter(DescriptorSetDeleter&&) | DescriptorSetDeleter(DescriptorSetDeleter&& rhs)noexcept :
Allocator {rhs.Allocator},
Set {rhs.Set },
Pool {rhs.Pool }
{
rhs.Allocator = nullptr;
rhs.Set = VK_NULL_HANDLE;
rhs.Pool = VK_NULL_HANDLE;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DescriptorPoolManager.cpp |
Diligent::DeviceContextVkImpl::PrepareCommandPool(Diligent::IndexWrapper<unsigned char, Diligent::_SoftwareQueueIndexTag>) | void DeviceContextVkImpl::PrepareCommandPool(SoftwareQueueIndex CommandQueueId)
{
DEV_CHECK_ERR(CommandQueueId < m_pDevice->GetCommandQueueCount(), "CommandQueueId is out of range");
const HardwareQueueIndex QueueFamilyIndex{m_pDevice->GetCommandQueue(CommandQueueId).GetQueueFamilyIndex()};
const auto& ... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb %sil, %al
movb %al, -0x1(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x1(%rbp), %rdi
callq 0xeb540
movq -0xa0(%rbp), %rdi
movl %eax, %eax
movq %rax, -0xa8(%rbp)
addq $0x10, %rdi
callq 0x124ef0
movq %rax, %rdi
callq 0xeef20
movq %rax, ... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp |
Diligent::DeviceContextVkImpl::TransitionShaderResources(Diligent::IShaderResourceBinding*) | void DeviceContextVkImpl::TransitionShaderResources(IShaderResourceBinding* pShaderResourceBinding)
{
DEV_CHECK_ERR(!m_pActiveRenderPass, "State transitions are not allowed inside a render pass.");
DEV_CHECK_ERR(pShaderResourceBinding != nullptr, "pShaderResourceBinding must not be null");
ShaderResourceBi... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
addq $0x540, %rdi # imm = 0x540
callq 0x1280e0
testb $0x1, %al
jne 0x1138a0
jmp 0x113841
leaq 0x9f6d33(%rip), %rsi # 0xb0a57b
leaq -0x30(%rbp), %rdi
... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp |
Diligent::DeviceContextVkImpl::ChooseRenderPassAndFramebuffer() | void DeviceContextVkImpl::ChooseRenderPassAndFramebuffer()
{
FramebufferCache::FramebufferCacheKey FBKey;
RenderPassCache::RenderPassCacheKey RenderPassKey;
if (m_pBoundDepthStencil)
{
ITexture* pDepthBuffer = m_pBoundDepthStencil->GetTexture();
FBKey.DSV = m_pBoundD... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x188(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1359e0
leaq -0x98(%rbp), %rdi
callq 0x135a60
movq -0x188(%rbp), %rdi
addq $0x530, %rdi # imm = 0x530
callq 0x129990
testb $0x1, %al
jne 0x11... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp |
Diligent::DeviceContextVkImpl::UpdateTextureRegion(void const*, unsigned long, unsigned long, Diligent::TextureVkImpl&, unsigned int, unsigned int, Diligent::Box const&, Diligent::RESOURCE_STATE_TRANSITION_MODE) | void DeviceContextVkImpl::UpdateTextureRegion(const void* pSrcData,
Uint64 SrcStride,
Uint64 SrcDepthStride,
Textur... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movb 0x20(%rbp), %al
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x180(%rbp)
mov... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp |
Diligent::DeviceContextVkImpl::CopyTextureRegion(Diligent::TextureVkImpl*, Diligent::RESOURCE_STATE_TRANSITION_MODE, Diligent::TextureVkImpl*, Diligent::RESOURCE_STATE_TRANSITION_MODE, VkImageCopy const&) | void DeviceContextVkImpl::CopyTextureRegion(TextureVkImpl* pSrcTexture,
RESOURCE_STATE_TRANSITION_MODE SrcTextureTransitionMode,
TextureVkImpl* pDstTexture,
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %dl, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x124da0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1000, %ecx ... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp |
Diligent::DeviceContextVkImpl::FinishCommandList(Diligent::ICommandList**) | void DeviceContextVkImpl::FinishCommandList(ICommandList** ppCommandList)
{
DEV_CHECK_ERR(IsDeferred(), "Only deferred context can record command list");
DEV_CHECK_ERR(m_pActiveRenderPass == nullptr, "Finishing command list inside an active render pass.");
EndRenderScope();
VkCommandBuffer vkCmdBuff =... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rdi
callq 0xf4fb0
testb $0x1, %al
jne 0x11d345
jmp 0x11d2e0
leaq 0x9efb07(%rip), %rsi # 0xb0cdee
leaq -0x30(%rbp), %rdi
movq %rdi, -0xe8(%... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp |
Diligent::DeviceContextVkImpl::BeginQuery(Diligent::IQuery*) | void DeviceContextVkImpl::BeginQuery(IQuery* pQuery)
{
TDeviceContextBase::BeginQuery(pQuery, 0);
VERIFY(m_pQueryMgr != nullptr || IsDeferred(), "Query manager should never be null for immediate contexts. This might be a bug.");
DEV_CHECK_ERR(m_pQueryMgr != nullptr, "Query manager is null, which indicates ... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x13f200
movq -0xf8(%rbp), %rax
cmpq $0x0, 0x1240(%rax)
jne 0x11d931
movq -0xf8(%rbp), %rdi
callq 0xf4fb0
testb $0x... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp |
Diligent::DeviceContextVkImpl::TransitionTextureState(Diligent::TextureVkImpl&, Diligent::RESOURCE_STATE, Diligent::RESOURCE_STATE, Diligent::STATE_TRANSITION_FLAGS, VkImageSubresourceRange*) | void DeviceContextVkImpl::TransitionTextureState(TextureVkImpl& TextureVk,
RESOURCE_STATE OldState,
RESOURCE_STATE NewState,
STATE_TRANSITION_F... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x158(%rbp), %rdi
addq $0x540, %rdi #... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp |
Diligent::DeviceContextVkImpl::AliasingBarrier(Diligent::IDeviceObject*, Diligent::IDeviceObject*) | void DeviceContextVkImpl::AliasingBarrier(IDeviceObject* pResourceBefore, IDeviceObject* pResourceAfter)
{
auto GetResourceBindFlags = [](IDeviceObject* pResource) //
{
if (RefCntAutoPtr<ITextureVk> pTexture{pResource, IID_TextureVk})
{
return pTexture.RawPtr<TextureVkImpl>()->GetDes... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x19(%rbp), %rdi
callq 0x11fe70
movl %eax, %edi
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp),... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp |
Diligent::DeviceContextVkImpl::WriteTLASCompactedSize(Diligent::WriteTLASCompactedSizeAttribs const&) | void DeviceContextVkImpl::WriteTLASCompactedSize(const WriteTLASCompactedSizeAttribs& Attribs)
{
TDeviceContextBase::WriteTLASCompactedSize(Attribs, 0);
const Uint32 QueryIndex = 0;
TopLevelASVkImpl* pTLASVk = ClassPtrCast<TopLevelASVkImpl>(Attribs.pTLAS);
BufferVkImpl* pDestBuffVk = Clas... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1446d0
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1424c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp |
Diligent::DeviceContextVkImpl::TraceRaysIndirect(Diligent::TraceRaysIndirectAttribs const&) | void DeviceContextVkImpl::TraceRaysIndirect(const TraceRaysIndirectAttribs& Attribs)
{
TDeviceContextBase::TraceRaysIndirect(Attribs, 0);
const ShaderBindingTableVkImpl* pSBTVk = ClassPtrCast<const ShaderBindingTableVkImpl>(Attribs.pSBT);
const BindingTableVk& BindingTable = pSBTVk->GetVkBi... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x145770
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x145520
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x145550
movq -0x38(%rbp... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp |
Diligent::DeviceContextVkImpl::EnsureVkCmdBuffer() | __forceinline void EnsureVkCmdBuffer()
{
VERIFY_EXPR(m_CmdPool != nullptr);
// Make sure that the number of commands in the context is at least one,
// so that the context cannot be disposed by Flush()
m_State.NumCommands = m_State.NumCommands != 0 ? m_State.NumCommands : 1;
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq $0x0, 0x10f8(%rax)
jne 0x124e2a
jmp 0x124dc4
leaq 0x9e1432(%rip), %rsi # 0xb061fd
leaq 0x9e9309(%rip), %rdx # 0xb0e0db
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xef... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/include/DeviceContextVkImpl.hpp |
VulkanUtilities::VulkanCommandBuffer::DrawIndexedIndirect(VkBuffer_T*, unsigned long, unsigned int, unsigned int) | __forceinline void DrawIndexedIndirect(VkBuffer Buffer, VkDeviceSize Offset, uint32_t DrawCount, uint32_t Stride)
{
VERIFY_EXPR(m_VkCmdBuffer != VK_NULL_HANDLE);
VERIFY(IsInRenderScope(),
"vkCmdDrawIndexedIndirect() must be called inside render pass "
"(https://registry... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x12cf54
jmp 0x12cee8
leaq 0x9d930e(%rip), %rsi # 0xb061fd
leaq 0x9d9... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanCommandBuffer.hpp |
VulkanUtilities::RenderingInfoWrapper::SetStencilAttachmentClearValue(unsigned int) | void SetStencilAttachmentClearValue(uint32_t Stencil)
{
VERIFY_EXPR(m_RI.pStencilAttachment != nullptr && m_StencilAttachmentIndex != ~0u);
m_Attachments[m_StencilAttachmentIndex].clearValue.depthStencil.stencil = Stencil;
m_Attachments[m_StencilAttachmentIndex].loadOp ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x12f7cc
movq -0x48(%rbp), %rax
cmpl $-0x1, 0x64(%rax)
jne 0x12f831
jmp 0x12f7ce
leaq 0x9d6a28(%rip), %rsi # 0xb061fd
leaq 0x9dfee6(%rip... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/RenderingInfoWrapper.hpp |
Diligent::DeviceContextBase<Diligent::EngineVkImplTraits>::SetScissorRects(unsigned int, Diligent::Rect const*, unsigned int&, unsigned int&) | inline void DeviceContextBase<ImplementationTraits>::SetScissorRects(
Uint32 NumRects,
const Rect* pRects,
Uint32& RTWidth,
Uint32& RTHeight)
{
DVP_CHECK_QUEUE_TYPE_COMPATIBILITY(COMMAND_QUEUE_TYPE_GRAPHICS, "SetScissorRects");
if (NumRects > 1)
{
DEV_CHECK_ERR(m_pDevic... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x148(%rbp), %rax
movzbl 0x590(%rax), %eax
cmpl $0x0, %eax
jne 0x135366
jmp 0x135282
m... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngine/include/DeviceContextBase.hpp |
void Diligent::LogError<false, char [50]>(bool, char const*, char const*, int, char const (&) [50]) | void LogError(bool IsFatal, const char* Function, const char* FullFilePath, int Line, const ArgsType&... Args)
{
std::string FileName(FullFilePath);
auto LastSlashPos = FileName.find_last_of("/\\");
if (LastSlashPos != std::string::npos)
FileName.erase(0, LastSlashPos + 1);
auto Msg = FormatStr... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xd99e0
mo... | /DiligentGraphics[P]DiligentCore/Primitives/interface/Errors.hpp |
VulkanUtilities::VulkanCommandBuffer::ResetQueryPool(VkQueryPool_T*, unsigned int, unsigned int) | __forceinline void ResetQueryPool(VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount)
{
VERIFY_EXPR(m_VkCmdBuffer != VK_NULL_HANDLE);
// Query pool reset must be performed outside of render pass (17.2).
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x14448d
jmp 0x14442a
leaq 0x9c1dcc(%rip), %rsi # 0xb061fd
leaq 0x9c2404(%rip), %rdx # 0x... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanCommandBuffer.hpp |
Diligent::TextureBase<Diligent::EngineVkImplTraits>::GetSparseProperties() const | GetSparseProperties() const override final
{
DEV_CHECK_ERR(this->m_Desc.Usage == USAGE_SPARSE,
"ITexture::GetSparseProperties() must be used for sparse texture");
VERIFY_EXPR(m_pSparseProps != nullptr);
return *m_pSparseProps;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x40(%rax), %eax
cmpl $0x5, %eax
je 0x147b52
jmp 0x147af3
leaq 0x9cde9d(%rip), %rsi # 0xb15997
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xebb30
movq -0x68(%rbp), %rd... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngine/include/TextureBase.hpp |
Diligent::DeviceContextVkImpl::CommitDescriptorSets(Diligent::DeviceContextVkImpl::ResourceBindInfo&, unsigned int) | void DeviceContextVkImpl::CommitDescriptorSets(ResourceBindInfo& BindInfo, Uint32 CommitSRBMask)
{
VERIFY(CommitSRBMask != 0, "This method should not be called when there is nothing to commit");
const Uint32 FirstSign = PlatformMisc::GetLSB(CommitSRBMask);
const Uint32 LastSign = PlatformMisc::GetMSB(Comm... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1a0(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x14b51e
jmp 0x14b4b9
leaq 0x9c3672(%rip), %rsi # 0xb0eb32
leaq -0x38(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp |
Diligent::TopLevelASBase<Diligent::EngineVkImplTraits>::CheckState(Diligent::RESOURCE_STATE) const | bool CheckState(RESOURCE_STATE State) const
{
VERIFY((State & (State - 1)) == 0, "Single state is expected");
VERIFY(IsInKnownState(), "TLAS state is unknown");
return (this->m_State & State) == State;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0xc(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x1531eb
jmp 0x15318c
leaq 0x9bd1cd(%rip), %rsi # 0xb10360
leaq -0x30(%rbp), %rdi
movq %r... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngine/include/TopLevelASBase.hpp |
Diligent::DeviceObjectBase<Diligent::IPipelineStateVk, Diligent::RenderDeviceVkImpl, Diligent::PipelineStateDesc>::Release() | Release() override final
{
// Render device owns allocators for all types of device objects,
// so it must be destroyed after all device objects are released.
// Consider the following scenario: an object A owns the last strong
// reference to the device:
//
// 1. A::... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xf88f0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x159f80
movl %eax, -0x30(%r... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngine/include/DeviceObjectBase.hpp |
void CheckDynamicType<Diligent::PipelineResourceSignatureVkImpl const, Diligent::IPipelineResourceSignature const>(Diligent::IPipelineResourceSignature const*) | void CheckDynamicType(SrcType* pSrcPtr)
{
VERIFY(pSrcPtr == nullptr || dynamic_cast<DstType*>(pSrcPtr) != nullptr, "Dynamic type cast failed. Src typeid: \'", typeid(*pSrcPtr).name(), "\' Dst typeid: \'", typeid(DstType).name(), '\'');
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15b858
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x15b796
movq -0x58(%rbp), %rdi
leaq 0xe745e0(%rip), %rsi # 0xfcfd60
leaq 0xe76911(%rip), %rdx # 0xfd2098
xorl %eax, %eax
movl %eax, %ecx
callq 0xde56... | /DiligentGraphics[P]DiligentCore/Common/interface/../../Platforms/Basic/interface/DebugUtilities.hpp |
Diligent::DynamicStaleResourceWrapper Diligent::DynamicStaleResourceWrapper::Create<VulkanUtilities::VulkanSyncObjectManager::RecycledSyncObject<VulkanUtilities::VkSemaphoreType>, void>(VulkanUtilities::VulkanSyncObjectManager::RecycledSyncObject<VulkanUtilities::VkSemaphoreType>&&, long) | static DynamicStaleResourceWrapper Create(ResourceType&& Resource, RefCounterType NumReferences)
{
VERIFY_EXPR(NumReferences >= 1);
class SpecificStaleResource final : public StaleResourceBase
{
public:
SpecificStaleResource(ResourceType&& SpecificResource) :
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
jge 0x162e81
jmp 0x162e1b
leaq 0x9a33db(%rip), %rsi # 0xb061fd
leaq 0x9a48b0(%rip), %rdx # 0xb076d9
leaq -0x38(%rbp),... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsAccessories/interface/ResourceReleaseQueue.hpp |
Diligent::RenderPassBase<Diligent::EngineVkImplTraits>::GetAttachmentState(unsigned int, unsigned int) const | RESOURCE_STATE GetAttachmentState(Uint32 Subpass, Uint32 Attachment) const
{
VERIFY_EXPR(Attachment < this->m_Desc.AttachmentCount);
VERIFY_EXPR(Subpass < this->m_Desc.SubpassCount);
return m_AttachmentStates[this->m_Desc.AttachmentCount * Subpass + Attachment];
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x20(%rcx), %eax
jb 0x168211
jmp 0x1681ab
leaq 0x99e04b(%rip), %rsi # 0xb061fd
leaq 0x9aaecd(%rip), %rdx # ... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngine/include/RenderPassBase.hpp |
Diligent::FramebufferBase<Diligent::EngineVkImplTraits>::GetReadOnlyDSV(unsigned int) const | ITextureView* GetReadOnlyDSV(Uint32 Subpass) const
{
VERIFY(Subpass < this->m_Desc.pRenderPass->GetDesc().SubpassCount, "Subpass index (", Subpass, ") is out of range.");
return m_ppReadOnlyDSVs != nullptr ?
m_ppReadOnlyDSVs[Subpass] :
nullptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, -0x4c(%rbp)
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %rcx
movl -0x4c(%rbp), %eax
cmpl 0x18(%rcx), %eax
... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngine/include/FramebufferBase.hpp |
Diligent::DeviceContextBase<Diligent::EngineVkImplTraits>::CheckIfBoundAsRenderTarget(Diligent::TextureVkImpl*) | bool DeviceContextBase<ImplementationTraits>::CheckIfBoundAsRenderTarget(TextureImplType* pTexture)
{
if (pTexture == nullptr)
return false;
for (Uint32 rt = 0; rt < m_NumBoundRenderTargets; ++rt)
{
if (m_pBoundRenderTargets[rt] && m_pBoundRenderTargets[rt]->GetTexture() == pTexture)
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x16c785
movb $0x0, -0x1(%rbp)
jmp 0x16c7fa
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x518(%rcx), %eax
jae 0x16c7f6
movq -0x... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngine/include/DeviceContextBase.hpp |
Diligent::ObjectBase<Diligent::ICommandList>::QueryInterface(Diligent::INTERFACE_ID const&, Diligent::IObject**) | QueryInterface(const INTERFACE_ID& IID, IObject** ppInterface)
{
if (ppInterface == nullptr)
return;
*ppInterface = nullptr;
if (IID == IID_Unknown)
{
*ppInterface = this;
(*ppInterface)->AddRef();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x16faa5
jmp 0x16fade
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x99a2ed(%rip), %rsi # 0xb09da8
callq 0xed... | /DiligentGraphics[P]DiligentCore/Common/interface/ObjectBase.hpp |
void Diligent::LogError<true, char [41], char [60]>(bool, char const*, char const*, int, char const (&) [41], char const (&) [60]) | void LogError(bool IsFatal, const char* Function, const char* FullFilePath, int Line, const ArgsType&... Args)
{
std::string FileName(FullFilePath);
auto LastSlashPos = FileName.find_last_of("/\\");
if (LastSlashPos != std::string::npos)
FileName.erase(0, LastSlashPos + 1);
auto Msg = FormatStr... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x98(... | /DiligentGraphics[P]DiligentCore/Primitives/interface/Errors.hpp |
void Diligent::LogError<true, char [41], char [23], unsigned int, char [36]>(bool, char const*, char const*, int, char const (&) [41], char const (&) [23], unsigned int const&, char const (&) [36]) | void LogError(bool IsFatal, const char* Function, const char* FullFilePath, int Line, const ArgsType&... Args)
{
std::string FileName(FullFilePath);
auto LastSlashPos = FileName.find_last_of("/\\");
if (LastSlashPos != std::string::npos)
FileName.erase(0, LastSlashPos + 1);
auto Msg = FormatStr... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movb %dil, %al
movq 0x18(%rbp), %rdi
movq 0x10(%rbp), %rdi
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%r... | /DiligentGraphics[P]DiligentCore/Primitives/interface/Errors.hpp |
Diligent::DeviceObjectBase<Diligent::IDeviceMemoryVk, Diligent::RenderDeviceVkImpl, Diligent::DeviceMemoryDesc>::Release() | Release() override final
{
// Render device owns allocators for all types of device objects,
// so it must be destroyed after all device objects are released.
// Consider the following scenario: an object A owns the last strong
// reference to the device:
//
// 1. A::... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xf88f0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x17fb60
movl %eax, -0x30(%r... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngine/include/DeviceObjectBase.hpp |
Diligent::DynamicLinearAllocator::Allocate(unsigned long, unsigned long) | NODISCARD void* Allocate(size_t size, size_t align)
{
if (size == 0)
return nullptr;
for (auto& block : m_Blocks)
{
auto* Ptr = AlignUp(block.CurrPtr, align);
if (Ptr + size <= block.Data + block.Size)
{
block.CurrPtr = Ptr + s... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x180d56
movq $0x0, -0x8(%rbp)
jmp 0x180f33
movq -0xa0(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x180f50
movq %... | /DiligentGraphics[P]DiligentCore/Common/interface/DynamicLinearAllocator.hpp |
bool Diligent::Serializer<(Diligent::SerializerMode)1>::Copy<unsigned int const>(unsigned int const*, unsigned long) | bool Serializer<SerializerMode::Write>::Copy(T* pData, size_t Size)
{
static_assert(IsAlignedBaseClass<T>::Value, "There is unused space at the end of the structure that may be filled with garbage. Use padding to zero-initialize this space and avoid nasty issues.");
CHECK_REMAINING_SIZE(Size, "Note enough data ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq 0x10(%rcx), %rax
addq -0x20(%rbp), %rax
cmpq 0x8(%rcx), %rax
jbe 0x1831eb
jmp 0x183180
leaq 0x993d4b(%rip), %rsi # 0xb16ed2
leaq 0... | /DiligentGraphics[P]DiligentCore/Common/interface/Serializer.hpp |
bool Diligent::Serializer<(Diligent::SerializerMode)2>::SerializeArray<Diligent::ImmutableSamplerAttribsVk const* const, unsigned int const, bool Diligent::Serializer<(Diligent::SerializerMode)2>::SerializeArrayRaw<Diligent::ImmutableSamplerAttribsVk const* const, unsigned int const>(Diligent::DynamicLinearAllocator*, ... | bool Serializer<Mode>::SerializeArray(DynamicLinearAllocator* Allocator,
ElemPtrType& SrcArray,
CountType& Count,
ArrayElemSerializerType ElemSerializer)
{
VERIFY_EXPR((SrcArray ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movq -0x28(%rbp), %rcx
cmpl $0x0, (%rcx)
setne %cl
andb... | /DiligentGraphics[P]DiligentCore/Common/interface/Serializer.hpp |
Diligent::(anonymous namespace)::EngineFactoryVkImpl::CreateSwapChainVk(Diligent::IRenderDevice*, Diligent::IDeviceContext*, Diligent::SwapChainDesc const&, Diligent::LinuxNativeWindow const&, Diligent::ISwapChain**) | void EngineFactoryVkImpl::CreateSwapChainVk(IRenderDevice* pDevice,
IDeviceContext* pImmediateContext,
const SwapChainDesc& SCDesc,
const NativeWindow& Window,
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1892f1
jmp 0x18928c
leaq 0x97d349(%rip), %rsi # 0xb065dc
leaq -0x50(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq ... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/EngineFactoryVk.cpp |
Diligent::IEngineFactoryVk::IEngineFactoryVk() | DILIGENT_BEGIN_INTERFACE(IEngineFactoryVk, IEngineFactory)
{
/// Creates a render device and device contexts for Vulkan backend
/// \param [in] EngineCI - Engine creation attributes.
/// \param [out] ppDevice - Address of the memory location where pointer to
/// the creat... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x18c4f0
movq -0x10(%rbp), %rax
leaq 0xe44404(%rip), %rcx # 0xfd0858
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/interface/EngineFactoryVk.h |
Diligent::RefCntWeakPtr<Diligent::IRenderDevice>::IsValid() const | bool IsValid() const noexcept
{
return m_pObject != nullptr && m_pRefCounters != nullptr && m_pRefCounters->GetNumStrongRefs() > 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x9(%rbp)
je 0x18cafc
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x9(%rbp)
je 0x18cafc
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x... | /DiligentGraphics[P]DiligentCore/Common/interface/RefCntAutoPtr.hpp |
Diligent::MakeNewRCObj<Diligent::CommandQueueVkImpl, Diligent::IMemoryAllocator>::MakeNewRCObj(Diligent::IMemoryAllocator&, char const*, char const*, int, Diligent::IObject*) | MakeNewRCObj(AllocatorType& Allocator, const Char* Description, const char* FileName, const Int32 LineNumber, IObject* pOwner = nullptr) noexcept :
// clang-format off
m_pAllocator{&Allocator},
m_pOwner{pOwner}
#ifdef DILIGENT_DEVELOPMENT
, m_dvpDescription{Description}
, m_dvpFileNa... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq ... | /DiligentGraphics[P]DiligentCore/Common/interface/RefCountedObjectImpl.hpp |
Diligent::MakeNewRCObj<Diligent::RenderDeviceVkImpl, Diligent::IMemoryAllocator>::MakeNewRCObj(Diligent::IMemoryAllocator&, char const*, char const*, int, Diligent::IObject*) | MakeNewRCObj(AllocatorType& Allocator, const Char* Description, const char* FileName, const Int32 LineNumber, IObject* pOwner = nullptr) noexcept :
// clang-format off
m_pAllocator{&Allocator},
m_pOwner{pOwner}
#ifdef DILIGENT_DEVELOPMENT
, m_dvpDescription{Description}
, m_dvpFileNa... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq ... | /DiligentGraphics[P]DiligentCore/Common/interface/RefCountedObjectImpl.hpp |
Diligent::FenceVkImpl::~FenceVkImpl() | FenceVkImpl::~FenceVkImpl()
{
if (IsTimelineSemaphore())
{
VERIFY_EXPR(m_SyncPoints.empty());
m_pDevice->SafeReleaseDeviceObject(std::move(m_TimelineSemaphore), ~0ull);
}
else if (!m_SyncPoints.empty())
{
LOG_INFO_MESSAGE("FenceVkImpl::~FenceVkImpl(): waiting for ", m_SyncPoi... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x131f00
movb %al, -0x79(%rbp)
jmp 0x19aa44
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x19aa50
jmp 0x19aadd
jmp 0x19aa52
movq -0x88(%rbp), %rdi
addq $0x88, %rdi
callq 0x19c6e0
testb $0x1, %al
jne 0x19aab... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineVulkan/src/FenceVkImpl.cpp |
void Diligent::RenderDeviceNextGenBase<Diligent::RenderDeviceBase<Diligent::EngineVkImplTraits>, Diligent::ICommandQueueVk>::SafeReleaseDeviceObject<VulkanUtilities::VulkanObjectWrapper<VkSemaphore_T*, (VulkanUtilities::VulkanHandleTypeId)17>, void>(VulkanUtilities::VulkanObjectWrapper<VkSemaphore_T*, (VulkanUtilities:... | void SafeReleaseDeviceObject(ObjectType&& Object, Uint64 QueueMask)
{
VERIFY(m_CommandQueues != nullptr, "Command queues have been destroyed. Are you releasing an object from the render device destructor?");
QueueMask &= GetCommandQueueMask();
VERIFY(QueueMask != 0, "At least one bit shoul... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
cmpq $0x0, 0x1c48(%rax)
jne 0x19c7aa
jmp 0x19c745
leaq 0x96ae2d(%rip), %rsi # 0xb07579
leaq -0x50(%rbp), %rdi... | /DiligentGraphics[P]DiligentCore/Graphics/GraphicsEngineNextGenBase/include/RenderDeviceNextGenBase.hpp |
Diligent::RefCountedObject<Diligent::IFenceVk>::~RefCountedObject() | virtual ~RefCountedObject()
{
// WARNING! m_pRefCounters may be expired in scenarios like this:
//
// A ==sp==> B ---wp---> A
//
// RefCounters_A.ReleaseStrongRef(){ // NumStrongRef == 0, NumWeakRef == 1
// bDestroyThis = (m_NumWeakReferences == 0) == false... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
ud2
nopw (%rax,%rax)
| /DiligentGraphics[P]DiligentCore/Common/interface/RefCountedObjectImpl.hpp |
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.