name string | code string | asm string | file string |
|---|---|---|---|
upb_DefPool_InsertSym | bool _upb_DefPool_InsertSym(upb_DefPool* s, upb_StringView sym, upb_value v,
upb_Status* status) {
// TODO: table should support an operation "tryinsert" to avoid the double
// lookup.
if (upb_strtable_lookup2(&s->syms, sym.data, sym.size, NULL)) {
upb_Status_SetErrorFormat(status,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbp
leaq 0x8(%rdi), %r13
movq %r13, %rdi
xorl %ecx, %ecx
callq 0x2427c
testb %al, %al
je 0x17ebb
leaq 0x1b2d1(%rip), %rsi # 0x3317b
xorl %ebp, %ebp
movq %rbx, %rdi
... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/reflection/def_pool.c |
upb_DefPool_AddFile | static const upb_FileDef* _upb_DefPool_AddFile(
upb_DefPool* s, const UPB_DESC(FileDescriptorProto) * file_proto,
const upb_MiniTableFile* layout, upb_Status* status) {
const upb_StringView name = UPB_DESC(FileDescriptorProto_name)(file_proto);
// Determine whether we already know about this file.
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x129ac(%rip), %rax # 0x2ac2f
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
andq $0x0, 0x8(%rsi)
leaq 0x1ade1(%rip), %rdi # 0x33078
callq 0x... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/reflection/def_pool.c |
upb_MiniTableField_DataIsZero_dont_copy_me__upb_internal_use_only | UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_DataIsZero)(
const upb_MiniTableField* f, const void* val) {
const char zero[16] = {0};
return UPB_PRIVATE(_upb_MiniTableField_DataEquals)(f, val, zero);
} | xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
movzbl 0xb(%rdi), %eax
shrl $0x6, %eax
leaq 0x1a8be(%rip), %rcx # 0x32fc4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x0, (%rsi)
jmp 0x1872b
cmpq $0x0, 0x8(%rsi)
jmp 0x1872b
movq (%rsi), %rax
cmpq -0x18(%rsp), %rax
jmp 0x1872b
movl (%rsi), %eax
cmpl -0x1... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/accessors.h |
upb_EnumDef_MiniDescriptorEncode | bool upb_EnumDef_MiniDescriptorEncode(const upb_EnumDef* e, upb_Arena* a,
upb_StringView* out) {
upb_DescState s;
_upb_DescState_Init(&s);
const upb_EnumValueDef** sorted = NULL;
if (!e->is_sorted) {
sorted = _upb_EnumValueDefs_Sorted(e->values, e->value_count, a);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x20, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
cmpb $0x0, 0xb0(%rdi)
je 0x18d89
xorl %r12d, %r12d
jmp 0x18dab
movq 0x88(%r15), %rdi
movl 0xa0(%r15), %esi
movq %r14, %rdx... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/reflection/enum_def.c |
upb_Message_HasBaseField | UPB_API_INLINE bool upb_Message_HasBaseField(const struct upb_Message* msg,
const upb_MiniTableField* field) {
UPB_ASSERT(upb_MiniTableField_HasPresence(field));
UPB_ASSUME(!upb_MiniTableField_IsExtension(field));
if (upb_MiniTableField_IsInOneof(field)) {
return U... | pushq %rax
movb 0xb(%rsi), %al
testb $0x8, %al
jne 0x194d4
movzwl 0x6(%rsi), %eax
testq %rax, %rax
je 0x194f9
testw %ax, %ax
js 0x194c5
movl %eax, %ecx
shrl $0x3, %ecx
movzbl (%rdi,%rcx), %ecx
andl $0x7, %eax
btl %eax, %ecx
setb %al
jmp 0x194d2
xorl $0xffff, %eax # imm = 0xFFFF
movl (%rdi,%rax), %eax
cmpl (%r... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/accessors.h |
upb_Message_GetArray | UPB_API_INLINE const upb_Array* upb_Message_GetArray(
const struct upb_Message* msg, const upb_MiniTableField* f) {
UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(f);
upb_Array* ret;
const upb_Array* default_val = NULL;
_upb_Message_GetNonExtensionField(msg, f, &default_val, &ret);
return ret;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movb 0xb(%rsi), %al
cmpb $-0x41, %al
jbe 0x19626
movl %eax, %ecx
andb $0x3, %cl
cmpb $0x1, %cl
jne 0x19645
movq %rsi, %rbx
cmpw $0x0, 0x6(%rsi)
jne 0x19664
andq $0x0, 0x8(%rsp)
testb $0x8, %al
jne 0x19683
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1945c
testb %al... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/accessors.h |
upb_EnumReservedRanges_New | upb_EnumReservedRange* _upb_EnumReservedRanges_New(
upb_DefBuilder* ctx, int n,
const UPB_DESC(EnumDescriptorProto_EnumReservedRange) * const* protos,
const upb_EnumDef* e) {
upb_EnumReservedRange* r =
_upb_DefBuilder_Alloc(ctx, sizeof(upb_EnumReservedRange) * n);
for (int i = 0; i < n; i++) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %rbp
movl %esi, %r14d
xorl %ebx, %ebx
testl %esi, %esi
movq %rdi, 0x8(%rsp)
je 0x1971b
movslq %r14d, %rsi
shlq $0x3, %rsi
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
cmpq ... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/reflection/enum_reserved_range.c |
upb_EnumValueDefs_Sorted | const upb_EnumValueDef** _upb_EnumValueDefs_Sorted(const upb_EnumValueDef* v,
int n, upb_Arena* a) {
// TODO: Try to replace this arena alloc with a persistent scratch buffer.
upb_EnumValueDef** out =
(upb_EnumValueDef**)upb_Arena_Malloc(a, n * sizeof(void*))... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r12
movslq %esi, %rbx
leaq (,%rbx,8), %rsi
movq %rdx, %rdi
callq 0x199af
movq %rax, %r14
testq %rax, %rax
je 0x199a0
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %rax, %r15
je 0x1998b
movq %r12, (%r14,%rax,8)
incq %rax
ad... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/reflection/enum_value_def.c |
upb_Arena_Malloc | UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size) {
void* UPB_PRIVATE(_upb_Arena_SlowMalloc)(struct upb_Arena * a, size_t size);
size = UPB_ALIGN_MALLOC(size);
const size_t span = size + UPB_ASAN_GUARD_SIZE;
if (UPB_UNLIKELY(UPB_PRIVATE(_upb_ArenaHas)(a) < span)) {
return UPB_PRIVATE(... | addq $0x7, %rsi
andq $-0x8, %rsi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
cmpq %rsi, %rcx
jb 0x16225
leaq 0x7(%rax), %rcx
andq $-0x8, %rcx
cmpq %rax, %rcx
jne 0x199de
addq %rax, %rsi
movq %rsi, (%rdi)
retq
pushq %rax
leaq 0x15679(%rip), %rdi # 0x2f05f
leaq 0x156af(%rip), %rsi # 0x2f09c
leaq 0x1572... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mem/internal/arena.h |
upb_EnumValueDefs_New | upb_EnumValueDef* _upb_EnumValueDefs_New(
upb_DefBuilder* ctx, const char* prefix, int n,
const UPB_DESC(EnumValueDescriptorProto*) const* protos,
const UPB_DESC(FeatureSet*) parent_features, upb_EnumDef* e,
bool* is_sorted) {
_upb_DefType_CheckPadding(sizeof(upb_EnumValueDef));
upb_EnumValueDef* v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, 0x20(%rsp)
movq %r8, 0x68(%rsp)
movq %rcx, 0x70(%rsp)
movl %edx, %ebx
movq %rsi, 0x60(%rsp)
movq %rdi, %r13
xorl %r14d, %r14d
testl %edx, %edx
je 0x19ab5
movslq %ebx, %rax
imulq $0x28, %rax, %rsi
movq 0x48(%r13), %rdi
callq 0x1... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/reflection/enum_value_def.c |
upb_Message_HasBaseField | UPB_API_INLINE bool upb_Message_HasBaseField(const struct upb_Message* msg,
const upb_MiniTableField* field) {
UPB_ASSERT(upb_MiniTableField_HasPresence(field));
UPB_ASSUME(!upb_MiniTableField_IsExtension(field));
if (upb_MiniTableField_IsInOneof(field)) {
return U... | pushq %rax
movb 0xb(%rsi), %al
testb $0x8, %al
jne 0x19e7a
movzwl 0x6(%rsi), %eax
testq %rax, %rax
je 0x19e9f
testw %ax, %ax
js 0x19e6b
movl %eax, %ecx
shrl $0x3, %ecx
movzbl (%rdi,%rcx), %ecx
andl $0x7, %eax
btl %eax, %ecx
setb %al
jmp 0x19e78
xorl $0xffff, %eax # imm = 0xFFFF
movl (%rdi,%rax), %eax
cmpl (%r... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/accessors.h |
upb_FieldDef_IsPacked | bool upb_FieldDef_IsPacked(const upb_FieldDef* f) {
return _upb_FieldDef_IsPackable(f) &&
UPB_DESC(FeatureSet_repeated_field_encoding(f->resolved_features)) ==
UPB_DESC(FeatureSet_PACKED);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x19f80
testb %al, %al
je 0x1a00f
movq 0x8(%rbx), %rbx
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
leaq 0x19ceb(%rip), %rdi # 0x33cbc
callq 0x1b017
testb %al, %al
jne 0x19fed
leaq 0x19cdb(%rip), %rsi # 0x33cbc
movq %rbx, %rdi
callq 0x1b056
testb %al, %al
je 0x1a... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/reflection/field_def.c |
upb_FieldDef_MiniTable | const upb_MiniTableField* upb_FieldDef_MiniTable(const upb_FieldDef* f) {
if (upb_FieldDef_IsExtension(f)) {
const upb_FileDef* file = upb_FieldDef_File(f);
return (upb_MiniTableField*)_upb_FileDef_ExtensionMiniTable(
file, f->layout_index);
} else {
const upb_MiniTable* layout = upb_MessageDef_... | pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x53(%rdi)
jne 0x1a17c
movq 0x10(%rbx), %rdi
movzwl 0x4e(%rbx), %esi
popq %rbx
jmp 0x1be0f
movq 0x18(%rbx), %rdi
callq 0x1d91a
movzwl 0x4e(%rbx), %ecx
imulq $0xc, %rcx, %rcx
addq 0x8(%rax), %rcx
movq %rcx, %rax
popq %rbx
retq
| /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/reflection/field_def.c |
upb_FieldDef_IsGroupLike | bool _upb_FieldDef_IsGroupLike(const upb_FieldDef* f) {
// Groups are always tag-delimited.
if (f->type_ != kUpb_FieldType_Group) {
return false;
}
const upb_MessageDef* msg = upb_FieldDef_MessageSubDef(f);
// Group fields always are always the lowercase type name.
const char* mname = upb_MessageDef_N... | cmpl $0xa, 0x58(%rdi)
jne 0x1a2b0
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %r14
movq %r14, %rdi
callq 0x1d79a
movq %rax, %r15
movq %rbx, %rdi
callq 0x1a019
movq %rax, %r12
movq %rax, %rdi
callq 0x9130
movq %rax, %r13
movq %r15, %rdi
callq 0x9130
cmpq %rax, %r13
jne 0x1a2c1... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/reflection/field_def.c |
upb_MessageDef_Resolve | void _upb_MessageDef_Resolve(upb_DefBuilder* ctx, upb_MessageDef* m) {
for (int i = 0; i < m->field_count; i++) {
upb_FieldDef* f = (upb_FieldDef*)upb_MessageDef_Field(m, i);
_upb_FieldDef_Resolve(ctx, m->full_name, f);
}
m->in_message_set = false;
for (int i = 0; i < upb_MessageDef_NestedExtensionCoun... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
cmpl 0xe8(%rbx), %ebp
jge 0x1dc08
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1d99a
movq 0x28(%rbx), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x1a930
incl %ebp
jmp 0x1dbe3
movb $0x0, 0x10c(%rbx)
xorl %ebp, %ebp
cmpl 0x1... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/reflection/message_def.c |
upb_Message_HasBaseField | UPB_API_INLINE bool upb_Message_HasBaseField(const struct upb_Message* msg,
const upb_MiniTableField* field) {
UPB_ASSERT(upb_MiniTableField_HasPresence(field));
UPB_ASSUME(!upb_MiniTableField_IsExtension(field));
if (upb_MiniTableField_IsInOneof(field)) {
return U... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1e3a2
testb %al, %al
je 0x1f215
testb $0x8, 0xb(%r14)
jne 0x1f234
movzwl 0x6(%r14), %eax
testw %ax, %ax
js 0x1f1ff
testq %rax, %rax
je 0x1f253
movl %eax, %ecx
shrl $0x3, %ecx
movzbl (%rbx,%rcx), %ecx
andl $0x7, %eax
btl %eax, %ecx
... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/accessors.h |
upb_ServiceDefs_New | upb_ServiceDef* _upb_ServiceDefs_New(upb_DefBuilder* ctx, int n,
const UPB_DESC(ServiceDescriptorProto*)
const* protos,
const UPB_DESC(FeatureSet*)
parent_features)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r15
movq %rdx, 0x58(%rsp)
movq %rdi, %r12
xorl %ecx, %ecx
testl %esi, %esi
je 0x1ff13
movslq %esi, %rax
movq %rsi, %rbx
imulq $0x30, %rax, %rsi
movq 0x48(%r12), %rdi
callq 0x2025f
movq %rbx, %rsi
movq %rax, %r13
xorl %ecx, %e... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/reflection/service_def.c |
upb_Arena_Malloc | UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size) {
void* UPB_PRIVATE(_upb_Arena_SlowMalloc)(struct upb_Arena * a, size_t size);
size = UPB_ALIGN_MALLOC(size);
const size_t span = size + UPB_ASAN_GUARD_SIZE;
if (UPB_UNLIKELY(UPB_PRIVATE(_upb_ArenaHas)(a) < span)) {
return UPB_PRIVATE(... | addq $0x7, %rsi
andq $-0x8, %rsi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
cmpq %rsi, %rcx
jb 0x16225
leaq 0x7(%rax), %rcx
andq $-0x8, %rcx
cmpq %rax, %rcx
jne 0x2028e
addq %rax, %rsi
movq %rsi, (%rdi)
retq
pushq %rax
leaq 0xedc9(%rip), %rdi # 0x2f05f
leaq 0xedff(%rip), %rsi # 0x2f09c
leaq 0xee7a... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mem/internal/arena.h |
upb_MiniTableField_DataIsZero_dont_copy_me__upb_internal_use_only | UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_DataIsZero)(
const upb_MiniTableField* f, const void* val) {
const char zero[16] = {0};
return UPB_PRIVATE(_upb_MiniTableField_DataEquals)(f, val, zero);
} | xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
movzbl 0xb(%rdi), %eax
shrl $0x6, %eax
leaq 0x158d9(%rip), %rcx # 0x35c18
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x0, (%rsi)
jmp 0x20364
cmpq $0x0, 0x8(%rsi)
jmp 0x20364
movq (%rsi), %rax
cmpq -0x18(%rsp), %rax
jmp 0x20364
movl (%rsi), %eax
cmpl -0x1... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/accessors.h |
upb_Decode | upb_DecodeStatus upb_Decode(const char* buf, size_t size, upb_Message* msg,
const upb_MiniTable* mt,
const upb_ExtensionRegistry* extreg, int options,
upb_Arena* arena) {
UPB_ASSERT(!upb_Message_IsFrozen(msg));
upb_Decoder decoder;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
testb $0x1, (%rdx)
jne 0x21c19
movl %r9d, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq %rcx, 0x10(%rsp)
movq 0x1d0(%rsp), %rsi
movl %r9d, %r12d
andl $0x1, %r12d
cmpq $0x10, %r15
ja 0x21b8b
leaq 0x35... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/wire/decode.c |
upb_Decoder_Decode | static upb_DecodeStatus upb_Decoder_Decode(upb_Decoder* const decoder,
const char* const buf,
upb_Message* const msg,
const upb_MiniTable* const m,
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
addq $0xa8, %rdi
callq 0x9510
testl %eax, %eax
je 0x21c88
cmpl $0x0, 0xa0(%rbx)
jne 0x21cb1
leaq 0x15424(%rip), %rdi # 0x37094
leaq 0x14199(%rip), %rsi # 0x35e10
leaq 0x1543e(%ri... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/wire/decode.c |
upb_DecodeStatus_String | const char* upb_DecodeStatus_String(upb_DecodeStatus status) {
switch (status) {
case kUpb_DecodeStatus_Ok:
return "Ok";
case kUpb_DecodeStatus_Malformed:
return "Wire format was corrupt";
case kUpb_DecodeStatus_OutOfMemory:
return "Arena alloc failed";
case kUpb_DecodeStatus_BadUtf8... | cmpl $0x6, %edi
ja 0x21d77
movl %edi, %eax
leaq 0x14085(%rip), %rcx # 0x35df4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x1431e(%rip), %rax # 0x3609c
retq
| /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/wire/decode.c |
upb_Decoder_DecodeLongVarint | UPB_NOINLINE
static _upb_DecodeLongVarintReturn _upb_Decoder_DecodeLongVarint(
const char* ptr, uint64_t val) {
_upb_DecodeLongVarintReturn ret = {NULL, 0};
uint64_t byte;
for (int i = 1; i < 10; i++) {
byte = (uint8_t)ptr[i];
val += (byte - 1) << (i * 7);
if (!(byte & 0x80)) {
ret.ptr = ptr... | movq %rsi, %rdx
movq %rdi, %rax
incq %rax
pushq $0x7
popq %rcx
cmpq $0x46, %rcx
je 0x21dd5
movzbl (%rax), %esi
movq %rsi, %rdi
decq %rdi
shlq %cl, %rdi
addq %rdi, %rdx
incq %rax
addq $0x7, %rcx
testb %sil, %sil
js 0x21db3
retq
xorl %edx, %edx
xorl %eax, %eax
retq
| /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/wire/decode.c |
upb_inttable_compact | void upb_inttable_compact(upb_inttable* t, upb_Arena* a) {
/* A power-of-two histogram of the table keys. */
size_t counts[UPB_MAXARRSIZE + 1] = {0};
/* The max key in each bucket. */
uintptr_t max[UPB_MAXARRSIZE + 1] = {0};
{
intptr_t iter = UPB_INTTABLE_BEGIN;
uintptr_t key;
upb_value val;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf0(%rsp), %rdi
movl $0x88, %edx
xorl %esi, %esi
callq 0x91e0
leaq 0x60(%rsp), %rdi
movl $0x88, %edx
xorl %esi, %esi
callq 0x91e0
leaq 0x28(%rsp), %r15
orq $-0x1, (%r15)
lea... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/hash/common.c |
upb_inttable_removeiter | void upb_inttable_removeiter(upb_inttable* t, intptr_t* iter) {
intptr_t i = *iter;
if ((size_t)i < t->array_size) {
t->array_count--;
mutable_array(t)[i].val = -1;
} else {
upb_tabent* ent = &t->t.entries[i - t->array_size];
upb_tabent* prev = NULL;
// Linear search, not great.
upb_taben... | movq (%rsi), %rax
movq %rax, %rcx
subq 0x28(%rdi), %rcx
jae 0x24c1f
decq 0x30(%rdi)
movq 0x20(%rdi), %rcx
orq $-0x1, (%rcx,%rax,8)
retq
movq 0x18(%rdi), %rdx
imulq $0x18, %rcx, %rax
movb 0x10(%rdi), %cl
pushq $0x1
popq %r8
shll %cl, %r8d
addq %rdx, %rax
xorl %esi, %esi
testb %cl, %cl
movslq %r8d, %rcx
cmoveq %rsi, %rcx... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/hash/common.c |
upb_Arena_Malloc | UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size) {
void* UPB_PRIVATE(_upb_Arena_SlowMalloc)(struct upb_Arena * a, size_t size);
size = UPB_ALIGN_MALLOC(size);
const size_t span = size + UPB_ASAN_GUARD_SIZE;
if (UPB_UNLIKELY(UPB_PRIVATE(_upb_ArenaHas)(a) < span)) {
return UPB_PRIVATE(... | addq $0x7, %rsi
andq $-0x8, %rsi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
cmpq %rsi, %rcx
jb 0x16225
leaq 0x7(%rax), %rcx
andq $-0x8, %rcx
cmpq %rax, %rcx
jne 0x25d97
addq %rax, %rsi
movq %rsi, (%rdi)
retq
pushq %rax
leaq 0x92c0(%rip), %rdi # 0x2f05f
leaq 0x92f6(%rip), %rsi # 0x2f09c
leaq 0x9371... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mem/internal/arena.h |
upb_Message_SetBaseField | UPB_API_INLINE void upb_Message_SetBaseField(struct upb_Message* msg,
const upb_MiniTableField* f,
const void* val) {
UPB_ASSERT(!upb_Message_IsFrozen(msg));
UPB_ASSUME(!upb_MiniTableField_IsExtension(f));
UPB_PRIVATE(_upb_M... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testb $0x1, (%rdi)
jne 0x25fb9
movq %rsi, %r15
testb $0x8, 0xb(%rsi)
jne 0x25fd8
movq %rdx, %rbx
movq %rdi, %r14
cmpw $0x0, 0x6(%r15)
jle 0x25f86
movq %r15, %rdi
callq 0x25eeb
movq %rax, %r12
movq %r15, %rdi
callq 0x25f18
orb %al, (%r14,%r12)
jmp 0x25f98
jns 0x25f9... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/accessors.h |
upb_MiniTableField_CheckIsMap_dont_copy_me__upb_internal_use_only | UPB_INLINE void UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(
const struct upb_MiniTableField* f) {
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) ==
kUpb_FieldRep_NativePointer);
UPB_ASSUME(upb_MiniTableField_IsMap(f));
UPB_ASSUME(f->presence == 0);
} | pushq %rax
movb 0xb(%rdi), %al
cmpb $-0x41, %al
jbe 0x2600c
testb $0x3, %al
jne 0x2602b
cmpw $0x0, 0x6(%rdi)
jne 0x2604a
popq %rax
retq
leaq 0x8e44(%rip), %rdi # 0x2ee57
leaq 0x473e(%rip), %rsi # 0x2a758
leaq 0xc9db(%rip), %rcx # 0x329fc
movl $0xcc, %edx
callq 0x9250
leaq 0xca35(%rip), %rdi # 0x32a6... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mini_table/internal/field.h |
upb_Map_Get | bool upb_Map_Get(const upb_Map* map, upb_MessageValue key,
upb_MessageValue* val) {
return _upb_Map_Get(map, &key, map->key_size, val, map->val_size);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movsbq (%rdi), %rcx
testq %rcx, %rcx
cmovneq %rax, %rsi
movsbq 0x1(%rdi), %r14
cmovneq %rcx, %rdx
addq $0x8, %rdi
movq %rsp, %rcx
callq 0x2427c
movl %eax, %ebp
xorb $0x1, %al
testq %rbx, %rbx
s... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/map.c |
upb_Map_Next | bool upb_Map_Next(const upb_Map* map, upb_MessageValue* key,
upb_MessageValue* val, size_t* iter) {
upb_StringView k;
upb_value v;
const bool ok = upb_strtable_next2(&map->table, &k, &v, (intptr_t*)iter);
if (ok) {
_upb_map_fromkey(k, key, map->key_size);
_upb_map_fromvalue(v, val, map... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
addq $0x8, %rdi
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x23f71
movl %eax, %ebp
testb %al, %al
je 0x263fa
movsbq (%r14), %rdx
movq 0x18(%rsp), %rsi
testq %rdx, %rdx
je 0x263c5
movq %r15, %rdi
callq 0x92... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/map.c |
upb_MapIterator_Next | bool upb_MapIterator_Next(const upb_Map* map, size_t* iter) {
return _upb_map_next(map, iter);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
addq $0x8, %rdi
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movq (%rsi), %rax
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x24440
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x24491
testb %al, %al
je 0x264d4
xorl %eax, %eax
jmp 0x264e1
movq 0x8(%rsp), %r... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/map.c |
upb_MapIterator_Done | bool upb_MapIterator_Done(const upb_Map* map, size_t iter) {
upb_strtable_iter i;
UPB_ASSERT(iter != kUpb_Map_Begin);
i.t = &map->table;
i.index = iter;
return upb_strtable_done(&i);
} | subq $0x18, %rsp
cmpq $-0x1, %rsi
je 0x26510
addq $0x8, %rdi
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
movq %rax, %rdi
callq 0x24491
addq $0x18, %rsp
retq
leaq 0x1289e(%rip), %rdi # 0x38db5
leaq 0x127bd(%rip), %rsi # 0x38cdb
leaq 0x128a7(%rip), %rcx # 0x38dcc
pushq $0x60
popq %rdx
callq 0x... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/map.c |
upb_MapIterator_Key | upb_MessageValue upb_MapIterator_Key(const upb_Map* map, size_t iter) {
upb_strtable_iter i;
upb_MessageValue ret;
i.t = &map->table;
i.index = iter;
_upb_map_fromkey(upb_strtable_iter_key(&i), &ret, map->key_size);
return ret;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
callq 0x244c4
movsbq (%rbx), %rcx
testq %rcx, %rcx
je 0x2656b
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
movq %rcx, %rdx
callq 0x92d0
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x20, %rsp... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/map.c |
upb_Map_Freeze | void upb_Map_Freeze(upb_Map* map, const upb_MiniTable* m) {
if (upb_Map_IsFrozen(map)) return;
UPB_PRIVATE(_upb_Map_ShallowFreeze)(map);
if (m) {
size_t iter = kUpb_Map_Begin;
upb_MessageValue key, val;
while (upb_Map_Next(map, &key, &val, &iter)) {
upb_Message_Freeze((upb_Message*)val.msg_val... | cmpb $0x0, 0x2(%rdi)
jne 0x26628
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x2(%rdi)
testq %rsi, %rsi
je 0x2661b
leaq 0x18(%rsp), %r15
orq $-0x1, (%r15)
leaq 0x20(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
mov... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/map.c |
upb_mapsorter_pushexts | bool _upb_mapsorter_pushexts(_upb_mapsorter* s, const upb_Extension* exts,
size_t count, _upb_sortedmap* sorted) {
if (!_upb_mapsorter_resize(s, sorted, count)) return false;
for (size_t i = 0; i < count; i++) {
s->entries[sorted->start + i] = &exts[i];
}
qsort(&s->entries[sor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rcx, %rsi
callq 0x2676d
movl %eax, %ebp
testb %al, %al
je 0x26837
xorl %eax, %eax
cmpq %rax, %rbx
je 0x2681b
movslq (%r15), %rcx
shlq $0x3, %rcx
addq (%r14), %rcx
movq %r12, (%rcx,%rax,8)
incq %r... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/map_sorter.c |
upb_mapsorter_cmpu64 | static void _upb_mapsorter_getkeys(const void* _a, const void* _b, void* a_key,
void* b_key, size_t size) {
const upb_tabent* const* a = _a;
const upb_tabent* const* b = _b;
upb_StringView a_tabkey = upb_tabstrview((*a)->key);
upb_StringView b_tabkey = upb_tabstrview((*b)->key... | movq (%rdi), %rax
movq (%rax), %rax
movq (%rsi), %rcx
movq (%rcx), %rcx
movq 0x4(%rax), %rax
xorl %edx, %edx
cmpq 0x4(%rcx), %rax
seta %dl
pushq $-0x1
popq %rax
cmovael %edx, %eax
retq
| /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/map_sorter.c |
upb_mapsorter_cmpbool | static void _upb_mapsorter_getkeys(const void* _a, const void* _b, void* a_key,
void* b_key, size_t size) {
const upb_tabent* const* a = _a;
const upb_tabent* const* b = _b;
upb_StringView a_tabkey = upb_tabstrview((*a)->key);
upb_StringView b_tabkey = upb_tabstrview((*b)->key... | movq (%rdi), %rax
movq (%rax), %rax
movq (%rsi), %rcx
movq (%rcx), %rcx
movb 0x4(%rax), %al
xorl %edx, %edx
cmpb 0x4(%rcx), %al
seta %dl
pushq $-0x1
popq %rax
cmovael %edx, %eax
retq
| /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/map_sorter.c |
upb_mapsorter_cmpstr | static void _upb_mapsorter_getkeys(const void* _a, const void* _b, void* a_key,
void* b_key, size_t size) {
const upb_tabent* const* a = _a;
const upb_tabent* const* b = _b;
upb_StringView a_tabkey = upb_tabstrview((*a)->key);
upb_StringView b_tabkey = upb_tabstrview((*b)->key... | pushq %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rsi), %rax
movq (%rax), %rsi
movl (%rsi), %ebx
addq $0x4, %rsi
movl (%rdi), %ebp
addq $0x4, %rdi
cmpl %ebx, %ebp
movl %ebx, %edx
cmovbl %ebp, %edx
callq 0x9140
testl %eax, %eax
je 0x26949
negl %eax
jmp 0x26956
xorl %ecx, %ecx
cmpl %ebx, %ebp
se... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/map_sorter.c |
upb_MiniTable_BuildWithBuf | upb_MiniTable* upb_MiniTable_BuildWithBuf(const char* data, size_t len,
upb_MiniTablePlatform platform,
upb_Arena* arena, void** buf,
size_t* buf_size,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r13
movl %edx, %r15d
movq %rsi, (%rsp)
movq %rdi, %r12
leaq 0x8(%rsp), %rbp
movl $0x100, %edx # imm = 0x100
movq %rbp, %rdi
xorl %esi, %esi
callq 0x91e0
movq ... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mini_descriptor/decode.c |
upb_Arena_Malloc | UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size) {
void* UPB_PRIVATE(_upb_Arena_SlowMalloc)(struct upb_Arena * a, size_t size);
size = UPB_ALIGN_MALLOC(size);
const size_t span = size + UPB_ASAN_GUARD_SIZE;
if (UPB_UNLIKELY(UPB_PRIVATE(_upb_ArenaHas)(a) < span)) {
return UPB_PRIVATE(... | addq $0x7, %rsi
andq $-0x8, %rsi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
cmpq %rsi, %rcx
jb 0x16225
leaq 0x7(%rax), %rcx
andq $-0x8, %rcx
cmpq %rax, %rcx
jne 0x26f42
addq %rax, %rsi
movq %rsi, (%rdi)
retq
pushq %rax
leaq 0x8115(%rip), %rdi # 0x2f05f
leaq 0x814b(%rip), %rsi # 0x2f09c
leaq 0x81c6... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mem/internal/arena.h |
upb_MtDecoder_BuildMiniTableWithBuf | static upb_MiniTable* upb_MtDecoder_BuildMiniTableWithBuf(
upb_MtDecoder* const decoder, const char* const data, const size_t len,
void** const buf, size_t* const buf_size) {
if (UPB_SETJMP(decoder->base.err) != 0) {
*buf = decoder->vec.data;
*buf_size = decoder->vec.capacity * sizeof(*decoder->vec.da... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x9510
testl %eax, %eax
je 0x26fa3
movq 0xf0(%rbx), %rax
movq %rax, (%r15)
imulq $0xc, 0x100(%rbx), %rax
movq %rax, (%r14)
xorl %eax, %eax
jm... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mini_descriptor/decode.c |
upb_MiniTableExtension_Build | upb_MiniTableExtension* _upb_MiniTableExtension_Build(
const char* data, size_t len, const upb_MiniTable* extendee,
upb_MiniTableSub sub, upb_MiniTablePlatform platform, upb_Arena* arena,
upb_Status* status) {
upb_MiniTableExtension* ext =
upb_Arena_Malloc(arena, sizeof(upb_MiniTableExtension));
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
pushq $0x20
popq %rsi
movq %r9, %rdi
callq 0x26f13
testq %rax, %rax
je 0x27523
movq %rax, %rbx
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r12, %... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mini_descriptor/decode.c |
upb_MiniTable_Build | upb_MiniTable* _upb_MiniTable_Build(const char* data, size_t len,
upb_MiniTablePlatform platform,
upb_Arena* arena, upb_Status* status) {
void* buf = NULL;
size_t size = 0;
upb_MiniTable* ret = upb_MiniTable_BuildWithBuf(data, len, platform, ... | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0x8(%rsp), %r9
andq $0x0, (%r9)
movq %r8, (%rsp)
movq %rbx, %r8
callq 0x26e6c
movq %rax, %r14
movq (%rbx), %rdi
callq 0x9410
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mini_descriptor/decode.c |
upb_MtDecoder_PushItem | static void upb_MtDecoder_PushItem(upb_MtDecoder* d, upb_LayoutItem item) {
if (d->vec.size == d->vec.capacity) {
size_t new_cap = UPB_MAX(8, d->vec.size * 2);
d->vec.data = realloc(d->vec.data, new_cap * sizeof(*d->vec.data));
upb_MdDecoder_CheckOutOfMemory(&d->base, d->vec.data);
d->vec.capacity = n... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0xf8(%rdi), %rax
cmpq 0x100(%rdi), %rax
jne 0x28069
addq %rax, %rax
cmpq $0x9, %rax
pushq $0x8
popq %r12
cmovaeq %rax, %r12
movq 0xf0(%r15), %rdi
imulq $0xc, %r12, %rsi
callq 0x95c0
movq %rax, 0xf0(%r15)
movq %r1... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mini_descriptor/decode.c |
upb_MtDataEncoder_PutBase92Varint | static char* upb_MtDataEncoder_PutBase92Varint(upb_MtDataEncoder* e, char* ptr,
uint32_t val, int min, int max) {
int shift = upb_Log2Ceiling(_upb_FromBase92(max) - _upb_FromBase92(min) + 1);
UPB_ASSERT(shift <= 6);
uint32_t mask = (1 << shift) - 1;
do {
uint32... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl $0xff, %r12d
andl %r12d, %r8d
movl %r8d, %edi
callq 0x28497
movsbl %al, %r13d
andl %r12d, %ebp
movl %ebp, %edi
callq 0x28497
movl %eax, %ebp
movsbl %al, %eax
subl %eax, %r13d... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mini_descriptor/internal/encode.c |
upb_MtDataEncoder_EncodeExtension | char* upb_MtDataEncoder_EncodeExtension(upb_MtDataEncoder* e, char* ptr,
upb_FieldType type, uint32_t field_num,
uint64_t field_mod) {
upb_MtDataEncoderInternal* in = upb_MtDataEncoder_GetInternal(e, ptr);
in->state.msg_state.msg_modifi... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %r15
movq %rsi, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
pushq $0x23
popq %rdx
callq 0x28207
testq %rax, %rax
je 0x281fa
movq %r15, %rdi
movq %rax, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %r... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mini_descriptor/internal/encode.c |
upb_MtDataEncoder_EncodeMap | char* upb_MtDataEncoder_EncodeMap(upb_MtDataEncoder* e, char* ptr,
upb_FieldType key_type,
upb_FieldType value_type, uint64_t key_mod,
uint64_t value_mod) {
upb_MtDataEncoderInternal* in = upb_MtDataEncoder_GetIntern... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r15
movl %ecx, %ebp
movl %edx, %r12d
movq %rdi, %r14
movq %rsi, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
pushq $0x25
popq %rdx
callq 0x28207
testq %rax, %rax
je 0x283e9
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rax, %rsi
movl... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mini_descriptor/internal/encode.c |
upb_Message_HasBaseField | UPB_API_INLINE bool upb_Message_HasBaseField(const struct upb_Message* msg,
const upb_MiniTableField* field) {
UPB_ASSERT(upb_MiniTableField_HasPresence(field));
UPB_ASSUME(!upb_MiniTableField_IsExtension(field));
if (upb_MiniTableField_IsInOneof(field)) {
return U... | pushq %rax
movb 0xb(%rsi), %al
testb $0x8, %al
jne 0x29083
movzwl 0x6(%rsi), %eax
testq %rax, %rax
je 0x290a8
testw %ax, %ax
js 0x29074
movl %eax, %ecx
shrl $0x3, %ecx
movzbl (%rdi,%rcx), %ecx
andl $0x7, %eax
btl %eax, %ecx
setb %al
jmp 0x29081
xorl $0xffff, %eax # imm = 0xFFFF
movl (%rdi,%rax), %eax
cmpl (%r... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/accessors.h |
upb_MiniTableField_DataIsZero_dont_copy_me__upb_internal_use_only | UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_DataIsZero)(
const upb_MiniTableField* f, const void* val) {
const char zero[16] = {0};
return UPB_PRIVATE(_upb_MiniTableField_DataEquals)(f, val, zero);
} | xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
movzbl 0xb(%rdi), %eax
shrl $0x6, %eax
leaq 0x10d9b(%rip), %rcx # 0x39e78
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x0, (%rsi)
jmp 0x29102
cmpq $0x0, 0x8(%rsi)
jmp 0x29102
movq (%rsi), %rax
cmpq -0x18(%rsp), %rax
jmp 0x29102
movl (%rsi), %eax
cmpl -0x1... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/accessors.h |
upb_Arena_Malloc | UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size) {
void* UPB_PRIVATE(_upb_Arena_SlowMalloc)(struct upb_Arena * a, size_t size);
size = UPB_ALIGN_MALLOC(size);
const size_t span = size + UPB_ASAN_GUARD_SIZE;
if (UPB_UNLIKELY(UPB_PRIVATE(_upb_ArenaHas)(a) < span)) {
return UPB_PRIVATE(... | addq $0x7, %rsi
andq $-0x8, %rsi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
cmpq %rsi, %rcx
jb 0x16225
leaq 0x7(%rax), %rcx
andq $-0x8, %rcx
cmpq %rax, %rcx
jne 0x295ff
addq %rax, %rsi
movq %rsi, (%rdi)
retq
pushq %rax
leaq 0x5a58(%rip), %rdi # 0x2f05f
leaq 0x5a8e(%rip), %rsi # 0x2f09c
leaq 0x5b09... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mem/internal/arena.h |
upb_Message_HasBaseField | UPB_API_INLINE bool upb_Message_HasBaseField(const struct upb_Message* msg,
const upb_MiniTableField* field) {
UPB_ASSERT(upb_MiniTableField_HasPresence(field));
UPB_ASSUME(!upb_MiniTableField_IsExtension(field));
if (upb_MiniTableField_IsInOneof(field)) {
return U... | pushq %rax
movb 0xb(%rsi), %al
testb $0x8, %al
jne 0x29656
movzwl 0x6(%rsi), %eax
testq %rax, %rax
je 0x2967b
testw %ax, %ax
js 0x29647
movl %eax, %ecx
shrl $0x3, %ecx
movzbl (%rdi,%rcx), %ecx
andl $0x7, %eax
btl %eax, %ecx
setb %al
jmp 0x29654
xorl $0xffff, %eax # imm = 0xFFFF
movl (%rdi,%rax), %eax
cmpl (%r... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/accessors.h |
upb_MiniTableField_DataIsZero_dont_copy_me__upb_internal_use_only | UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_DataIsZero)(
const upb_MiniTableField* f, const void* val) {
const char zero[16] = {0};
return UPB_PRIVATE(_upb_MiniTableField_DataEquals)(f, val, zero);
} | xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
movzbl 0xb(%rdi), %eax
shrl $0x6, %eax
leaq 0x10858(%rip), %rcx # 0x39f08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x0, (%rsi)
jmp 0x296d5
cmpq $0x0, 0x8(%rsi)
jmp 0x296d5
movq (%rsi), %rax
cmpq -0x18(%rsp), %rax
jmp 0x296d5
movl (%rsi), %eax
cmpl -0x1... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/accessors.h |
main | int main(int argc, char **argv) {
char **dir;
int curdir;
char c;
progname =*argv++;
if (! argv || ! *argv) usage();
switch ((c =**argv)) {
case 'e': c ='x';
case 'u': case 'd': case 'o': case 'x': case 'p': case 'c': case 'h':
case 'a': case 'i': case 't': case 'k': case 'q': case '1': case '2':
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, 0x3d21(%rip) # 0x60e0
cmpq $0x0, -0x10(%rbp)
je 0x23d0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
j... | /madscientist42[P]runit/src/runsvctrl.c |
allwrite | static int allwrite(int (*op)(),int fd,const char *buf,unsigned int len)
{
int w;
while (len) {
w = op(fd,buf,len);
if (w == -1) {
if (errno == error_intr) continue;
return -1; /* note that some data may have been written */
}
//TODO: probably meant as a return -1??? a break????
if (w ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x2861
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movb $0x0, %al
callq *%rcx
movl %eax, -0x28(%rbp)
cmpl $-0x... | /madscientist42[P]runit/src/lib/unix/buffer_put.c |
buffer_put | int buffer_put(buffer *s,const char *buf,unsigned int len)
{
unsigned int n;
n = s->n;
if (len > n - s->p) {
if (buffer_flush(s) == -1) return -1;
/* now s->p == 0 */
if (n < BUFFER_OUTSIZE) n = BUFFER_OUTSIZE;
while (len > s->n) {
if (n > len) n = len;
if (allwrite(s->op,s->fd,buf,n... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rdx
subl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jbe 0x2a10
movq -0x10(%rbp), %rdi
... | /madscientist42[P]runit/src/lib/unix/buffer_put.c |
main | int main()
{
BOOST_TEST((is_same<
extract_dimensions_t<int>, dimensions<>
>::value));
BOOST_TEST((is_same<
extract_dimensions_t<int[ ]>, dimensions<dyn>
>::value));
BOOST_TEST((is_same<
extract_dimensions_t<int[3]>, dimensions<3 >
>::value));
BOOST_TEST((is_same<
... | jmp 0x1281
| /brycelelbach[P]mdspan/tests/test_meta_extract_dimensions.cpp |
boost::report_errors() | inline report_errors_reminder& report_errors_remind()
{
static report_errors_reminder r;
return r;
} | pushq %rbp
pushq %rbx
pushq %rax
movb 0x2df6(%rip), %al # 0x4080
testb %al, %al
je 0x1360
movb $0x1, 0x2de1(%rip) # 0x407a
movb 0x2de1(%rip), %al # 0x4080
testb %al, %al
je 0x136a
movl 0x2ddb(%rip), %ebp # 0x4088
testl %ebp, %ebp
je 0x1313
movq 0x2d20(%rip), %rdi # 0x3fd8
movl %ebp, %esi
call... | /brycelelbach[P]mdspan/include/boost/core/lightweight_test.hpp |
DisasmReplayer::DisasmReplayer(Fossilize::VulkanDevice*) | DisasmReplayer(VulkanDevice *device_)
: device(device_)
{
if (device)
{
VkPipelineCacheCreateInfo info = { VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO };
vkCreatePipelineCache(device->get_device(), &info, nullptr, &pipeline_cache);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x372b1d(%rip), %rax # 0x39f548
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
addq $0x10, %rdi
leaq 0x160(%rbx), %r15
movl $0x120, %edx # imm = 0x120
xorl %esi, %esi
callq 0x29320
movq %r15, 0x130(%rbx)
p... | /ValveSoftware[P]Fossilize/cli/fossilize_disasm.cpp |
DisasmReplayer::~DisasmReplayer() | ~DisasmReplayer()
{
if (device)
{
if (pipeline_cache)
vkDestroyPipelineCache(device->get_device(), pipeline_cache, nullptr);
for (auto &sampler : samplers)
if (sampler)
vkDestroySampler(device->get_device(), sampler, nullptr);
for (auto &layout : layouts)
if (layout)
vkDestroyDescrip... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x372920(%rip), %rax # 0x39f548
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2cdf2
movq 0x228(%rbx), %rsi
testq %rsi, %rsi
je 0x2cc53
leaq 0x3bf4b5(%rip), %rcx # 0x3ec100
movq 0x18(%rax), %rdi
xorl %edx, %edx
callq *(%rcx)... | /ValveSoftware[P]Fossilize/cli/fossilize_disasm.cpp |
FilterReplayer::enqueue_create_compute_pipeline(unsigned long, VkComputePipelineCreateInfo const*, VkPipeline_T**) | bool enqueue_create_compute_pipeline(Hash hash, const VkComputePipelineCreateInfo *create_info, VkPipeline *pipeline) override
{
*pipeline = fake_handle<VkPipeline>(hash);
// We are active if we either explicitly add the pipeline, or we explicitly add one of the module dependencies.
bool active;
if (filter_co... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rsi, (%rcx)
leaq 0x40(%rdi), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2d8ce
testq %rax, %rax
jne 0x2d61b
leaq 0xb0(%r14), %rdi
movq 0x30(%r15), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
callq ... | /ValveSoftware[P]Fossilize/cli/fossilize_disasm.cpp |
FilterReplayer::enqueue_create_raytracing_pipeline(unsigned long, VkRayTracingPipelineCreateInfoKHR const*, VkPipeline_T**) | bool enqueue_create_raytracing_pipeline(Hash hash, const VkRayTracingPipelineCreateInfoKHR *create_info, VkPipeline *pipeline) override
{
*pipeline = fake_handle<VkPipeline>(hash);
// We are active if we either explicitly add the pipeline, or we explicitly add one of the module dependencies.
bool active;
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
movq %rsi, (%rcx)
leaq 0x78(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2d8ce
testq %rax, %rax
je 0x2d83b
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0x2d7a8
l... | /ValveSoftware[P]Fossilize/cli/fossilize_disasm.cpp |
DisasmReplayer::enqueue_create_descriptor_set_layout(unsigned long, VkDescriptorSetLayoutCreateInfo const*, VkDescriptorSetLayout_T**) | bool enqueue_create_descriptor_set_layout(Hash hash, const VkDescriptorSetLayoutCreateInfo *create_info, VkDescriptorSetLayout *layout) override
{
if (device)
{
LOGI("Creating descriptor set layout 0%" PRIX64 "\n", hash);
if (vkCreateDescriptorSetLayout(device->get_device(), create_info, nullptr, layout) != ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rbx
movq %r15, (%rsp)
cmpq $0x0, 0x8(%rdi)
jne 0x2e1d2
movq %rdx, (%r14)
leaq 0x180(%rbx), %rdi
movq %r14, %rsi
callq 0x2ec4e
addq $0x28, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2ec6c
movb $0x1, %al
a... | /ValveSoftware[P]Fossilize/cli/fossilize_disasm.cpp |
DisasmReplayer::enqueue_create_pipeline_layout(unsigned long, VkPipelineLayoutCreateInfo const*, VkPipelineLayout_T**) | bool enqueue_create_pipeline_layout(Hash hash, const VkPipelineLayoutCreateInfo *create_info, VkPipelineLayout *layout) override
{
if (device)
{
LOGI("Creating pipeline layout 0%" PRIX64 "\n", hash);
if (vkCreatePipelineLayout(device->get_device(), create_info, nullptr, layout) != VK_SUCCESS)
{
LOGE("... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rbx
movq %r15, (%rsp)
cmpq $0x0, 0x8(%rdi)
jne 0x2e2a6
movq %rdx, (%r14)
leaq 0x198(%rbx), %rdi
movq %r14, %rsi
callq 0x2ef3e
addq $0x40, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2ef5c
movb $0x1, %al
a... | /ValveSoftware[P]Fossilize/cli/fossilize_disasm.cpp |
DisasmReplayer::enqueue_create_shader_module(unsigned long, VkShaderModuleCreateInfo const*, VkShaderModule_T**) | bool enqueue_create_shader_module(Hash hash, const VkShaderModuleCreateInfo *create_info, VkShaderModule *module) override
{
if (!shader_module_is_active(hash))
{
*module = fake_handle<VkShaderModule>(hash);
return true;
}
if (device)
{
LOGI("Creating shader module 0%" PRIX64 "\n", hash);
if (vk... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
callq 0x2f22e
testb %al, %al
je 0x2e3b9
cmpq $0x0, 0x8(%rbx)
jne 0x2e3cc
movq %r12, (%r14)
leaq 0x1b0(%rbx), %r15
movq 0x1b8(%rbx), %r12
subq 0x1... | /ValveSoftware[P]Fossilize/cli/fossilize_disasm.cpp |
DisasmReplayer::enqueue_create_graphics_pipeline(unsigned long, VkGraphicsPipelineCreateInfo const*, VkPipeline_T**) | bool enqueue_create_graphics_pipeline(Hash hash, const VkGraphicsPipelineCreateInfo *create_info, VkPipeline *pipeline) override
{
if (!graphics_pipeline_is_active(hash))
{
*pipeline = fake_handle<VkPipeline>(hash);
return true;
}
if (device)
{
if (device->has_pipeline_stats())
const_cast<VkGra... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
callq 0x2fcba
testb %al, %al
je 0x2e783
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x2e796
movq %r12, (%r14)
leaq 0x1f8(%rbx), %rdi
movq %r14, %rs... | /ValveSoftware[P]Fossilize/cli/fossilize_disasm.cpp |
DisasmReplayer::enqueue_create_raytracing_pipeline(unsigned long, VkRayTracingPipelineCreateInfoKHR const*, VkPipeline_T**) | bool enqueue_create_raytracing_pipeline(Hash hash, const VkRayTracingPipelineCreateInfoKHR *create_info, VkPipeline *pipeline) override
{
if (!raytracing_pipeline_is_active(hash))
{
*pipeline = fake_handle<VkPipeline>(hash);
return true;
}
if (device)
{
if (device->has_pipeline_stats())
{
co... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
callq 0x2fe6c
testb %al, %al
je 0x2e8a6
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x2e8b9
movq %r12, (%r14)
leaq 0x210(%rbx), %rdi
movq %r14... | /ValveSoftware[P]Fossilize/cli/fossilize_disasm.cpp |
Fossilize::Hashing::compute_hash_physical_device_features(void const*) | static Hash compute_hash_physical_device_features(const void *device_pnext)
{
Hasher h;
// For hash invariance, make sure we hash PDF2 first, since when we serialize and unserialize,
// PDF2 will always come first in the chain.
auto *pdf2 = find_pnext<VkPhysicalDeviceFeatures2>(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movabsq $-0x509c42b379fe4821, %rbx # imm = 0xAF63BD4C8601B7DF
callq 0x40af7
testq %rax, %rax
je 0x31527
movl 0x10(%rax), %eax
xorq %rax, %rbx
movabsq $0x100000001b3, %r15 # imm = 0x100000001B3
pushq $0x10
popq %r12
pus... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::Hashing::hash_application_feature_info(Fossilize::Hasher&, Fossilize::StateRecorderApplicationFeatureHash const&) | static void hash_application_feature_info(Hasher &hasher, const StateRecorderApplicationFeatureHash &base_hash)
{
// This makes it so two different applications won't conflict if they use the same pipelines.
hasher.u64(base_hash.application_info_hash);
hasher.u64(base_hash.physical_device_features_hash);
} | movabsq $0x100000001b3, %rax # imm = 0x100000001B3
movq (%rdi), %rcx
imulq %rax, %rcx
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
movl %edx, %r8d
xorq %rcx, %r8
shrq $0x20, %rdx
imulq %rax, %r8
xorq %rdx, %r8
imulq %rax, %r8
movl %esi, %ecx
xorq %r8, %rcx
shrq $0x20, %rsi
imulq %rax, %rcx
xorq %rsi, %rcx
movq %rcx, (%rdi... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::Hashing::compute_hash_sampler(VkSamplerCreateInfo const&, unsigned long*) | bool compute_hash_sampler(const VkSamplerCreateInfo &sampler, Hash *out_hash)
{
Hasher h;
constexpr VkSamplerCreateFlagBits ignore_capture_replay_flags =
VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT;
h.u32(sampler.flags & ~ignore_capture_replay_flags);
h.f32(sampler.maxAnisotropy);
h.f32(sampler... | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %edx
andl $-0x9, %ecx
movabsq $-0x509c42b379fe4821, %rax # imm = 0xAF63BD4C8601B7DF
xorq %rcx, %rax
movl 0x34(%rdi), %esi
movabsq $0x100000001b3, %rcx # imm = 0x100000001B3
imulq %rcx, %rax
xorq %rsi, %rax
movl 0x2c(%rdi), %esi
imulq ... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::Hashing::hash_pnext_chain(Fossilize::StateRecorder const*, Fossilize::Hasher&, void const*, Fossilize::DynamicStateInfo const*, unsigned int) | static bool hash_pnext_chain(const StateRecorder *recorder, Hasher &h, const void *pNext,
const DynamicStateInfo *dynamic_state_info,
VkGraphicsPipelineLibraryFlagsEXT state_flags)
{
while ((pNext = pnext_chain_skip_ignored_entries(pNext)) != nullptr)
{
auto... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %r12d
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r13
movabsq $0x100000001b3, %rbp # imm = 0x100000001B3
movq %rdx, %rdi
callq 0x3d79d
movq %rax, %rbx
testq %rax, %rax
je 0x32392
movl (%rbx), %ecx
cmpq $0x10, %rcx
je 0x322f... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::Hashing::parse_dynamic_state_info(VkPipelineDynamicStateCreateInfo const&) | static DynamicStateInfo parse_dynamic_state_info(const VkPipelineDynamicStateCreateInfo &dynamic_info)
{
DynamicStateInfo info = {};
#define DYN_STATE(state, member) case VK_DYNAMIC_STATE_##state: info.member = true; break
for (uint32_t i = 0; i < dynamic_info.dynamicStateCount; i++)
{
switch (dynamic_info.pDynami... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x140, %rsp # imm = 0x140
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0xd8(%rsp)
leaq 0x20(%rdi), %rcx
movq %rcx, 0xd... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::get_hash_for_render_pass(VkRenderPass_T*, unsigned long*) const | bool StateRecorder::get_hash_for_render_pass(VkRenderPass render_pass, Hash *hash) const
{
if (render_pass == VK_NULL_HANDLE)
{
// Dynamic rendering.
*hash = 0;
return true;
}
auto itr = impl->render_pass_to_hash.find(render_pass);
if (itr == end(impl->render_pass_to_hash))
{
log_failed_hash("Render pass... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0x33cb5
movl $0x388, %eax # imm = 0x388
addq (%rdi), %rax
movq %rsp, %rsi
movq %rax, %rdi
callq 0x54b6a
testq %rax, %rax
je 0x33cc5
movq 0x10(%rax), %rax
movq %rax, (%rbx)
jmp 0x33cb9
andq $0x0, (%rbx)
movb $0x1, %bl
movl ... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::Hashing::compute_hash_stage(Fossilize::StateRecorder const&, Fossilize::Hasher&, VkPipelineShaderStageCreateInfo const&) | static bool compute_hash_stage(const StateRecorder &recorder, Hasher &h, const VkPipelineShaderStageCreateInfo &stage)
{
if (!stage.pName)
return false;
h.u32(stage.flags);
h.string(stage.pName);
h.u32(stage.stage);
Hash hash;
if (stage.module != VK_NULL_HANDLE)
{
if (!recorder.get_hash_for_shader_module(s... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x20(%rdx), %rsi
testq %rsi, %rsi
je 0x33d9e
movq %rdx, %r15
movq %rdi, %r14
movabsq $0x100000001b3, %r13 # imm = 0x100000001B3
movl 0x10(%rdx), %eax
movq (%rbx), %rcx
imulq %r13, %rcx
xorq %rax, %rcx
movq %rcx, (%rbx)
movq ... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::Hashing::compute_hash_compute_pipeline(Fossilize::StateRecorder const&, VkComputePipelineCreateInfo const&, unsigned long*) | bool compute_hash_compute_pipeline(const StateRecorder &recorder, const VkComputePipelineCreateInfo &create_info, Hash *out_hash)
{
// Ignore pipelines that cannot result in meaningful replay.
if (!create_info.stage.pName)
return false;
Hasher h;
Hash hash;
if (!recorder.get_hash_for_pipeline_layout(create_inf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x38(%rsi)
je 0x33f32
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x48(%rsi), %rsi
leaq 0x8(%rsp), %rdx
callq 0x33bde
testb %al, %al
je 0x33f32
movabsq $0x100000001b3, %r13 # imm = 0x100000001B3
movq 0x8(%rsp), %ra... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::get_hash_for_compute_pipeline_handle(VkPipeline_T*, unsigned long*) const | bool StateRecorder::get_hash_for_compute_pipeline_handle(VkPipeline pipeline, Hash *hash) const
{
auto itr = impl->compute_pipeline_to_hash.find(pipeline);
if (itr == end(impl->compute_pipeline_to_hash))
{
log_failed_hash("Compute pipeline", pipeline);
return false;
}
else
{
*hash = itr->second;
return tr... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
movl $0x318, %ecx # imm = 0x318
addq (%rdi), %rcx
movq %rcx, %rdi
movq %rax, %rsi
callq 0x548fe
movq %rax, %r14
testq %rax, %rax
je 0x3407d
movq 0x10(%r14), %rax
movq %rax, (%rbx)
jmp 0x3408d
movq (%rsp), %rsi
leaq 0x215036(%r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkShaderModuleCreateInfo const* Fossilize::find_pnext<VkShaderModuleCreateInfo>(VkStructureType, void const*) | static const T *find_pnext(VkStructureType sType, const void *pNext)
{
while (pNext)
{
auto *base_in = static_cast<const VkBaseInStructure *>(pNext);
if (base_in->sType == sType)
return static_cast<const T *>(pNext);
pNext = base_in->pNext;
}
return nullptr;
} | movq %rdi, %rax
testq %rax, %rax
je 0x3414a
cmpl $0x10, (%rax)
je 0x3414a
movq 0x8(%rax), %rax
jmp 0x3413a
retq
| /ValveSoftware[P]Fossilize/fossilize.cpp |
VkPipelineShaderStageModuleIdentifierCreateInfoEXT const* Fossilize::find_pnext<VkPipelineShaderStageModuleIdentifierCreateInfoEXT>(VkStructureType, void const*) | static const T *find_pnext(VkStructureType sType, const void *pNext)
{
while (pNext)
{
auto *base_in = static_cast<const VkBaseInStructure *>(pNext);
if (base_in->sType == sType)
return static_cast<const T *>(pNext);
pNext = base_in->pNext;
}
return nullptr;
} | movq %rdi, %rax
testq %rax, %rax
je 0x34161
cmpl $0x3ba1d6b2, (%rax) # imm = 0x3BA1D6B2
je 0x34161
movq 0x8(%rax), %rax
jmp 0x3414e
retq
| /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::Hashing::hash_specialization_info(Fossilize::Hasher&, VkSpecializationInfo const&) | static void hash_specialization_info(Hasher &h, const VkSpecializationInfo &spec)
{
h.data(static_cast<const uint8_t *>(spec.pData), spec.dataSize);
h.u64(spec.dataSize);
h.u32(spec.mapEntryCount);
for (uint32_t i = 0; i < spec.mapEntryCount; i++)
{
h.u32(spec.pMapEntries[i].offset);
h.u64(spec.pMapEntries[i].... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movabsq $0x100000001b3, %r15 # imm = 0x100000001B3
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rsi
callq 0x4e1da
movq 0x10(%r14), %rax
movq (%rbx), %rdx
imulq %r15, %rdx
movl %eax, %ecx
xorq %rdx, %rcx
shrq $0x20, %rax
imulq %r15, %rcx
xorq %rax, %rcx
movl... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::Hashing::compute_hash_render_pass(VkRenderPassCreateInfo const&, unsigned long*) | bool compute_hash_render_pass(const VkRenderPassCreateInfo &create_info, Hash *out_hash)
{
Hasher h;
// Conditionally branch to remain hash compatible.
if (create_info.flags != 0)
h.u32(create_info.flags);
h.u32(create_info.attachmentCount);
h.u32(create_info.dependencyCount);
h.u32(create_info.subpassCount);... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movabsq $0x100000001b3, %rax # imm = 0x100000001B3
movl 0x10(%rdi), %edx
movabsq $-0x509c42b379fe4821, %rsi # imm = 0xAF63BD4C8601B7DF
movq %rdx, %rcx
xorq %rsi, %rcx
imulq %rax, %rcx
testq %rdx, %rdx
cmoveq %rsi, %rcx
movl 0x14(... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_immutable_samplers(Fossilize::StateCreatorInterface&, Fossilize::DatabaseInterface*, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkSampler_T* const**) | bool StateReplayer::Impl::parse_immutable_samplers(StateCreatorInterface &iface, DatabaseInterface *resolver,
const Value &samplers, const VkSampler **out_sampler)
{
auto *samps = allocator.allocate_n<VkSampler>(samplers.Size());
auto *ret = samps;
for (auto itr = s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, 0x30(%rsp)
movq %rcx, %rbx
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %r14
movq %rcx, %rdi
callq 0x4add4
movl %eax, %esi
movq %r14, %rdi
callq 0x4adc0
movq %rax, %r15
movq %rbx, 0x48(%rsp)
movq %rbx, %rdi
callq 0x4ff70
mo... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse(Fossilize::StateCreatorInterface&, Fossilize::DatabaseInterface*, void const*, unsigned long) | bool StateReplayer::Impl::parse(StateCreatorInterface &iface, DatabaseInterface *resolver, const void *buffer_, size_t total_size)
{
// All data after a string terminating '\0' is considered binary payload
// which can be read for various purposes (SPIR-V varint for example).
const uint8_t *buffer = static_cast<cons... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %r12
movq %rcx, %rbp
movq %rdx, 0x68(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdi, %r13
addq %rcx, %r12
leaq 0x8(%rsp), %rdx
movb $0x0, (%rdx)
movq %rcx, %rdi
movq %r12, %rsi
callq 0x513fb
movq %rax, %r15
subq %rbp, %r15
leaq 0x1(%rax... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::~Impl() | StateRecorder::Impl::~Impl()
{
sync_thread();
} | pushq %rbx
movq %rdi, %rbx
callq 0x35392
leaq 0x578(%rbx), %rdi
callq 0x3115a
leaq 0x558(%rbx), %rdi
callq 0x4ae7e
leaq 0x508(%rbx), %rdi
callq 0x4e204
leaq 0x4d8(%rbx), %rdi
callq 0x29b20
leaq 0x430(%rbx), %rdi
callq 0x4e25c
leaq 0x3f8(%rbx), %rdi
callq 0x4e2e4
leaq 0x3c0(%rbx), %rdi
callq 0x4e382
leaq 0x388(%rbx), %r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_descriptor_set_bindings(Fossilize::StateCreatorInterface&, Fossilize::DatabaseInterface*, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkDescriptorSetLayoutBinding const**) | bool StateReplayer::Impl::parse_descriptor_set_bindings(StateCreatorInterface &iface, DatabaseInterface *resolver,
const Value &bindings,
const VkDescriptorSetLayoutBinding **out_bindings)
{
auto *set_bindin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r14
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
movq %rcx, %rdi
callq 0x4add4
movl %eax, %esi
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
callq 0x4ae8c
movq %rax, %rbp
movq %r14, %rdi
callq 0x4ff... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_push_constant_ranges(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPushConstantRange const**) | bool StateReplayer::Impl::parse_push_constant_ranges(const Value &ranges, const VkPushConstantRange **out_ranges)
{
auto *infos = allocator.allocate_n_cleared<VkPushConstantRange>(ranges.Size());
auto *ret = infos;
for (auto itr = ranges.Begin(); itr != ranges.End(); ++itr, infos++)
{
auto &obj = *itr;
infos->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4add4
movl %eax, %esi
movq %rbx, %rdi
callq 0x4aef0
movq %rax, %r15
movq %r14, %rdi
callq 0x4ff70
movq %rax, %r12
leaq 0x21286f(%rip), %r13 # 0x247f15
leaq ... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_set_layouts(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkDescriptorSetLayout_T* const**) | bool StateReplayer::Impl::parse_set_layouts(const Value &layouts, const VkDescriptorSetLayout **out_layout)
{
auto *infos = allocator.allocate_n_cleared<VkDescriptorSetLayout>(layouts.Size());
auto *ret = infos;
for (auto itr = layouts.Begin(); itr != layouts.End(); ++itr, infos++)
{
auto index = string_to_uint6... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x4add4
movl %eax, %esi
movq %r12, %rdi
callq 0x4af04
movq %rax, %r13
movq %r15, %rdi
callq 0x4ff70
movq %rax, %r14
addq $0x40, %r12
movq %rsp, %rbx
movq %r13, 0... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_shader_modules(Fossilize::StateCreatorInterface&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, unsigned char const*, unsigned long) | bool StateReplayer::Impl::parse_shader_modules(StateCreatorInterface &iface, const Value &modules,
const uint8_t *varint, size_t varint_size)
{
auto *infos = allocator.allocate_n_cleared<VkShaderModuleCreateInfo>(modules.MemberCount());
unsigned index = 0;
for (auto it... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %r12
movq %rsi, 0x18(%rsp)
movq %rdi, %r14
movq %rdx, %rdi
callq 0x4af2c
movl %eax, %esi
movq %r14, %rdi
callq 0x4af18
movq %rax, 0x40(%rsp)
movq %r12, %rdi
callq 0x4af56
movq %rax, %... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::ScratchAllocator::allocate_raw(unsigned long, unsigned long) | void *ScratchAllocator::allocate_raw(size_t size, size_t alignment)
{
if (impl->blocks.empty())
impl->add_block(size + alignment);
auto &block = impl->blocks.back();
size_t offset = (block.offset + alignment - 1) & ~(alignment - 1);
size_t required_size = offset + size;
if (required_size <= block.blob.size())
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq (%rdx,%rsi), %r12
leaq -0x1(%rdx), %r13
negq %rbx
movq (%r15), %rdi
movq 0x8(%rdi), %rcx
cmpq %rcx, (%rdi)
jne 0x35b02
movq %r12, %rsi
callq 0x3d8e6
movq (%r15), %rdi
movq 0x8(%rdi), %rcx
movq -0x20(%rcx), %rdx
a... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::decode_base64(Fossilize::ScratchAllocator&, char const*, unsigned long) | static uint8_t *decode_base64(ScratchAllocator &allocator, const char *data, size_t length)
{
auto *buf = static_cast<uint8_t *>(allocator.allocate_raw(length, 16));
auto *ptr = buf;
const auto base64_index = [](char c) -> uint32_t {
if (c >= 'A' && c <= 'Z')
return uint32_t(c - 'A');
else if (c >= 'a' && c ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rax
movq %rsi, %r14
pushq $0x10
popq %rdx
movq %rax, 0x8(%rsp)
movq %rax, %rsi
callq 0x35aca
xorl %ecx, %ecx
movq %rax, (%rsp)
movq %rax, %rdx
cmpq 0x8(%rsp), %rcx
jae 0x35d45
movb (%r14), %al
testb %al, %al
je 0x35d45
movb 0... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_viewports(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkViewport const**) | bool StateReplayer::Impl::parse_viewports(const Value &viewports, const VkViewport **out_viewports)
{
auto *vps = allocator.allocate_n_cleared<VkViewport>(viewports.Size());
auto *ret = vps;
for (auto itr = viewports.Begin(); itr != viewports.End(); ++itr, vps++)
{
auto &obj = *itr;
vps->x = obj["x"].GetFloat(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4add4
movl %eax, %esi
movq %rbx, %rdi
callq 0x4b2c0
movq %rax, %rbx
movq %r14, %rdi
callq 0x4ff70
movq %rax, %r12
leaq 0x215e5e(%rip), %r15 # 0x24fc98
leaq ... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_graphics_pipeline(Fossilize::StateCreatorInterface&, Fossilize::DatabaseInterface*, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjso... | bool StateReplayer::Impl::parse_graphics_pipeline(StateCreatorInterface &iface, DatabaseInterface *resolver, const Value &pipelines, const Value &member)
{
Hash hash = string_to_uint64(member.GetString());
if (replayed_graphics_pipelines.count(hash))
return true;
auto *info_allocated = allocator.allocate_cleared<... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq %r8, %rdi
callq 0x4adfe
movq %rax, %rdi
callq 0x34e3b
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x158(%r13), %r12
movq %r12, %rdi
callq 0x51032
movq %... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_raytracing_pipeline(Fossilize::StateCreatorInterface&, Fossilize::DatabaseInterface*, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidj... | bool StateReplayer::Impl::parse_raytracing_pipeline(StateCreatorInterface &iface, DatabaseInterface *resolver,
const Value &pipelines, const Value &member)
{
Hash hash = string_to_uint64(member.GetString());
if (replayed_raytracing_pipelines.count(hash))
return tr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rcx, 0x20(%rsp)
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
movq %r8, %rdi
callq 0x4adfe
movq %rax, %rdi
callq 0x34e3b
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x190(%r14), %r15
movq %r15, %rdi
callq 0x51032
... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_pipeline_library(Fossilize::StateCreatorInterface&, Fossilize::DatabaseInterface*, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson... | bool StateReplayer::Impl::parse_pipeline_library(
StateCreatorInterface &iface, DatabaseInterface *resolver,
const Value &pipelines,
const Value &lib_info, ResourceTag tag,
VkPipelineLibraryCreateInfoKHR **out_info)
{
auto &library_list = lib_info["libraries"];
auto *library_info = allocator.allocate_cleared<... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0xc(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20de20(%rip), %rsi # 0x248a50
movq %r8, 0x10(%rsp)
movq %r8, %rdi
callq 0x4b84c
movq %rax, %rbx
movq %r14, %rdi
callq 0x4b472
movq %rax,... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_graphics_pipelines(Fossilize::StateCreatorInterface&, Fossilize::DatabaseInterface*, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&) | bool StateReplayer::Impl::parse_graphics_pipelines(StateCreatorInterface &iface, DatabaseInterface *resolver, const Value &pipelines)
{
for (auto itr = pipelines.MemberBegin(); itr != pipelines.MemberEnd(); ++itr)
if (!parse_graphics_pipeline(iface, resolver, pipelines, itr->name))
return false;
iface.notify_rep... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq %rcx, %rdi
callq 0x4af56
movq %rax, %r13
movq %r14, %rdi
callq 0x4af8c
movq %rax, %rbp
cmpq %rax, %r13
je 0x3ad80
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_raytracing_pipelines(Fossilize::StateCreatorInterface&, Fossilize::DatabaseInterface*, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&) | bool StateReplayer::Impl::parse_raytracing_pipelines(StateCreatorInterface &iface, DatabaseInterface *resolver,
const Value &pipelines)
{
for (auto itr = pipelines.MemberBegin(); itr != pipelines.MemberEnd(); ++itr)
if (!parse_raytracing_pipeline(iface, resolver, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq %rcx, %rdi
callq 0x4af56
movq %rax, %r13
movq %r14, %rdi
callq 0x4af8c
movq %rax, %rbp
cmpq %rax, %r13
je 0x3adf4
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_vertex_input_divisor_state(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPipelineVertexInputDivisorStateCreateInfo**) | bool StateReplayer::Impl::parse_vertex_input_divisor_state(const Value &state, VkPipelineVertexInputDivisorStateCreateInfoKHR **out_info)
{
auto *info = allocator.allocate_cleared<VkPipelineVertexInputDivisorStateCreateInfoKHR>();
info->vertexBindingDivisorCount = state["vertexBindingDivisorCount"].GetUint();
if (st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %rbx
movq %rdi, %r15
callq 0x4b32e
movq %rax, %r14
leaq 0x20d858(%rip), %rsi # 0x2486cc
movq %rbx, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%r14)
leaq 0x20d857(%rip), %rsi # 0x2486e6
m... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_rasterization_depth_clip_state(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPipelineRasterizationDepthClipStateCreateInfoEXT**) | bool StateReplayer::Impl::parse_rasterization_depth_clip_state(const Value &state, VkPipelineRasterizationDepthClipStateCreateInfoEXT **out_info)
{
auto *info = allocator.allocate_cleared<VkPipelineRasterizationDepthClipStateCreateInfoEXT>();
info->flags = state["flags"].GetUint();
info->depthClipEnable = state["de... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x4b34e
movq %rax, %r15
leaq 0x24239e(%rip), %rsi # 0x27d2f2
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%r15)
leaq 0x20d78d(%rip), %rsi # 0x2486fc
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
mov... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_rasterization_stream_state(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPipelineRasterizationStateStreamCreateInfoEXT**) | bool StateReplayer::Impl::parse_rasterization_stream_state(const Value &state, VkPipelineRasterizationStateStreamCreateInfoEXT **out_info)
{
auto *info = allocator.allocate_cleared<VkPipelineRasterizationStateStreamCreateInfoEXT>();
info->flags = state["flags"].GetUint();
info->rasterizationStream = state["rasteriz... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x4b35a
movq %rax, %r15
leaq 0x24234a(%rip), %rsi # 0x27d2f2
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%r15)
leaq 0x20d749(%rip), %rsi # 0x24870c
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
mov... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_color_blend_advanced_state(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPipelineColorBlendAdvancedStateCreateInfoEXT**) | bool StateReplayer::Impl::parse_color_blend_advanced_state(const Value &state,
VkPipelineColorBlendAdvancedStateCreateInfoEXT **out_info)
{
auto *info = allocator.allocate_cleared<VkPipelineColorBlendAdvancedStateCreateInfoEXT>();
info->blendOverlap = static... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
callq 0x4b372
movq %rax, %r14
leaq 0x20d6b9(%rip), %rsi # 0x24872d
movq %r15, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x18(%r14)
leaq 0x20d6ab(%rip), %rsi # 0x24873a
movq %r15, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
mov... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_rasterization_conservative_state(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPipelineRasterizationConservativeStateCreateInfoEXT**) | bool StateReplayer::Impl::parse_rasterization_conservative_state(const Value &state,
VkPipelineRasterizationConservativeStateCreateInfoEXT **out_info)
{
auto *info = allocator.allocate_cleared<VkPipelineRasterizationConservativeStateCreateInfoEXT>();
i... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
callq 0x4b37e
movq %rax, %r14
leaq 0x24220e(%rip), %rsi # 0x27d2f2
movq %r15, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%r14)
leaq 0x20d65d(%rip), %rsi # 0x24875c
movq %r15, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
mov... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_attachment_description_stencil_layout(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkAttachmentDescriptionStencilLayout**) | bool StateReplayer::Impl::parse_attachment_description_stencil_layout(const Value &state,
VkAttachmentDescriptionStencilLayout **out_info)
{
auto *info = allocator.allocate_cleared<VkAttachmentDescriptionStencilLayout>();
*out_info = info;
info->... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x4b3a2
movq %rax, %r15
movq %rax, (%rbx)
leaq 0x20d5df(%rip), %rsi # 0x2487fe
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%r15)
leaq 0x20d5d9(%rip), %rsi # 0x248813
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.