name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
wabt::Result wabt::SharedValidator::CheckIndexWithValue<wabt::SharedValidator::ElemType>(wabt::Var, std::vector<wabt::SharedValidator::ElemType, std::allocator<wabt::SharedValidator::ElemType>> const&, wabt::SharedValidator::ElemType*, char const*) | Result SharedValidator::CheckIndexWithValue(Var var,
const std::vector<T>& values,
T* out,
const char* desc) {
Result result = CheckIndex(var, values.size(), desc);
if (out) {
*out = Succeeded(result) ? values[var.index()] : T{};
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r13
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rsi, 0x18(%rsp)
callq 0x3e72c
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x2, %rax
imull $0xcccccccd, %eax, %edx # imm = 0xCCCCCCCD
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x4e5a6
movl %eax, %ebp
movq %r15, %rdi
callq 0x3e814
testq %rbx, %rbx
je 0x521c2
testl %ebp, %ebp
je 0x5218f
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movl $0x0, 0x10(%rsp)
jmp 0x521b4
movq 0x18(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x521d3
movl 0x28(%rax), %eax
movq (%r14), %rcx
leaq (%rax,%rax,4), %rax
movl 0x10(%rcx,%rax,4), %edx
movl %edx, 0x10(%rsp)
movups (%rcx,%rax,4), %xmm0
movaps %xmm0, (%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x10(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5102(%rip), %rdi # 0x572dc
leaq 0x50a4(%rip), %rsi # 0x57285
leaq 0x50ff(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::TypeChecker::GetRethrowLabel(unsigned int, wabt::TypeChecker::Label**) | Result TypeChecker::GetRethrowLabel(Index depth, Label** out_label) {
if (Failed(GetLabel(depth, out_label))) {
return Result::Error;
}
if ((*out_label)->label_type == LabelType::Catch) {
return Result::Ok;
}
std::string candidates;
for (Index idx = 0; idx < label_stack_.size(); idx++) {
LabelType type = label_stack_[label_stack_.size() - idx - 1].label_type;
if (type == LabelType::Catch) {
if (!candidates.empty()) {
candidates.append(", ");
}
candidates.append(std::to_string(idx));
}
}
if (candidates.empty()) {
PrintError("rethrow not in try catch block");
} else {
PrintError("invalid rethrow depth: %" PRIindex " (catches: %s)", depth,
candidates.c_str());
}
*out_label = nullptr;
return Result::Error;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x5383e
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0x53a9b
movq (%rbx), %rcx
xorl %eax, %eax
cmpl $0x8, (%rcx)
je 0x53a9b
movl %ebp, 0xc(%rsp)
movq %rbx, 0x10(%rsp)
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x38(%r14), %rcx
movq 0x40(%r14), %rax
subq %rcx, %rax
je 0x53a39
xorl %edx, %edx
leaq 0x28(%rsp), %r15
leaq 0x38(%rsp), %r12
movl $0xd1b71759, %ebp # imm = 0xD1B71759
movabsq $-0x71c71c71c71c71c7, %rbx # imm = 0x8E38E38E38E38E39
xorl %r13d, %r13d
addq %rcx, %rax
notq %rdx
leaq (%rdx,%rdx,8), %rcx
cmpl $0x8, (%rax,%rcx,8)
jne 0x53a14
cmpq $0x0, 0x40(%rsp)
je 0x5397c
movq %r12, %rdi
leaq 0xa726(%rip), %rsi # 0x5e09d
callq 0x15430
movl $0x1, %eax
cmpl $0xa, %r13d
jb 0x539c7
movl $0x4, %eax
movl %r13d, %ecx
cmpl $0x63, %ecx
jbe 0x539c0
cmpl $0x3e7, %ecx # imm = 0x3E7
jbe 0x539c5
cmpl $0x2710, %ecx # imm = 0x2710
jb 0x539c7
movl %ecx, %edx
imulq %rbp, %rdx
shrq $0x2d, %rdx
addl $0x4, %eax
cmpl $0x1869f, %ecx # imm = 0x1869F
movl %edx, %ecx
ja 0x5398f
addl $-0x3, %eax
jmp 0x539c7
addl $-0x2, %eax
jmp 0x539c7
decl %eax
movl %eax, %esi
movq %r15, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
callq 0x152b0
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %esi
movl %r13d, %edx
callq 0x250b0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r12, %rdi
callq 0x150c0
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x53a14
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x15200
incl %r13d
movq 0x38(%r14), %rcx
movq 0x40(%r14), %rax
subq %rcx, %rax
movq %rax, %rsi
sarq $0x3, %rsi
imulq %rbx, %rsi
movq %r13, %rdx
cmpq %r13, %rsi
ja 0x53951
cmpq $0x0, 0x40(%rsp)
je 0x53a5d
movq 0x38(%rsp), %rcx
leaq 0x12440(%rip), %rsi # 0x65e8d
movq %r14, %rdi
movl 0xc(%rsp), %edx
xorl %eax, %eax
callq 0x53728
jmp 0x53a6e
leaq 0x1240a(%rip), %rsi # 0x65e6e
movq %r14, %rdi
xorl %eax, %eax
callq 0x53728
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x53a96
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x15200
movl $0x1, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::GetCatchCount(unsigned int, unsigned int*) | Result TypeChecker::GetCatchCount(Index depth, Index* out_count) {
Label* unused;
if (Failed(GetLabel(depth, &unused))) {
return Result::Error;
}
Index catch_count = 0;
for (Index idx = 0; idx <= depth; idx++) {
LabelType type = label_stack_[label_stack_.size() - idx - 1].label_type;
if (type == LabelType::Catch) {
catch_count++;
}
}
*out_count = catch_count;
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x8(%rsp), %rdx
callq 0x5383e
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0x53b0d
movq 0x40(%r15), %rax
leal 0x1(%r14), %ecx
cmpl $0x1, %ecx
adcl $0x1, %r14d
addq $-0x48, %rax
shlq $0x3, %r14
leaq (%r14,%r14,8), %rcx
xorl %edx, %edx
xorl %esi, %esi
xorl %edi, %edi
cmpl $0x8, (%rax,%rdx)
sete %dil
addl %edi, %esi
addq $-0x48, %rdx
movq %rcx, %rdi
addq %rdx, %rdi
jne 0x53af1
movl %esi, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::PeekAndCheckType(unsigned int, wabt::Type) | Result TypeChecker::PeekAndCheckType(Index depth, Type expected) {
Type actual = Type::Any;
Result result = PeekType(depth, &actual);
return result | CheckType(actual, expected);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsp, %r14
movq $0x0, (%r14)
movq %r14, %rdx
callq 0x53c14
movq (%r14), %rcx
testl %ebx, %ebx
setne %dl
testl %ecx, %ecx
setne %sil
andb %dl, %sil
cmpq %rbx, %rcx
setne %cl
andb %sil, %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::PushType(wabt::Type) | void TypeChecker::PushType(Type type) {
if (type != Type::Void) {
type_stack_.push_back(type);
}
} | pushq %rax
movq %rsi, (%rsp)
cmpl $-0x40, %esi
je 0x53d95
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
je 0x53d86
movq %rsi, (%rax)
addq $0x8, 0x28(%rdi)
jmp 0x53d95
addq $0x20, %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x564dc
popq %rax
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::CheckTypeStackEnd(char const*) | Result TypeChecker::CheckTypeStackEnd(const char* desc) {
Label* label;
CHECK_RESULT(TopLabel(&label));
Result result = (type_stack_.size() == label->type_stack_limit)
? Result::Ok
: Result::Error;
PrintStackIfFailedV(result, desc, {}, /*is_end=*/true);
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
xorl %esi, %esi
callq 0x5383e
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x53e2b
movq 0x28(%r14), %rax
subq 0x20(%r14), %rax
sarq $0x3, %rax
movq 0x8(%rsp), %rcx
xorl %ebp, %ebp
cmpq 0x38(%rcx), %rax
setne %bpl
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movl $0x1, %r8d
callq 0x53e36
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::CheckSignature(std::vector<wabt::Type, std::allocator<wabt::Type>> const&, char const*) | Result TypeChecker::CheckSignature(const TypeVector& sig, const char* desc) {
Result result = Result::Ok;
for (size_t i = 0; i < sig.size(); ++i) {
result |= PeekAndCheckType(sig.size() - i - 1, sig[i]);
}
PrintStackIfFailedV(result, desc, sig, /*is_end=*/false);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
subq %rax, %rsi
je 0x5418f
movq %rdx, 0x10(%rsp)
sarq $0x3, %rsi
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
xorl %r13d, %r13d
xorl %r14d, %r14d
addl %ebp, %esi
movq (%rax,%r13,8), %r12
movq $0x0, 0x8(%rsp)
movq %r15, %rdi
leaq 0x8(%rsp), %rdx
callq 0x53c14
movq 0x8(%rsp), %rcx
testl %r12d, %r12d
setne %dl
testl %ecx, %ecx
setne %sil
andb %dl, %sil
cmpq %r12, %rcx
setne %cl
andb %sil, %cl
cmpl $0x1, %eax
sete %al
orb %al, %r14b
orb %cl, %r14b
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
subq %rax, %rsi
sarq $0x3, %rsi
decl %ebp
cmpq %rsi, %r13
jb 0x54124
movzbl %r14b, %ebp
andl $0x1, %ebp
movq 0x10(%rsp), %rdx
jmp 0x54191
xorl %ebp, %ebp
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x53e36
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::CheckReturnSignature(std::vector<wabt::Type, std::allocator<wabt::Type>> const&, std::vector<wabt::Type, std::allocator<wabt::Type>> const&, char const*) | Result TypeChecker::CheckReturnSignature(const TypeVector& actual,
const TypeVector& expected,
const char* desc) {
Result result = CheckTypes(actual, expected);
if (Failed(result)) {
PrintError("return signatures have inconsistent types: expected %s, got %s",
TypesToString(expected).c_str(), TypesToString(actual).c_str());
}
return result;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
callq 0x54082
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x54248
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x54258
movq (%r13), %r12
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x54258
movq (%r13), %rcx
leaq 0x11cb0(%rip), %rsi # 0x65eb5
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x53728
movq (%r13), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5422d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x15200
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54248
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x15200
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::(anonymous namespace)::TypesToString[abi:cxx11](std::vector<wabt::Type, std::allocator<wabt::Type>> const&, char const*) | std::string TypesToString(const TypeVector& types,
const char* prefix = nullptr) {
std::string result = "[";
if (prefix) {
result += prefix;
}
for (size_t i = 0; i < types.size(); ++i) {
Type ty = types[i];
// NOTE: Reference (and GetName) is also used by (e.g.) objdump, which does
// not apply validation. do this here so as to not break that.
if (ty == Type::Reference && ty.GetReferenceIndex() == kInvalidIndex) {
result += "reference";
} else {
result += types[i].GetName();
}
if (i < types.size() - 1) {
result += ", ";
}
}
result += "]";
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0xfb5e(%rip), %rsi # 0x63ddb
leaq 0xfb58(%rip), %rdx # 0x63ddc
callq 0x16a80
testq %r15, %r15
je 0x54299
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15430
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x54358
xorl %ebp, %ebp
movabsq $-0x100000000, %r15 # imm = 0xFFFFFFFF00000000
leaq 0x8(%rsp), %r13
xorl %r12d, %r12d
movq (%rsi,%rbp), %rax
cmpl $-0x15, %eax
setne %cl
cmpq %r15, %rax
setb %al
orb %cl, %al
jne 0x542df
movq %rbx, %rdi
leaq 0x11eb3(%rip), %rsi # 0x6618b
callq 0x15430
jmp 0x54318
addq %rbp, %rsi
movq %r13, %rdi
callq 0x2df88
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x150c0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x54318
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x15200
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
decq %rax
cmpq %rax, %r12
jae 0x5433a
movq %rbx, %rdi
leaq 0x9d68(%rip), %rsi # 0x5e09d
callq 0x15430
incq %r12
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
addq $0x8, %rbp
cmpq %rax, %r12
jb 0x542ba
leaq 0x8272(%rip), %rsi # 0x5c5d1
movq %rbx, %rdi
callq 0x15430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::PopAndCheck2Types(wabt::Type, wabt::Type, char const*) | Result TypeChecker::PopAndCheck2Types(Type expected1,
Type expected2,
const char* desc) {
Result result = Result::Ok;
result |= PeekAndCheckType(0, expected2);
result |= PeekAndCheckType(1, expected1);
PrintStackIfFailed(result, desc, expected1, expected2);
result |= DropTypes(2);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
xorl %esi, %esi
movq %r13, %rdx
callq 0x53c14
movq (%r13), %rcx
testl %r14d, %r14d
setne %dl
testl %ecx, %ecx
setne %sil
andb %dl, %sil
cmpq %r14, %rcx
setne %bpl
andb %sil, %bpl
cmpl $0x1, %eax
sete %r15b
xorl %eax, %eax
movq %rax, (%r13)
leaq 0x10(%rsp), %r13
movq %rbx, %rdi
movl $0x1, %esi
movq %r13, %rdx
callq 0x53c14
movq (%r13), %rcx
testl %r12d, %r12d
setne %dl
testl %ecx, %ecx
setne %sil
andb %dl, %sil
cmpq %r12, %rcx
setne %cl
andb %sil, %cl
cmpl $0x1, %eax
sete %al
orb %r15b, %al
orb %bpl, %al
orb %cl, %al
movzbl %al, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq 0x8(%rsp), %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x55fc4
movl $0x2, %esi
movq %rbx, %rdi
callq 0x53ce8
cmpl $0x1, %eax
sete %al
orb %al, %bpl
movzbl %bpl, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::CheckOpcode3(wabt::Opcode, wabt::Limits const*, wabt::Limits const*, wabt::Limits const*) | Result TypeChecker::CheckOpcode3(Opcode opcode,
const Limits* limits1,
const Limits* limits2,
const Limits* limits3) {
Result result = PopAndCheck3Types(
GetMemoryParam(opcode.GetParamType1(), limits1),
GetMemoryParam(opcode.GetParamType2(), limits2),
GetMemoryParam(opcode.GetParamType3(), limits3), opcode.GetName());
PushType(opcode.GetResultType());
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %rbx
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x41380
testq %r12, %r12
je 0x5484c
leaq 0x1(%rbp), %r14
cmpb $0x0, 0x12(%r12)
cmovneq %rbp, %r14
jmp 0x54851
movq 0x28(%rsp), %r14
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x41380
testq %r13, %r13
je 0x54874
leaq 0x1(%rbp), %r12
cmpb $0x0, 0x12(%r13)
cmovneq %rbp, %r12
jmp 0x54879
movq 0x30(%rsp), %r12
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x41380
testq %r15, %r15
je 0x5489c
leaq 0x1(%rbp), %r13
cmpb $0x0, 0x12(%r15)
cmovneq %rbp, %r13
jmp 0x548a1
movq 0x38(%rsp), %r13
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x41380
movq (%r15), %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x54584
movl %eax, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x41380
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x53d68
movl %r14d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::BeginFunction(std::vector<wabt::Type, std::allocator<wabt::Type>> const&) | Result TypeChecker::BeginFunction(const TypeVector& sig) {
type_stack_.clear();
label_stack_.clear();
PushLabel(LabelType::Func, TypeVector(), sig);
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rax
cmpq %rax, 0x28(%rdi)
je 0x5491b
movq %rax, 0x28(%r14)
leaq 0x38(%r14), %r15
movq 0x38(%r14), %r12
movq 0x40(%r14), %rsi
cmpq %r12, %rsi
je 0x54938
movq %r12, %rdi
callq 0x47e3c
movq %r12, 0x40(%r14)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movq 0x28(%r14), %rax
subq 0x20(%r14), %rax
sarq $0x3, %rax
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
movq %r15, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x55ecc
movq (%r12), %rdi
testq %rdi, %rdi
je 0x54991
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnBr(unsigned int) | Result TypeChecker::OnBr(Index depth) {
Result result = Result::Ok;
Label* label;
CHECK_RESULT(GetLabel(depth, &label));
result |= CheckSignature(label->br_types(), "br");
CHECK_RESULT(SetUnreachable());
return result;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdx
callq 0x5383e
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0x54aa9
movq (%rsp), %rax
leaq 0x20(%rax), %rsi
leaq 0x8(%rax), %rcx
cmpl $0x3, (%rax)
cmoveq %rcx, %rsi
leaq 0xc442(%rip), %rdx # 0x60ec8
movq %rbx, %rdi
callq 0x540f0
cmpl $0x1, %eax
sete %bpl
movq %rbx, %rdi
callq 0x53b4e
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnReturnCall(std::vector<wabt::Type, std::allocator<wabt::Type>> const&, std::vector<wabt::Type, std::allocator<wabt::Type>> const&) | Result TypeChecker::OnReturnCall(const TypeVector& param_types,
const TypeVector& result_types) {
Result result = PopAndCheckSignature(param_types, "return_call");
Label* func_label;
CHECK_RESULT(GetThisFunctionLabel(&func_label));
result |= CheckReturnSignature(result_types, func_label->result_types,
"return_call");
CHECK_RESULT(SetUnreachable());
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0xc88e(%rip), %rdx # 0x61603
callq 0x5437a
movq 0x40(%rbx), %rcx
subq 0x38(%rbx), %rcx
movl %eax, %ebp
shrq $0x3, %rcx
imull $0x38e38e39, %ecx, %esi # imm = 0x38E38E39
decl %esi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5383e
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0x54de2
movq 0x8(%rsp), %rdx
addq $0x20, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x541b2
cmpl $0x1, %ebp
sete %bpl
cmpl $0x1, %eax
sete %r14b
movq %rbx, %rdi
callq 0x53b4e
cmpl $0x1, %eax
sete %al
orb %bpl, %al
orb %r14b, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnCatch(std::vector<wabt::Type, std::allocator<wabt::Type>> const&) | Result TypeChecker::OnCatch(const TypeVector& sig) {
Result result = Result::Ok;
Label* label;
CHECK_RESULT(TopLabel(&label));
result |= Check2LabelTypes(label, LabelType::Try, LabelType::Catch);
result |= PopAndCheckSignature(label->result_types, "try block");
result |= CheckTypeStackEnd("try block");
ResetTypeStackToLabel(label);
label->label_type = LabelType::Catch;
label->unreachable = false;
PushTypes(sig);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
xorl %esi, %esi
callq 0x5383e
movb $0x1, %bpl
cmpl $0x1, %eax
jne 0x54ee9
movzbl %bpl, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %r12
movl (%r12), %eax
addl $-0x6, %eax
testl $0xfffffffd, %eax # imm = 0xFFFFFFFD
setne 0xf(%rsp)
leaq 0x20(%r12), %rsi
leaq 0x2b5c(%rip), %r15 # 0x57a67
movq %rbx, %rdi
movq %r15, %rdx
callq 0x5437a
cmpl $0x1, %eax
sete %r13b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x53dc6
cmpl $0x1, %eax
sete %bpl
orb %r13b, %bpl
orb 0xf(%rsp), %bpl
leaq 0x20(%rbx), %rdi
movq 0x38(%r12), %rsi
callq 0x2d2f6
movl $0x8, (%r12)
movb $0x0, 0x40(%r12)
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x54ed6
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x53d68
addq $0x8, %r15
jmp 0x54f5a
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnElse() | Result TypeChecker::OnElse() {
Result result = Result::Ok;
Label* label;
CHECK_RESULT(TopLabel(&label));
result |= CheckLabelType(label, LabelType::If);
result |= PopAndCheckSignature(label->result_types, "`if true` branch");
result |= CheckTypeStackEnd("`if true` branch");
ResetTypeStackToLabel(label);
PushTypes(label->param_types);
label->label_type = LabelType::Else;
label->unreachable = false;
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdx
xorl %esi, %esi
callq 0x5383e
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0x5513c
movq (%rsp), %r15
cmpl $0x4, (%r15)
setne %r12b
leaq 0x20(%r15), %rsi
leaq 0x10f0e(%rip), %r14 # 0x65fe5
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5437a
cmpl $0x1, %eax
sete %r13b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53dc6
cmpl $0x1, %eax
sete %bpl
orb %r13b, %bpl
orb %r12b, %bpl
leaq 0x20(%rbx), %rdi
movq 0x38(%r15), %rsi
callq 0x2d2f6
movq 0x8(%r15), %r14
movq 0x10(%r15), %r12
cmpq %r12, %r14
je 0x5512c
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x53d68
addq $0x8, %r14
jmp 0x55116
movzbl %bpl, %eax
movl $0x5, (%r15)
movb $0x0, 0x40(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnEnd(wabt::TypeChecker::Label*, char const*, char const*) | Result TypeChecker::OnEnd(Label* label,
const char* sig_desc,
const char* end_desc) {
Result result = Result::Ok;
result |= PopAndCheckSignature(label->result_types, sig_desc);
result |= CheckTypeStackEnd(end_desc);
ResetTypeStackToLabel(label);
PushTypes(label->result_types);
PopLabel();
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x20, %rsi
callq 0x5437a
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53dc6
movl %eax, %r14d
leaq 0x20(%rbx), %rdi
movq 0x38(%r15), %rsi
callq 0x2d2f6
movq 0x20(%r15), %r12
movq 0x28(%r15), %r15
cmpq %r15, %r12
je 0x551a2
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x53d68
addq $0x8, %r12
jmp 0x5518b
cmpl $0x1, %ebp
sete %al
cmpl $0x1, %r14d
sete %cl
orb %al, %cl
movzbl %cl, %ebp
leaq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
addq $-0x48, %rsi
movq %rsi, 0x40(%rbx)
callq 0x564aa
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnEnd() | Result TypeChecker::OnEnd() {
Result result = Result::Ok;
static const char* s_label_type_name[] = {
"function", "initializer expression", "block", "loop",
"if", "`if false` branch", "try", "try table",
"try catch"};
WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(s_label_type_name) == kLabelTypeCount);
Label* label;
CHECK_RESULT(TopLabel(&label));
assert(static_cast<int>(label->label_type) < kLabelTypeCount);
if (label->label_type == LabelType::If) {
// An if without an else will just pass the params through, so the result
// types must be the same as the param types. It has the same behavior as
// an empty else block.
CHECK_RESULT(OnElse());
}
const char* desc = s_label_type_name[static_cast<int>(label->label_type)];
result |= OnEnd(label, desc, desc);
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
xorl %esi, %esi
callq 0x5383e
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x55239
movq 0x8(%rsp), %r14
movl (%r14), %eax
cmpl $0x9, %eax
jge 0x55244
cmpl $0x4, %eax
jne 0x55214
movq %rbx, %rdi
callq 0x5509c
cmpl $0x1, %eax
je 0x55239
movslq (%r14), %rax
leaq 0x2eb32(%rip), %rcx # 0x83d50
movq (%rcx,%rax,8), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rcx, %rdx
callq 0x5514c
xorl %ebp, %ebp
cmpl $0x1, %eax
sete %bpl
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10de8(%rip), %rdi # 0x66033
leaq 0x10b73(%rip), %rsi # 0x65dc5
leaq 0x10e10(%rip), %rcx # 0x66069
movl $0x287, %edx # imm = 0x287
callq 0x15160
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnLoop(std::vector<wabt::Type, std::allocator<wabt::Type>> const&, std::vector<wabt::Type, std::allocator<wabt::Type>> const&) | Result TypeChecker::OnLoop(const TypeVector& param_types,
const TypeVector& result_types) {
Result result = PopAndCheckSignature(param_types, "loop");
PushLabel(LabelType::Loop, param_types, result_types);
PushTypes(param_types);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xbb1e(%rip), %rdx # 0x60ea8
callq 0x5437a
movl %eax, %ebp
leaq 0xc(%rsp), %rsi
movl $0x3, (%rsi)
movq 0x28(%rbx), %rax
subq 0x20(%rbx), %rax
leaq 0x38(%rbx), %rdi
sarq $0x3, %rax
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
movq %r14, %rdx
movq %r15, %rcx
callq 0x55ecc
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x553dc
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x53d68
addq $0x8, %r15
jmp 0x553c6
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnMemoryCopy(wabt::Limits const&, wabt::Limits const&) | Result TypeChecker::OnMemoryCopy(const Limits& dst_limits,
const Limits& src_limits) {
Limits size_limits = src_limits;
// The memory64 proposal specifies that the type of the size argument should
// be the mimimum of the two memory types.
if (src_limits.is_64 && !dst_limits.is_64) {
size_limits = dst_limits;
}
return CheckOpcode3(Opcode::MemoryCopy, &dst_limits, &src_limits,
&size_limits);
} | subq $0x18, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movups (%rcx), %xmm0
movaps %xmm0, (%rsp)
cmpb $0x1, 0x12(%rcx)
jne 0x5541e
cmpb $0x0, 0x12(%rdx)
jne 0x5541e
movl 0xf(%rdx), %eax
movl %eax, 0xf(%rsp)
movups (%rdx), %xmm0
movaps %xmm0, (%rsp)
movq %rsp, %r8
movl $0xd1, %esi
callq 0x54804
addq $0x18, %rsp
retq
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnTableCopy(wabt::Limits const&, wabt::Limits const&) | Result TypeChecker::OnTableCopy(const Limits& dst_limits,
const Limits& src_limits) {
Limits size_limits = src_limits;
// The memory64 proposal specifies that the type of the size argument should
// be the mimimum of the two table types.
if (src_limits.is_64 && !dst_limits.is_64) {
size_limits = dst_limits;
}
return CheckOpcode3(Opcode::TableCopy, &dst_limits, &src_limits,
&size_limits);
} | subq $0x18, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movups (%rcx), %xmm0
movaps %xmm0, (%rsp)
cmpb $0x1, 0x12(%rcx)
jne 0x554f8
cmpb $0x0, 0x12(%rdx)
jne 0x554f8
movl 0xf(%rdx), %eax
movl %eax, 0xf(%rsp)
movups (%rdx), %xmm0
movaps %xmm0, (%rsp)
movq %rsp, %r8
movl $0xd5, %esi
callq 0x54804
addq $0x18, %rsp
retq
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnRefFuncExpr(unsigned int, bool) | Result TypeChecker::OnRefFuncExpr(Index func_type, bool force_generic_funcref) {
/*
* In a const expression, treat ref.func as producing a generic funcref.
* This avoids having to implement funcref subtyping (for now) and matches
* the previous behavior where SharedValidator::OnElemSegmentElemExpr_RefFunc
* examined only the validity of the function index.
*/
if (features_.function_references_enabled() && !force_generic_funcref) {
PushType(Type(Type::Reference, func_type));
} else {
PushType(Type::FuncRef);
}
return Result::Ok;
} | pushq %rax
shlq $0x20, %rsi
movl $0xffffffeb, %eax # imm = 0xFFFFFFEB
orq %rax, %rsi
addq $0x5, %rax
testl %edx, %edx
cmovneq %rax, %rsi
cmpb $0x0, 0x5e(%rdi)
cmoveq %rax, %rsi
callq 0x53d68
xorl %eax, %eax
popq %rcx
retq
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnRefIsNullExpr() | Result TypeChecker::OnRefIsNullExpr() {
Type type;
Result result = PeekType(0, &type);
if (!type.IsRef()) {
type = Type(Type::Reference, kInvalidIndex);
}
result |= PopAndCheck1Type(type, "ref.is_null");
PushType(Type::I32);
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
xorl %esi, %esi
movq %r14, %rdx
callq 0x53c14
movl %eax, %ebp
movl (%r14), %eax
addl $0x17, %eax
cmpl $0x7, %eax
ja 0x5569e
movl $0xc5, %ecx
btl %eax, %ecx
jae 0x5569e
movq 0x8(%rsp), %rsi
leaq 0xc0f4(%rip), %rdx # 0x61761
movq %rbx, %rdi
callq 0x5441e
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %ebp
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x53d68
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq $-0x15, 0x8(%rsp)
jmp 0x55661
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnReturn() | Result TypeChecker::OnReturn() {
Result result = Result::Ok;
Label* func_label;
CHECK_RESULT(GetThisFunctionLabel(&func_label));
result |= PopAndCheckSignature(func_label->result_types, "return");
CHECK_RESULT(SetUnreachable());
return result;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
subq 0x38(%rdi), %rax
shrq $0x3, %rax
imull $0x38e38e39, %eax, %esi # imm = 0x38E38E39
decl %esi
movq %rsp, %rdx
callq 0x5383e
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0x557ae
movq (%rsp), %rsi
addq $0x20, %rsi
leaq 0x109e2(%rip), %rdx # 0x6616d
movq %rbx, %rdi
callq 0x5437a
cmpl $0x1, %eax
sete %bpl
movq %rbx, %rdi
callq 0x53b4e
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnSelect(std::vector<wabt::Type, std::allocator<wabt::Type>> const&) | Result TypeChecker::OnSelect(const TypeVector& expected) {
Result result = Result::Ok;
Type type1 = Type::Any;
Type type2 = Type::Any;
Type result_type = Type::Any;
result |= PeekAndCheckType(0, Type::I32);
result |= PeekType(1, &type1);
result |= PeekType(2, &type2);
if (expected.empty()) {
if (type1.IsRef() || type2.IsRef()) {
result = Result::Error;
} else {
result |= CheckType(type1, type2);
result_type = type1;
}
} else {
assert(expected.size() == 1);
result |= CheckType(type1, expected[0]);
result |= CheckType(type2, expected[0]);
}
PrintStackIfFailed(result, "select", result_type, result_type, Type::I32);
result |= DropTypes(3);
PushType(result_type);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rsp, %r15
movq %rax, (%r15)
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
xorl %esi, %esi
movq %r13, %rdx
callq 0x53c14
movq (%r13), %rcx
testl %ecx, %ecx
setne %dl
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
cmpq %rsi, %rcx
setne %bpl
andb %dl, %bpl
cmpl $0x1, %eax
sete %r13b
movq %rbx, %rdi
movl $0x1, %esi
movq %r12, %rdx
callq 0x53c14
cmpl $0x1, %eax
sete %r12b
orb %r13b, %r12b
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x53c14
cmpl $0x1, %eax
sete %al
orb %r12b, %al
orb %bpl, %al
movq (%r14), %rcx
movq 0x8(%r14), %rdx
cmpq %rdx, %rcx
je 0x55898
subq %rcx, %rdx
cmpq $0x8, %rdx
jne 0x55967
movq 0x8(%rsp), %rdx
movq (%rcx), %rcx
testl %ecx, %ecx
setne %sil
testl %edx, %edx
setne %dil
andb %sil, %dil
cmpq %rcx, %rdx
setne %dl
andb %dil, %dl
orb %dl, %al
movq (%rsp), %rdx
testl %edx, %edx
setne %dil
andb %sil, %dil
cmpq %rcx, %rdx
setne %cl
andb %dil, %cl
orb %al, %cl
jmp 0x558b0
movb $0x1, %cl
movl 0x8(%rsp), %edx
addl $0x17, %edx
cmpl $0x7, %edx
ja 0x55914
movl $0xc5, %esi
btl %edx, %esi
jae 0x55914
xorl %r14d, %r14d
xorl %edx, %edx
orq %rdx, %r14
movzbl %cl, %ebp
movl %ebp, %esi
andl $0x1, %esi
leaq 0xcd8a(%rip), %rdx # 0x62651
movq %rbx, %rdi
movq %r14, %rcx
movq %r14, %r8
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
callq 0x5619c
movl $0x3, %esi
movq %rbx, %rdi
callq 0x53ce8
cmpl $0x1, %eax
sete %al
orb %al, %bpl
movzbl %bpl, %ebp
andl $0x1, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53d68
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%rsp), %edx
addl $0x17, %edx
cmpl $0x7, %edx
ja 0x55929
movl $0xc5, %esi
btl %edx, %esi
jb 0x558b0
movq 0x8(%rsp), %rcx
movq (%rsp), %rdx
testl %edx, %edx
setne %sil
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
andq %rcx, %r14
setne %dil
andb %sil, %dil
cmpq %rdx, %rcx
setne %dl
andb %dil, %dl
orb %dl, %al
movabsq $-0x100000000, %rdx # imm = 0xFFFFFFFF00000000
andq %rcx, %rdx
movl %eax, %ecx
jmp 0x558b5
leaq 0x1071d(%rip), %rdi # 0x6608b
leaq 0x10450(%rip), %rsi # 0x65dc5
leaq 0x10724(%rip), %rcx # 0x660a0
movl $0x362, %edx # imm = 0x362
callq 0x15160
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnTry(std::vector<wabt::Type, std::allocator<wabt::Type>> const&, std::vector<wabt::Type, std::allocator<wabt::Type>> const&) | Result TypeChecker::OnTry(const TypeVector& param_types,
const TypeVector& result_types) {
Result result = PopAndCheckSignature(param_types, "try");
PushLabel(LabelType::Try, param_types, result_types);
PushTypes(param_types);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb50c(%rip), %rdx # 0x60eb2
callq 0x5437a
movl %eax, %ebp
leaq 0xc(%rsp), %rsi
movl $0x6, (%rsi)
movq 0x28(%rbx), %rax
subq 0x20(%rbx), %rax
leaq 0x38(%rbx), %rdi
sarq $0x3, %rax
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
movq %r14, %rdx
movq %r15, %rcx
callq 0x55ecc
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x559f8
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x53d68
addq $0x8, %r15
jmp 0x559e2
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnSimdLaneOp(wabt::Opcode, unsigned long) | Result TypeChecker::OnSimdLaneOp(Opcode opcode, uint64_t lane_idx) {
Result result = Result::Ok;
uint32_t lane_count = opcode.GetSimdLaneCount();
if (lane_idx >= lane_count) {
PrintError("lane index must be less than %d (got %" PRIu64 ")", lane_count,
lane_idx);
result = Result::Error;
}
switch (opcode) {
case Opcode::I8X16ExtractLaneS:
case Opcode::I8X16ExtractLaneU:
case Opcode::I16X8ExtractLaneS:
case Opcode::I16X8ExtractLaneU:
case Opcode::I32X4ExtractLane:
case Opcode::F32X4ExtractLane:
case Opcode::I64X2ExtractLane:
case Opcode::F64X2ExtractLane:
result |= CheckOpcode1(opcode);
break;
case Opcode::I8X16ReplaceLane:
case Opcode::I16X8ReplaceLane:
case Opcode::I32X4ReplaceLane:
case Opcode::F32X4ReplaceLane:
case Opcode::I64X2ReplaceLane:
case Opcode::F64X2ReplaceLane:
result |= CheckOpcode2(opcode);
break;
default:
WABT_UNREACHABLE;
}
return result;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r15
leaq 0xc(%rsp), %rdi
movl %esi, (%rdi)
callq 0x41486
movl %eax, %r14d
cmpq %rbx, %r14
ja 0x55ba2
leaq 0x1057f(%rip), %rsi # 0x66111
movq %r15, %rdi
movl %r14d, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x53728
movl 0xc(%rsp), %esi
leal -0xf3(%rsi), %eax
cmpl $0xd, %eax
ja 0x55be7
movl $0x155b, %ecx # imm = 0x155B
movq %r15, %rdi
xorl %edx, %edx
btl %eax, %ecx
jae 0x55bc7
callq 0x546c0
jmp 0x55bcc
callq 0x54754
cmpq %rbx, %r14
setbe %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x15150
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnSimdLoadLane(wabt::Opcode, wabt::Limits const&, unsigned long) | Result TypeChecker::OnSimdLoadLane(Opcode opcode,
const Limits& limits,
uint64_t lane_idx) {
Result result = Result::Ok;
uint32_t lane_count = opcode.GetSimdLaneCount();
if (lane_idx >= lane_count) {
PrintError("lane index must be less than %d (got %" PRIu64 ")", lane_count,
lane_idx);
result = Result::Error;
}
result |= CheckOpcode2(opcode, &limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rdi
movl %esi, (%rdi)
callq 0x41486
movl %eax, %r12d
cmpq %r15, %r12
ja 0x55c2c
leaq 0x104f5(%rip), %rsi # 0x66111
movq %r14, %rdi
movl %r12d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x53728
cmpq %r15, %r12
setbe %bpl
movl 0xc(%rsp), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x54754
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnSimdStoreLane(wabt::Opcode, wabt::Limits const&, unsigned long) | Result TypeChecker::OnSimdStoreLane(Opcode opcode,
const Limits& limits,
uint64_t lane_idx) {
Result result = Result::Ok;
uint32_t lane_count = opcode.GetSimdLaneCount();
if (lane_idx >= lane_count) {
PrintError("lane index must be less than %d (got %" PRIu64 ")", lane_count,
lane_idx);
result = Result::Error;
}
result |= CheckOpcode2(opcode, &limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rdi
movl %esi, (%rdi)
callq 0x41486
movl %eax, %r12d
cmpq %r15, %r12
ja 0x55c9c
leaq 0x10485(%rip), %rsi # 0x66111
movq %r14, %rdi
movl %r12d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x53728
cmpq %r15, %r12
setbe %bpl
movl 0xc(%rsp), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x54754
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnSimdShuffleOp(wabt::Opcode, v128) | Result TypeChecker::OnSimdShuffleOp(Opcode opcode, v128 lane_idx) {
Result result = Result::Ok;
uint8_t simd_data[16];
memcpy(simd_data, &lane_idx, 16);
for (int i = 0; i < 16; i++) {
if (simd_data[i] >= 32) {
PrintError("lane index must be less than 32 (got %d)", simd_data[i]);
result = Result::Error;
}
}
result |= CheckOpcode2(opcode);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdx, (%rsp)
movq %rcx, 0x8(%rsp)
leaq 0x1044e(%rip), %r15 # 0x6613b
xorl %r12d, %r12d
xorl %ebp, %ebp
movzbl (%rsp,%r12), %edx
cmpl $0x20, %edx
jb 0x55d0e
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x53728
movl $0x1, %ebp
incq %r12
cmpq $0x10, %r12
jne 0x55cf2
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x54754
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/type-checker.cc |
wabt::TypeChecker::EndInitExpr() | Result TypeChecker::EndInitExpr() {
Result result = Result::Ok;
Label* label;
CHECK_RESULT(TopLabel(&label));
result |= CheckLabelType(label, LabelType::InitExpr);
result |= OnEnd(label, "initializer expression", "initializer expression");
return result;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdx
xorl %esi, %esi
callq 0x5383e
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0x55ec5
movq (%rsp), %rsi
cmpl $0x1, (%rsi)
setne %bpl
leaq 0x10148(%rip), %rcx # 0x65ff6
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x5514c
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /WebAssembly[P]wabt/src/type-checker.cc |
void wabt::TypeChecker::PrintStackIfFailed<wabt::Type>(wabt::Result, char const*, wabt::Type) | inline bool Failed(Result result) {
return result == Result::Error;
} | cmpl $0x1, %esi
jne 0x55fc3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movl $0x8, %edi
callq 0x151f0
movq %rax, %r13
movq %rax, (%r12)
addq $0x8, %rax
movq %rax, 0x10(%r12)
movq %r15, (%r13)
movq %rax, 0x8(%r12)
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x53e36
movl $0x8, %esi
movq %r13, %rdi
callq 0x15200
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/include/wabt/result.h |
void wabt::TypeChecker::PrintStackIfFailed<wabt::Type, wabt::Type, wabt::Type>(wabt::Result, char const*, wabt::Type, wabt::Type, wabt::Type) | inline bool Failed(Result result) {
return result == Result::Error;
} | cmpl $0x1, %esi
jne 0x560ef
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r12
movq %rcx, %r13
movl %esi, %ebp
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movl $0x18, %edi
movq %rdx, 0x8(%rsp)
movq %r9, (%rsp)
callq 0x151f0
movq %rax, %r14
movq %rax, (%rbx)
addq $0x18, %rax
movq %rax, 0x10(%rbx)
movq %r13, (%r14)
movq %r12, 0x8(%r14)
movq (%rsp), %rcx
movq %rcx, 0x10(%r14)
movq %rax, 0x8(%rbx)
movq %r15, %rdi
movl %ebp, %esi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x53e36
movl $0x18, %esi
movq %r14, %rdi
callq 0x15200
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/include/wabt/result.h |
void wabt::TypeChecker::PrintStackIfFailed<wabt::Type::Enum>(wabt::Result, char const*, wabt::Type::Enum) | explicit TypeChecker(const Features& features) : features_(features) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x1, %esi
jne 0x5616d
movl %ecx, %r15d
cmpl $-0x15, %ecx
je 0x5617c
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movl $0x8, %edi
callq 0x151f0
movq %rax, %r13
movq %rax, (%r12)
addq $0x8, %rax
movq %rax, 0x10(%r12)
movl %r15d, %ecx
movq %rcx, (%r13)
movq %rax, 0x8(%r12)
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x53e36
movl $0x8, %esi
movq %r13, %rdi
callq 0x15200
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd68c(%rip), %rdi # 0x6380f
leaq 0x14bd(%rip), %rsi # 0x57647
leaq 0xffe3(%rip), %rcx # 0x66174
movl $0x43, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/include/wabt/type-checker.h |
void wabt::TypeChecker::PrintStackIfFailed<wabt::Type, wabt::Type, wabt::Type::Enum>(wabt::Result, char const*, wabt::Type, wabt::Type, wabt::Type::Enum) | explicit TypeChecker(const Features& features) : features_(features) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %esi
jne 0x5622e
movl %r9d, %r14d
movq %rdi, (%rsp)
movq %rdx, 0x8(%rsp)
cmpl $-0x15, %r9d
je 0x5623d
movq %r8, %r12
movq %rcx, %r13
movl %esi, %ebp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movl $0x18, %edi
callq 0x151f0
movq %rax, %r15
movq %rax, (%rbx)
addq $0x18, %rax
movq %rax, 0x10(%rbx)
movq %r13, (%r15)
movq %r12, 0x8(%r15)
movl %r14d, 0x10(%r15)
movl $0x0, 0x14(%r15)
movq %rax, 0x8(%rbx)
movq (%rsp), %rdi
movl %ebp, %esi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x53e36
movl $0x18, %esi
movq %r15, %rdi
callq 0x15200
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd5cb(%rip), %rdi # 0x6380f
leaq 0x13fc(%rip), %rsi # 0x57647
leaq 0xff22(%rip), %rcx # 0x66174
movl $0x43, %edx
callq 0x15160
| /WebAssembly[P]wabt/include/wabt/type-checker.h |
nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::json_value::json_value(nlohmann::json_abi_v3_11_2::detail::value_t) | json_value(value_t t)
{
switch (t)
{
case value_t::object:
{
object = create<object_t>();
break;
}
case value_t::array:
{
array = create<array_t>();
break;
}
case value_t::string:
{
string = create<string_t>("");
break;
}
case value_t::binary:
{
binary = create<binary_t>();
break;
}
case value_t::boolean:
{
boolean = static_cast<boolean_t>(false);
break;
}
case value_t::number_integer:
{
number_integer = static_cast<number_integer_t>(0);
break;
}
case value_t::number_unsigned:
{
number_unsigned = static_cast<number_unsigned_t>(0);
break;
}
case value_t::number_float:
{
number_float = static_cast<number_float_t>(0.0);
break;
}
case value_t::null:
{
object = nullptr; // silence warning, see #821
break;
}
case value_t::discarded:
default:
{
object = nullptr; // silence warning, see #821
if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
{
JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.11.2", nullptr)); // LCOV_EXCL_LINE
}
break;
}
}
} | pushq %rbx
movq %rdi, %rbx
cmpl $0x8, %esi
ja 0x2282f
movl %esi, %eax
leaq 0x2c912(%rip), %rcx # 0x4f138
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, (%rbx)
jmp 0x228a8
movl $0x30, %edi
callq 0x7370
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %edx, %edx
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
jmp 0x228a5
movb $0x0, (%rbx)
jmp 0x228a8
movl $0x18, %edi
callq 0x7370
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
jmp 0x228a5
leaq 0x2d3aa(%rip), %rdi # 0x4fc30
callq 0x228aa
jmp 0x228a5
movl $0x28, %edi
callq 0x7370
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movb $0x0, 0x20(%rax)
movq %rax, (%rbx)
popq %rbx
retq
| /pboettch[P]json-schema-validator/build_O3/_deps/nlohmann_json-src/include/nlohmann/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_2::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [17], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3]>(char const (&) [17], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3]) | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(std::forward<Args>(args)...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, 0x10(%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x7180
movq %rax, %r12
addq 0x8(%r13), %r12
addq 0x8(%r15), %r12
movq %r14, %rdi
callq 0x7180
leaq (%rax,%r12), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x7550
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x7680
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0x70d0
movq 0x10(%rsp), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x7310
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x70d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7680
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x22af3
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x7380
movq %r14, %rdi
callq 0x7600
| /pboettch[P]json-schema-validator/build_O3/_deps/nlohmann_json-src/include/nlohmann/detail/string_concat.hpp |
nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::lexer(nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&, bool) | explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{} | pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movb %dl, 0x10(%rdi)
movl $0xffffffff, 0x14(%rdi) # imm = 0xFFFFFFFF
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movb %al, 0x60(%rdi)
leaq 0x2cf96(%rip), %rcx # 0x4fc30
movq %rcx, 0x70(%rdi)
movups %xmm0, 0x78(%rdi)
movq %rax, 0x88(%rdi)
callq 0x7690
movq (%rax), %rax
testq %rax, %rax
je 0x22cbb
movsbl (%rax), %eax
jmp 0x22cc0
movl $0x2e, %eax
movl %eax, 0x90(%rbx)
popq %rbx
retq
| /pboettch[P]json-schema-validator/build_O3/_deps/nlohmann_json-src/include/nlohmann/detail/input/lexer.hpp |
nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::json_value::destroy(nlohmann::json_abi_v3_11_2::detail::value_t) | void destroy(value_t t)
{
if (t == value_t::array || t == value_t::object)
{
// flatten the current json_value to a heap-allocated stack
std::vector<basic_json> stack;
// move the top-level items to stack
if (t == value_t::array)
{
stack.reserve(array->size());
std::move(array->begin(), array->end(), std::back_inserter(stack));
}
else
{
stack.reserve(object->size());
for (auto&& it : *object)
{
stack.push_back(std::move(it.second));
}
}
while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
stack.pop_back();
// if current_item is array/object, move
// its children to the stack to be processed later
if (current_item.is_array())
{
std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(), std::back_inserter(stack));
current_item.m_value.array->clear();
}
else if (current_item.is_object())
{
for (auto&& it : *current_item.m_value.object)
{
stack.push_back(std::move(it.second));
}
current_item.m_value.object->clear();
}
// it's now safe that current_item get destructed
// since it doesn't have any children
}
}
switch (t)
{
case value_t::object:
{
AllocatorType<object_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
break;
}
case value_t::array:
{
AllocatorType<array_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
break;
}
case value_t::string:
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
break;
}
case value_t::binary:
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
break;
}
case value_t::null:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::discarded:
default:
{
break;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %r13d
movq %rdi, %r14
leal -0x1(%r13), %eax
cmpb $0x1, %al
ja 0x27ac6
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%r14), %rax
cmpb $0x2, %r13b
jne 0x27966
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x4, %rsi
movq %rsp, %rdi
callq 0x27b8e
movq (%r14), %rax
movq (%rax), %r15
movq 0x8(%rax), %rbx
subq %r15, %rbx
sarq $0x4, %rbx
testq %rbx, %rbx
jle 0x279a1
incq %rbx
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x264f4
addq $0x10, %r15
decq %rbx
cmpq $0x1, %rbx
jg 0x2794c
jmp 0x279a1
movq 0x28(%rax), %rsi
movq %rsp, %rdi
callq 0x27b8e
movq (%r14), %rbx
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x279a1
movq %rsp, %r12
leaq 0x40(%r15), %rsi
movq %r12, %rdi
callq 0x264f4
movq %r15, %rdi
callq 0x7270
movq %rax, %r15
cmpq %rbx, %rax
jne 0x27985
movq %r13, 0x28(%rsp)
movq %r14, 0x30(%rsp)
movq 0x8(%rsp), %rax
cmpq %rax, (%rsp)
je 0x27ab4
movq %rsp, %r15
leaq 0x18(%rsp), %r12
movb -0x10(%rax), %cl
movb %cl, 0x18(%rsp)
movq -0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movb $0x0, -0x10(%rax)
movq $0x0, -0x8(%rax)
movq 0x8(%rsp), %rdi
addq $-0x10, %rdi
movq %rdi, 0x8(%rsp)
callq 0x13fe0
movzbl 0x18(%rsp), %eax
cmpl $0x1, %eax
je 0x27a65
cmpl $0x2, %eax
jne 0x27a9d
movq 0x20(%rsp), %rbx
movq (%rbx), %r13
movq 0x8(%rbx), %r14
movq %r14, %rbp
subq %r13, %rbp
sarq $0x4, %rbp
testq %rbp, %rbp
jle 0x27a46
incq %rbp
movq %r15, %rdi
movq %r13, %rsi
callq 0x264f4
addq $0x10, %r13
decq %rbp
cmpq $0x1, %rbp
jg 0x27a22
movq 0x20(%rsp), %rbx
movq (%rbx), %r13
movq 0x8(%rbx), %r14
cmpq %r13, %r14
je 0x27a9d
movq %r13, %rbp
movq %rbp, %rdi
callq 0x13fe0
addq $0x10, %rbp
cmpq %r14, %rbp
jne 0x27a4e
movq %r13, 0x8(%rbx)
jmp 0x27a9d
movq 0x20(%rsp), %rdi
movq 0x18(%rdi), %r13
leaq 0x8(%rdi), %rbx
cmpq %rbx, %r13
je 0x27a98
leaq 0x40(%r13), %rsi
movq %r15, %rdi
callq 0x264f4
movq %r13, %rdi
callq 0x7270
movq %rax, %r13
cmpq %rbx, %rax
jne 0x27a77
movq 0x20(%rsp), %rdi
callq 0x27cca
movq %r12, %rdi
callq 0x13fe0
movq 0x8(%rsp), %rax
cmpq %rax, (%rsp)
jne 0x279c2
movq %rsp, %rdi
callq 0x27c82
movq 0x30(%rsp), %r14
movq 0x28(%rsp), %r13
movzbl %r13b, %eax
decl %eax
cmpl $0x7, %eax
ja 0x27b57
leaq 0x27b6c(%rip), %rcx # 0x4f648
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r14), %rdi
callq 0x27cf8
movq (%r14), %rdi
movl $0x30, %esi
jmp 0x27b52
movq (%r14), %rdi
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x27b17
movq (%rcx), %rsi
incq %rsi
movq %rax, %rdi
callq 0x7380
movq (%r14), %rdi
movl $0x20, %esi
jmp 0x27b52
movq (%r14), %rdi
callq 0x27c82
movq (%r14), %rdi
movl $0x18, %esi
jmp 0x27b52
movq (%r14), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x27b4d
movq 0x10(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x7380
movq (%r14), %rdi
movl $0x28, %esi
callq 0x7380
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27b6a
jmp 0x27b6a
movq %rax, %rbx
jmp 0x27b7e
jmp 0x27b71
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13fe0
movq %rsp, %rdi
callq 0x27c82
movq %rbx, %rdi
callq 0x7600
| /pboettch[P]json-schema-validator/build_O3/_deps/nlohmann_json-src/include/nlohmann/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_2::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [23], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const (&) [23], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(std::forward<Args>(args)...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x7180
addq 0x8(%r14), %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7550
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7680
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x70d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x280fc
movq (%r12), %rsi
incq %rsi
callq 0x7380
movq %r14, %rdi
callq 0x7600
| /pboettch[P]json-schema-validator/build_O3/_deps/nlohmann_json-src/include/nlohmann/detail/string_concat.hpp |
nlohmann::json_abi_v3_11_2::detail::parse_error::position_string[abi:cxx11](nlohmann::json_abi_v3_11_2::detail::position_t const&) | static std::string position_string(const position_t& pos)
{
return concat(" at line ", std::to_string(pos.lines_read + 1),
", column ", std::to_string(pos.chars_read_current_line));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
incq %r15
movl $0x1, %ebp
movabsq $0x346dc5d63886594b, %r13 # imm = 0x346DC5D63886594B
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x29066
movl $0x4, %esi
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x2905f
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0x29064
cmpq $0x2710, %rcx # imm = 0x2710
jb 0x29066
movq %rcx, %rax
mulq %r13
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0x29029
addl $-0x3, %esi
jmp 0x29066
addl $-0x2, %esi
jmp 0x29066
decl %esi
movl %esi, %esi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x7440
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x26841
movq 0x8(%r14), %r14
cmpq $0xa, %r14
jb 0x290e0
movl $0x4, %ebp
movq %r14, %rcx
cmpq $0x63, %rcx
jbe 0x290d9
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0x290de
cmpq $0x2710, %rcx # imm = 0x2710
jb 0x290e0
movq %rcx, %rax
mulq %r13
shrq $0xb, %rdx
addl $0x4, %ebp
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0x290a3
addl $-0x3, %ebp
jmp 0x290e0
addl $-0x2, %ebp
jmp 0x290e0
decl %ebp
movl %ebp, %esi
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
callq 0x7440
leaq 0x28(%rsp), %r15
movq (%r15), %rdi
movl 0x8(%r15), %esi
movq %r14, %rdx
callq 0x26841
leaq 0x2810d(%rip), %rsi # 0x51220
leaq 0x28110(%rip), %rcx # 0x5122a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %r8
callq 0x291b2
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x29141
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7380
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2915d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7380
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x2918e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7380
jmp 0x2918e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x291aa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7380
movq %rbx, %rdi
callq 0x7600
| /pboettch[P]json-schema-validator/build_O3/_deps/nlohmann_json-src/include/nlohmann/detail/exceptions.hpp |
nlohmann::json_abi_v3_11_2::detail::type_error nlohmann::json_abi_v3_11_2::detail::type_error::create<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const*, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const*) | static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
{
std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x25dc0(%rip), %rsi # 0x511ad
leaq 0x25dc3(%rip), %rdx # 0x511b7
leaq 0x28(%rsp), %rdi
callq 0x18da6
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl %ebp, %edx
callq 0x22900
leaq 0x78(%rsp), %r14
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb %al, (%r14)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq 0x8(%r15), %rsi
addq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x7550
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x70d0
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x70d0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0x70d0
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x2b497
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x7380
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b4b2
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x7380
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2b4c9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7380
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x22b68
leaq 0x3fc19(%rip), %rax # 0x6b0f8
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2b4f9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7380
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2b587
movq 0x18(%rsp), %rsi
jmp 0x2b57f
movq %rax, %rbx
jmp 0x2b570
movq %rax, %rbx
jmp 0x2b587
movq %rdx, %rbx
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2b549
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7380
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
leaq 0x88(%rsp), %r12
movq %r14, %rsi
movq %r15, %rcx
movl %ebx, %r8d
movq %r12, %r9
callq 0x7ee2
movq (%r12), %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2b587
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7380
movq %rbx, %rdi
callq 0x7600
| /pboettch[P]json-schema-validator/build_O3/_deps/nlohmann_json-src/include/nlohmann/detail/exceptions.hpp |
nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::basic_json<nlohmann::json_abi_v3_11_2::detail::json_ref<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>, 0>(nlohmann::json_abi_v3_11_2::detail::json_ref<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>> const&) | basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x2b896
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x268bc
movb (%r14), %al
movq 0x8(%r14), %rcx
jmp 0x2b8a7
movb (%rsi), %al
movq 0x8(%rsi), %rcx
movb $0x0, (%rsi)
movq $0x0, 0x8(%rsi)
movb %al, (%rbx)
movq %rcx, 0x8(%rbx)
leaq 0x8(%rsp), %rdi
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
callq 0x13fe0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /pboettch[P]json-schema-validator/build_O3/_deps/nlohmann_json-src/include/nlohmann/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_2::detail::escape<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline StringType escape(StringType s)
{
replace_substring(s, StringType{"~"}, StringType{"~0"});
replace_substring(s, StringType{"/"}, StringType{"~1"});
return s;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x236ee(%rip), %rsi # 0x513a2
leaq 0x236e8(%rip), %rdx # 0x513a3
movq %rsp, %rdi
callq 0x18da6
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x236cc(%rip), %rsi # 0x5139f
leaq 0x236c7(%rip), %rdx # 0x513a1
leaq 0x20(%rsp), %rdi
callq 0x18da6
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x75f0
cmpq $-0x1, %rax
je 0x2dd3c
movq %rax, %r15
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73f0
addq 0x28(%rsp), %r15
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x75f0
movq %rax, %r15
cmpq $-0x1, %rax
jne 0x2dd00
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x2dd53
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7380
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2dd69
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7380
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x24290(%rip), %rsi # 0x52006
leaq 0x2428a(%rip), %rdx # 0x52007
callq 0x18da6
leaq 0x20(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x2360b(%rip), %rsi # 0x5139c
leaq 0x23606(%rip), %rdx # 0x5139e
callq 0x18da6
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x75f0
cmpq $-0x1, %rax
je 0x2ddf5
movq %rax, %r15
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73f0
addq 0x28(%rsp), %r15
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x75f0
movq %rax, %r15
cmpq $-0x1, %rax
jne 0x2ddb9
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x2de0c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7380
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2de22
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7380
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0x2de41
movq %rdx, (%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
jmp 0x2de47
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2de73
jmp 0x2de78
movq %rax, %rbx
jmp 0x2de99
movq %rax, %rbx
jmp 0x2deaf
jmp 0x2de7f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x2de99
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7380
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2deaf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7380
movq %rbx, %rdi
callq 0x7600
nop
| /pboettch[P]json-schema-validator/build_O3/_deps/nlohmann_json-src/include/nlohmann/detail/string_escape.hpp |
nlohmann::operator<<(std::ostream&, nlohmann::json_uri const&) | std::ostream &operator<<(std::ostream &os, const json_uri &u)
{
return os << u.to_string();
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2e8c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x7410
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ea70
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7380
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ea99
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7380
movq %rbx, %rdi
callq 0x7600
nop
| /pboettch[P]json-schema-validator/src/json-uri.cpp |
nlohmann::json_schema::json_validator::json_validator(nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const&, std::function<void (nlohmann::json_uri const&, nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>&)>, std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>, std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const&)>) | json_validator::json_validator(const json &schema,
schema_loader loader,
format_checker format,
content_checker content)
: json_validator(std::move(loader),
std::move(format),
std::move(content))
{
set_root_schema(schema);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x18(%rdx), %rax
movq %rax, 0x38(%rsp)
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0x2eed8
movups (%rdx), %xmm1
addq $0x10, %rdx
movaps %xmm1, 0x20(%rsp)
movq %rax, 0x30(%rsp)
movups %xmm0, (%rdx)
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rcx), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rcx), %r12
testq %r12, %r12
je 0x2ef0d
movups (%rcx), %xmm0
addq $0x10, %rcx
movaps %xmm0, (%rsp)
movq %r12, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x18(%r8), %rax
movq %rax, 0x58(%rsp)
movq 0x10(%r8), %r13
testq %r13, %r13
je 0x2ef43
movups (%r8), %xmm1
addq $0x10, %r8
movaps %xmm1, 0x40(%rsp)
movq %r13, 0x50(%rsp)
movups %xmm0, (%r8)
movl $0xa0, %edi
callq 0x7370
movq %rax, %r15
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
leaq 0x40(%rsp), %r12
movq %rax, %rdi
movq %r12, %rcx
callq 0x40afa
movq %r15, (%rbx)
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x2ef84
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2ef9b
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2efb4
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2f04c
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2f044
jmp 0x2f044
jmp 0x2f044
movq %rax, %r14
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x2efe6
movq %rbx, %rdi
callq 0x41694
movq $0x0, (%rbx)
jmp 0x2f038
movq %rax, %r14
testq %r13, %r13
je 0x2f00c
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%r13
movq 0x10(%rsp), %r12
testq %r12, %r12
je 0x2f01f
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%r12
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2f038
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x7600
jmp 0x2f044
jmp 0x2f044
movq %rax, %rdi
callq 0x140f5
| /pboettch[P]json-schema-validator/src/json-validator.cpp |
nlohmann::json_schema::json_validator::validate(nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const&) const | json json_validator::validate(const json &instance) const
{
throwing_error_handler err;
return validate(instance, err);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3c8c6(%rip), %rax # 0x6bbd8
movq %rax, (%rsp)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x24121(%rip), %rsi # 0x53447
leaq 0x2411b(%rip), %rdx # 0x53448
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x18da6
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x2a4ce
movq %rsp, %rcx
leaq 0x28(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2f3c4
leaq 0x28(%rsp), %rdi
callq 0x2a656
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2f37e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7380
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2a656
jmp 0x2f3a4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2f3bb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7380
movq %rbx, %rdi
callq 0x7600
nop
| /pboettch[P]json-schema-validator/src/json-validator.cpp |
(anonymous namespace)::schema_ref::default_value(nlohmann::json_abi_v3_11_2::json_pointer<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const&, nlohmann::json_schema::error_handler&) const | const json &default_value(const json::json_pointer &ptr, const json &instance, error_handler &e) const override final
{
if (!default_value_.is_null())
return default_value_;
auto target = target_.lock();
if (target)
return target->default_value(ptr, instance, e);
e.error(ptr, instance, "unresolved or freed schema-reference " + id_);
return default_value_;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x10(%rdi), %r14
cmpb $0x0, 0x10(%rdi)
jne 0x31ab0
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rdx
movq 0x48(%rdi), %rbx
testq %rbx, %rbx
je 0x31a60
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x31a60
leal 0x1(%rax), %ecx
lock
cmpxchgl %ecx, 0x8(%rbx)
jne 0x31a25
movl 0x8(%rbx), %eax
testl %eax, %eax
setne %al
movq 0x40(%rdx), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x31a62
movq (%rdi), %rax
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq *0x20(%rax)
movq %rax, %r14
jmp 0x31aa8
xorl %ebx, %ebx
addq $0x20, %rdx
leaq 0x2124f(%rip), %rsi # 0x52cbc
movq %rsp, %rdi
callq 0x2b8ca
movq (%r12), %rax
movq %rsp, %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq *0x10(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31aa3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7380
testq %rbx, %rbx
je 0x31ab0
movq %rbx, %rdi
callq 0x1f63e
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x31aee
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31ae9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7380
jmp 0x31ae9
movq %rax, %r14
testq %rbx, %rbx
je 0x31af6
movq %rbx, %rdi
callq 0x1f63e
movq %r14, %rdi
callq 0x7600
| /pboettch[P]json-schema-validator/src/json-validator.cpp |
(anonymous namespace)::type_schema::validate(nlohmann::json_abi_v3_11_2::json_pointer<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const&, nlohmann::json_patch&, nlohmann::json_schema::error_handler&) const | void validate(const json::json_pointer &ptr, const json &instance, json_patch &patch, error_handler &e) const override final
{
// depending on the type of instance run the type specific validator - if present
auto type = type_[static_cast<uint8_t>(instance.type())];
if (type)
type->validate(ptr, instance, patch, e);
else
e.error(ptr, instance, "unexpected instance type");
if (enum_.first) {
bool seen_in_enum = false;
for (auto &v : enum_.second)
if (instance == v) {
seen_in_enum = true;
break;
}
if (!seen_in_enum)
e.error(ptr, instance, "instance not found in required enum");
}
if (const_.first &&
const_.second != instance)
e.error(ptr, instance, "instance not const");
for (auto l : logic_)
l->validate(ptr, instance, patch, e);
if (if_) {
first_error_handler err;
if_->validate(ptr, instance, patch, err);
if (!err) {
if (then_)
then_->validate(ptr, instance, patch, e);
} else {
if (else_)
else_->validate(ptr, instance, patch, e);
}
}
if (instance.is_null()) {
patch.add(nlohmann::json::json_pointer{}, default_value_);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, (%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r14
movzbl (%rdx), %eax
movq 0x20(%rdi), %rcx
shll $0x4, %eax
movq (%rcx,%rax), %rdi
movq 0x8(%rcx,%rax), %rcx
testq %rcx, %rcx
je 0x39e92
movq 0x3211c(%rip), %rax # 0x6bfa0
cmpb $0x0, (%rax)
je 0x39e8e
incl 0x8(%rcx)
jmp 0x39e92
lock
incl 0x8(%rcx)
testq %rdi, %rdi
movq %rcx, 0x88(%rsp)
je 0x39eb6
movq (%rdi), %rax
movq %rbp, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq *0x18(%rax)
jmp 0x39f03
leaq 0x40(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x17727(%rip), %rsi # 0x515ed
leaq 0x17738(%rip), %rdx # 0x51605
leaq 0x30(%rsp), %rdi
callq 0x18da6
movq (%rsp), %rdi
movq (%rdi), %rax
leaq 0x30(%rsp), %rcx
movq %rbp, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x39f03
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x7380
cmpb $0x1, 0x38(%r14)
jne 0x3a068
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
leaq 0x40(%r14), %rax
movq %rax, 0x30(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rsp)
movq %rcx, 0x48(%rsp)
movzbl 0x40(%r14), %edx
testl %edx, %edx
je 0x39f92
cmpl $0x2, %edx
je 0x39f6c
cmpl $0x1, %edx
jne 0x39f9d
movq 0x48(%r14), %rdx
movq 0x18(%rdx), %rsi
movq %rsi, 0x38(%rsp)
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
addq $0x8, %rdx
movq %rdx, 0x18(%rsp)
jmp 0x39fb9
movq 0x48(%r14), %rdx
movq (%rdx), %rsi
movq %rsi, 0x40(%rsp)
movq %rax, 0x10(%rsp)
movups %xmm0, 0x18(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x20(%rsp)
jmp 0x39fb9
movq $0x1, 0x48(%rsp)
jmp 0x39fa6
movq $0x0, 0x48(%rsp)
movq %rax, 0x10(%rsp)
movups %xmm0, 0x18(%rsp)
movq $0x1, 0x28(%rsp)
leaq 0x30(%rsp), %rbx
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x454fc
testb %al, %al
jne 0x3a01b
movq %rbx, %rdi
callq 0x457a6
movq %r12, %rdi
movq %rax, %rsi
callq 0x48bb3
testb %al, %al
jne 0x3a068
movq 0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x3a00c
cmpl $0x1, %eax
jne 0x3a014
movq 0x38(%rsp), %rdi
callq 0x7270
movq %rax, 0x38(%rsp)
jmp 0x39fc3
addq $0x10, 0x40(%rsp)
jmp 0x39fc3
incq 0x48(%rsp)
jmp 0x39fc3
leaq 0x40(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x1941e(%rip), %rsi # 0x53449
leaq 0x1943a(%rip), %rdx # 0x5346c
leaq 0x30(%rsp), %rdi
callq 0x18da6
movq (%rsp), %rdi
movq (%rdi), %rax
leaq 0x30(%rsp), %rcx
movq %rbp, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3a068
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x7380
cmpb $0x1, 0x50(%r14)
jne 0x3a0cc
leaq 0x58(%r14), %rdi
movq %r12, %rsi
callq 0x49574
testb %al, %al
je 0x3a0cc
leaq 0x40(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x193de(%rip), %rsi # 0x5346d
leaq 0x193e9(%rip), %rdx # 0x5347f
leaq 0x30(%rsp), %rdi
callq 0x18da6
movq (%rsp), %rdi
movq (%rdi), %rax
leaq 0x30(%rsp), %rcx
movq %rbp, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3a0cc
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x7380
movq 0x68(%r14), %r15
movq %r14, 0x90(%rsp)
movq 0x70(%r14), %r14
cmpq %r14, %r15
je 0x3a12f
movq 0x31eb8(%rip), %r13 # 0x6bfa0
movq (%r15), %rdi
movq 0x8(%r15), %rbx
testq %rbx, %rbx
je 0x3a104
cmpb $0x0, (%r13)
je 0x3a100
incl 0x8(%rbx)
jmp 0x3a104
lock
incl 0x8(%rbx)
movq (%rdi), %rax
movq %rbp, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq *0x18(%rax)
testq %rbx, %rbx
je 0x3a126
movq %rbx, %rdi
callq 0x1f63e
addq $0x10, %r15
cmpq %r14, %r15
jne 0x3a0e8
movq 0x90(%rsp), %r13
cmpq $0x0, 0x80(%r13)
movq 0x88(%rsp), %r14
je 0x3a239
leaq 0x316e4(%rip), %rax # 0x6b838
leaq 0x40(%rsp), %r15
movq %rax, -0x10(%r15)
xorl %eax, %eax
movb %al, -0x8(%r15)
leaq 0x20(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb %al, (%rbx)
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x2a6e6
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3a19a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7380
xorl %eax, %eax
leaq 0x78(%rsp), %rbx
movb %al, -0x20(%rbx)
movq %rax, -0x18(%rbx)
movq %rbx, -0x10(%rbx)
movq %rax, -0x8(%rbx)
movb %al, (%rbx)
movq 0x80(%r13), %rdi
movq (%rdi), %rax
leaq 0x30(%rsp), %r8
movq %rbp, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
callq *0x18(%rax)
cmpb $0x0, 0x38(%rsp)
je 0x3a1df
movq 0xa0(%r13), %rdi
jmp 0x3a1e6
movq 0x90(%r13), %rdi
testq %rdi, %rdi
je 0x3a200
movq (%rdi), %rax
movq %rbp, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq *0x18(%rax)
movq %r15, %rbp
leaq 0x58(%rsp), %r15
leaq 0x31629(%rip), %rax # 0x6b838
movq %rax, -0x28(%r15)
movq 0x10(%r15), %rdi
cmpq %rbx, %rdi
je 0x3a229
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x7380
movq %r15, %rdi
callq 0x13fe0
movq %rbp, %rdi
callq 0x19052
cmpb $0x0, (%r12)
jne 0x3a2c9
leaq 0x40(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x159dc(%rip), %rdx # 0x4fc30
leaq 0x30(%rsp), %rdi
movq %rdx, %rsi
callq 0x18da6
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2a6e6
addq $0x10, %r13
leaq 0x98(%rsp), %rdi
movq %r13, %rsi
callq 0x268bc
leaq 0x10(%rsp), %rsi
leaq 0x98(%rsp), %rdx
movq 0x8(%rsp), %rdi
callq 0x4b0b8
leaq 0x98(%rsp), %rdi
callq 0x13fe0
leaq 0x10(%rsp), %rdi
callq 0x19052
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3a2c9
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x7380
testq %r14, %r14
je 0x3a2d6
movq %r14, %rdi
callq 0x1f63e
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a315
jmp 0x3a35a
jmp 0x3a315
jmp 0x3a35a
movq %rax, %r14
leaq 0x98(%rsp), %rdi
callq 0x13fe0
jmp 0x3a305
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x19052
jmp 0x3a318
jmp 0x3a315
jmp 0x3a35a
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3a36f
movq 0x40(%rsp), %rsi
jmp 0x3a33d
jmp 0x3a35a
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3a36f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7380
jmp 0x3a36f
jmp 0x3a35a
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x3d17c
jmp 0x3a36f
jmp 0x3a35a
movq %rax, %r14
jmp 0x3a36f
movq %rax, %r14
testq %rbx, %rbx
je 0x3a36f
movq %rbx, %rdi
callq 0x1f63e
cmpq $0x0, 0x88(%rsp)
je 0x3a387
movq 0x88(%rsp), %rdi
callq 0x1f63e
movq %r14, %rdi
callq 0x7600
nop
| /pboettch[P]json-schema-validator/src/json-validator.cpp |
(anonymous namespace)::object::validate(nlohmann::json_abi_v3_11_2::json_pointer<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const&, nlohmann::json_patch&, nlohmann::json_schema::error_handler&) const | void validate(const json::json_pointer &ptr, const json &instance, json_patch &patch, error_handler &e) const override
{
if (maxProperties_.first && instance.size() > maxProperties_.second)
e.error(ptr, instance, "too many properties");
if (minProperties_.first && instance.size() < minProperties_.second)
e.error(ptr, instance, "too few properties");
for (auto &r : required_)
if (instance.find(r) == instance.end())
e.error(ptr, instance, "required property '" + r + "' not found in object");
// for each property in instance
for (auto &p : instance.items()) {
if (propertyNames_)
propertyNames_->validate(ptr, p.key(), patch, e);
bool a_prop_or_pattern_matched = false;
auto schema_p = properties_.find(p.key());
// check if it is in "properties"
if (schema_p != properties_.end()) {
a_prop_or_pattern_matched = true;
schema_p->second->validate(ptr / p.key(), p.value(), patch, e);
}
#ifndef NO_STD_REGEX
// check all matching patternProperties
for (auto &schema_pp : patternProperties_)
if (REGEX_NAMESPACE::regex_search(p.key(), schema_pp.first)) {
a_prop_or_pattern_matched = true;
schema_pp.second->validate(ptr / p.key(), p.value(), patch, e);
}
#endif
// check additionalProperties as a last resort
if (!a_prop_or_pattern_matched && additionalProperties_) {
first_error_handler additional_prop_err;
additionalProperties_->validate(ptr / p.key(), p.value(), patch, additional_prop_err);
if (additional_prop_err)
e.error(ptr, instance, "validation failed for additional property '" + p.key() + "': " + additional_prop_err.message_);
}
}
// reverse search
for (auto const &prop : properties_) {
const auto finding = instance.find(prop.first);
if (instance.end() == finding) { // if the prop is not in the instance
const auto &default_value = prop.second->default_value(ptr, instance, e);
if (!default_value.is_null()) { // if default value is available
patch.add((ptr / prop.first), default_value);
}
}
}
for (auto &dep : dependencies_) {
auto prop = instance.find(dep.first);
if (prop != instance.end()) // if dependency-property is present in instance
dep.second->validate(ptr / dep.first, instance, patch, e); // validate
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r8, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
movq %rdx, (%rsp)
jne 0x3be37
movzbl (%rdx), %ecx
testl %ecx, %ecx
je 0x3be37
cmpl $0x1, %ecx
je 0x3bdd4
movl $0x1, %eax
cmpl $0x2, %ecx
jne 0x3bddc
movq 0x8(%rdx), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x4, %rax
jmp 0x3bddc
movq 0x8(%rdx), %rax
movq 0x28(%rax), %rax
cmpq 0x28(%rbx), %rax
jbe 0x3be37
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x173cd(%rip), %rsi # 0x531bf
leaq 0x173d9(%rip), %rdx # 0x531d2
leaq 0x50(%rsp), %rdi
callq 0x18da6
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
leaq 0x50(%rsp), %rcx
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *0x10(%rax)
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x3be33
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x7380
movq (%rsp), %rdx
cmpb $0x1, 0x30(%rbx)
jne 0x3becd
movzbl (%rdx), %eax
testl %eax, %eax
je 0x3be72
cmpl $0x1, %eax
je 0x3be63
cmpl $0x2, %eax
jne 0x3be6d
movq 0x8(%rdx), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x4, %rax
jmp 0x3be72
movq 0x8(%rdx), %rax
movq 0x28(%rax), %rax
jmp 0x3be72
movl $0x1, %eax
cmpq 0x38(%rbx), %rax
jae 0x3becd
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1734b(%rip), %rsi # 0x531d3
leaq 0x17356(%rip), %rdx # 0x531e5
leaq 0x50(%rsp), %rdi
callq 0x18da6
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
leaq 0x50(%rsp), %rcx
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *0x10(%rax)
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x3bec9
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x7380
movq (%rsp), %rdx
movq 0x40(%rbx), %r15
movq %rbx, 0x20(%rsp)
movq 0x48(%rbx), %rbx
cmpq %rbx, %r15
je 0x3c0b0
leaq 0x120(%rsp), %r14
leaq 0x60(%rsp), %r12
leaq 0x50(%rsp), %r13
leaq 0x118(%rsp), %rbp
movq %rdx, 0x50(%rsp)
leaq 0x58(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x68(%rsp)
movzbl (%rdx), %eax
cmpl $0x1, %eax
je 0x3bf56
cmpl $0x2, %eax
jne 0x3bf6f
movq 0x8(%rdx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x60(%rsp)
movq %rdx, 0x118(%rsp)
movups %xmm0, (%r14)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x130(%rsp)
jmp 0x3bfb7
movq 0x8(%rdx), %rdi
movq %r15, %rsi
callq 0x43850
movq (%rsp), %rdx
movq %rax, 0x58(%rsp)
movb (%rdx), %al
jmp 0x3bf78
movq $0x1, 0x68(%rsp)
movq %rdx, 0x118(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
movq %rcx, 0x130(%rsp)
cmpb $0x2, %al
je 0x3bfb7
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x3bfc9
movq 0x8(%rdx), %rax
addq $0x8, %rax
movq %rax, 0x120(%rsp)
jmp 0x3bfd5
movq 0x8(%rdx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x128(%rsp)
jmp 0x3bfd5
movq $0x1, 0x130(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x454fc
testb %al, %al
je 0x3c09f
movq %rbp, %rdi
leaq 0x17193(%rip), %rsi # 0x53185
movq %r15, %rdx
callq 0x2b8ca
movq %rbp, %rdi
leaq 0x171e2(%rip), %rsi # 0x531e6
callq 0x7680
movq %r12, 0x50(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3c02c
movq %rdx, 0x50(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x60(%rsp)
jmp 0x3c034
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x58(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movq %r13, %rcx
callq *0x10(%rax)
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x3c07a
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x7380
movq 0x118(%rsp), %rdi
leaq 0x128(%rsp), %rax
cmpq %rax, %rdi
je 0x3c09f
movq 0x128(%rsp), %rsi
incq %rsi
callq 0x7380
addq $0x20, %r15
cmpq %rbx, %r15
movq (%rsp), %rdx
jne 0x3befd
leaq 0x280(%rsp), %rbx
movq %rdx, (%rbx)
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x48442
leaq 0x118(%rsp), %rdi
movq %rbx, %rsi
callq 0x484c0
movq 0x20(%rsp), %r15
leaq 0x58(%r15), %rax
movq %rax, 0x248(%rsp)
leaq 0x60(%r15), %rax
movq %rax, 0x48(%rsp)
leaq 0xc0(%rsp), %r13
movq %rbp, %rdi
leaq 0x118(%rsp), %rsi
callq 0x454fc
testb %al, %al
jne 0x3c674
movq 0xe0(%r15), %rbx
testq %rbx, %rbx
je 0x3c170
movq %rbp, %rdi
callq 0x48530
movq $0x0, 0xc8(%rsp)
movb $0x3, 0xc0(%rsp)
movq %rax, %rdi
callq 0x270d4
movq %rax, 0xc8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq *0x18(%rax)
movq %r13, %rdi
callq 0x13fe0
movq %rbp, %rdi
callq 0x48530
movq 0x248(%rsp), %rdi
movq %rax, %rsi
callq 0x3d10e
cmpq 0x48(%rsp), %rax
setne %r12b
je 0x3c22c
movq 0x40(%rax), %r14
movq %rbp, %rdi
callq 0x48530
leaq 0x228(%rsp), %rbx
leaq 0x238(%rsp), %rcx
movq %rcx, 0x228(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x19be8
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x48577
movq %rbp, %rdi
callq 0x457a6
movq (%r14), %r9
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq *0x18(%r9)
movq %r13, %rdi
callq 0x19052
movq 0x228(%rsp), %rdi
leaq 0x238(%rsp), %rax
cmpq %rax, %rdi
je 0x3c22c
movq 0x238(%rsp), %rsi
incq %rsi
callq 0x7380
movq 0x88(%r15), %r14
movq 0x90(%r15), %r15
cmpq %r15, %r14
je 0x3c33e
movq %rbp, %rdi
callq 0x48530
movq (%rax), %rdi
movq 0x8(%rax), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, 0xd0(%rsp)
movaps %xmm0, 0xc0(%rsp)
movq %r13, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x20041
movl %eax, %ebx
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0x3c295
movq 0xd0(%rsp), %rsi
subq %rdi, %rsi
callq 0x7380
testb %bl, %bl
je 0x3c335
movq 0x20(%r14), %rbx
movq %rbp, %rdi
callq 0x48530
leaq 0x208(%rsp), %r12
leaq 0x218(%rsp), %rcx
movq %rcx, 0x208(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x19be8
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x48577
movq %rbp, %rdi
callq 0x457a6
movq (%rbx), %r9
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq *0x18(%r9)
movq %r13, %rdi
callq 0x19052
movq 0x208(%rsp), %rdi
leaq 0x218(%rsp), %rax
cmpq %rax, %rdi
je 0x3c332
movq 0x218(%rsp), %rsi
incq %rsi
callq 0x7380
movb $0x1, %r12b
addq $0x30, %r14
jmp 0x3c23a
testb $0x1, %r12b
movq 0x20(%rsp), %r15
leaq 0x38(%rsp), %r12
jne 0x3c63a
cmpq $0x0, 0xa0(%r15)
je 0x3c63a
leaq 0x2f4d1(%rip), %rax # 0x6b838
movq %rax, 0xc0(%rsp)
xorl %eax, %eax
movb %al, 0xc8(%rsp)
movq %r12, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movb %al, 0x38(%rsp)
leaq 0xd0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2a6e6
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3c3b3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7380
xorl %ecx, %ecx
movb %cl, 0xe8(%rsp)
movq %rcx, 0xf0(%rsp)
leaq 0x108(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq %rcx, 0x100(%rsp)
movb %cl, 0x108(%rsp)
movq %r15, %r14
movq 0xa0(%r15), %rbx
movq %rbp, %rdi
callq 0x48530
leaq 0x1e8(%rsp), %r15
leaq 0x1f8(%rsp), %rcx
movq %rcx, 0x1e8(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x19be8
leaq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x48577
movq %rbp, %rdi
callq 0x457a6
leaq 0x28(%rsp), %r15
movq (%rbx), %r9
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq 0x18(%rsp), %rcx
movq %r13, %r8
callq *0x18(%r9)
movq %r15, %rdi
callq 0x19052
movq 0x1e8(%rsp), %rdi
leaq 0x1f8(%rsp), %rax
cmpq %rax, %rdi
je 0x3c483
movq 0x1f8(%rsp), %rsi
incq %rsi
callq 0x7380
cmpb $0x1, 0xc8(%rsp)
movq %r14, %r15
jne 0x3c5ec
movq %rbp, %rdi
callq 0x48530
leaq 0x250(%rsp), %rbx
movq %rbx, %rdi
leaq 0x16d4e(%rip), %rsi # 0x531fc
movq %rax, %rdx
callq 0x2b8ca
movq %rbx, %rdi
leaq 0x16d68(%rip), %rsi # 0x53228
callq 0x7680
leaq 0x198(%rsp), %rbx
movq %rbx, 0x188(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3c4f9
movq %rdx, 0x188(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x198(%rsp)
jmp 0x3c4ff
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, 0x190(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0xf8(%rsp), %rsi
movq 0x100(%rsp), %rdx
leaq 0x188(%rsp), %rdi
callq 0x70d0
movq %r12, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3c55a
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x3c562
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq *0x10(%rax)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3c5aa
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7380
movq 0x188(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3c5c7
movq 0x198(%rsp), %rsi
incq %rsi
callq 0x7380
movq 0x250(%rsp), %rdi
leaq 0x260(%rsp), %rax
cmpq %rax, %rdi
je 0x3c5ec
movq 0x260(%rsp), %rsi
incq %rsi
callq 0x7380
leaq 0x2f245(%rip), %rax # 0x6b838
movq %rax, 0xc0(%rsp)
movq 0xf8(%rsp), %rdi
leaq 0x108(%rsp), %rax
cmpq %rax, %rdi
je 0x3c620
movq 0x108(%rsp), %rsi
incq %rsi
callq 0x7380
leaq 0xe8(%rsp), %rdi
callq 0x13fe0
leaq 0xd0(%rsp), %rdi
callq 0x19052
movq 0x50(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x3c65d
cmpl $0x1, %eax
jne 0x3c665
movq 0x58(%rsp), %rdi
callq 0x7270
movq %rax, 0x58(%rsp)
jmp 0x3c66a
addq $0x10, 0x60(%rsp)
jmp 0x3c66a
incq 0x68(%rsp)
incq 0x70(%rsp)
jmp 0x3c0fd
leaq 0x118(%rsp), %rdi
callq 0x48642
leaq 0x50(%rsp), %rdi
callq 0x48642
movq 0x70(%r15), %r15
cmpq 0x48(%rsp), %r15
je 0x3c873
leaq 0x58(%rsp), %r14
leaq 0x118(%rsp), %r13
leaq 0x50(%rsp), %rbp
movq (%rsp), %rcx
movq %rcx, 0x50(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x68(%rsp)
movzbl (%rcx), %eax
cmpl $0x1, %eax
je 0x3c70c
cmpl $0x2, %eax
jne 0x3c726
movq 0x8(%rcx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x60(%rsp)
movq %rcx, 0x118(%rsp)
leaq 0x120(%rsp), %rax
movups %xmm0, (%rax)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x130(%rsp)
jmp 0x3c775
leaq 0x20(%r15), %rsi
movq 0x8(%rcx), %rdi
callq 0x43850
movq (%rsp), %rcx
movq %rax, 0x58(%rsp)
movb (%rcx), %al
jmp 0x3c72f
movq $0x1, 0x68(%rsp)
movq %rcx, 0x118(%rsp)
xorps %xmm0, %xmm0
leaq 0x120(%rsp), %rdx
movups %xmm0, (%rdx)
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movq %rdx, 0x130(%rsp)
cmpb $0x2, %al
je 0x3c775
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x3c787
movq 0x8(%rcx), %rax
addq $0x8, %rax
movq %rax, 0x120(%rsp)
jmp 0x3c793
movq 0x8(%rcx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x128(%rsp)
jmp 0x3c793
movq $0x1, 0x130(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x454fc
testb %al, %al
je 0x3c85d
movq 0x40(%r15), %rdi
movq (%rdi), %rax
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movq 0x10(%rsp), %rcx
callq *0x20(%rax)
cmpb $0x0, (%rax)
je 0x3c85d
movq %rax, %rbx
leaq 0x1d8(%rsp), %rax
movq %rax, 0x1c8(%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq 0x1c8(%rsp), %r12
movq %r12, %rdi
callq 0x19be8
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x48577
leaq 0x270(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x268bc
movq 0x18(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4b0b8
movq %r12, %rdi
callq 0x13fe0
movq %r13, %rdi
callq 0x19052
movq 0x1c8(%rsp), %rdi
leaq 0x1d8(%rsp), %rax
cmpq %rax, %rdi
je 0x3c85d
movq 0x1d8(%rsp), %rsi
incq %rsi
callq 0x7380
movq %r15, %rdi
callq 0x7430
movq %rax, %r15
cmpq 0x48(%rsp), %rax
jne 0x3c6ac
movq 0x20(%rsp), %rax
movq 0xc8(%rax), %r15
addq $0xb8, %rax
movq %rax, 0x20(%rsp)
cmpq %rax, %r15
je 0x3ca45
leaq 0x58(%rsp), %rbx
leaq 0x120(%rsp), %rbp
leaq 0x50(%rsp), %r12
leaq 0x118(%rsp), %r13
movq (%rsp), %rcx
movq %rcx, 0x50(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x68(%rsp)
movzbl (%rcx), %eax
cmpl $0x1, %eax
je 0x3c905
cmpl $0x2, %eax
jne 0x3c91f
movq 0x8(%rcx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x60(%rsp)
movq %rcx, 0x118(%rsp)
movups %xmm0, (%rbp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x130(%rsp)
jmp 0x3c967
leaq 0x20(%r15), %rsi
movq 0x8(%rcx), %rdi
callq 0x43850
movq (%rsp), %rcx
movq %rax, 0x58(%rsp)
movb (%rcx), %al
jmp 0x3c928
movq $0x1, 0x68(%rsp)
movq %rcx, 0x118(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movq %rdx, 0x130(%rsp)
cmpb $0x2, %al
je 0x3c967
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x3c979
movq 0x8(%rcx), %rax
addq $0x8, %rax
movq %rax, 0x120(%rsp)
jmp 0x3c985
movq 0x8(%rcx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x128(%rsp)
jmp 0x3c985
movq $0x1, 0x130(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x454fc
testb %al, %al
jne 0x3ca2f
movq %rbx, %r14
movq 0x40(%r15), %rbx
leaq 0x1b8(%rsp), %rax
movq %rax, 0x1a8(%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %r13, %r12
leaq 0x1a8(%rsp), %r13
movq %r13, %rdi
callq 0x19be8
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0x48577
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq *0x18(%rax)
movq %r12, %r13
movq %r12, %rdi
callq 0x19052
movq 0x1a8(%rsp), %rdi
leaq 0x1b8(%rsp), %rax
cmpq %rax, %rdi
movq %r14, %rbx
je 0x3ca2a
movq 0x1b8(%rsp), %rsi
incq %rsi
callq 0x7380
leaq 0x50(%rsp), %r12
movq %r15, %rdi
callq 0x7430
movq %rax, %r15
cmpq 0x20(%rsp), %rax
jne 0x3c8ad
addq $0x288, %rsp # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ca5b
jmp 0x3ca76
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ccf0
movq 0x60(%rsp), %rsi
jmp 0x3cbb2
movq %rax, %rbx
jmp 0x3ccf0
movq %rax, %rbx
jmp 0x3caa5
movq %rax, %rbx
leaq 0x270(%rsp), %rdi
callq 0x13fe0
jmp 0x3ca98
movq %rax, %rbx
leaq 0x118(%rsp), %rdi
callq 0x19052
movq 0x1c8(%rsp), %rdi
leaq 0x1d8(%rsp), %rax
cmpq %rax, %rdi
je 0x3ccf0
movq 0x1d8(%rsp), %rsi
jmp 0x3cbb2
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3caea
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7380
jmp 0x3caea
movq %rax, %rbx
movq 0x188(%rsp), %rdi
leaq 0x198(%rsp), %rax
cmpq %rax, %rdi
je 0x3cb14
movq 0x198(%rsp), %rsi
incq %rsi
callq 0x7380
jmp 0x3cb14
movq %rax, %rbx
movq 0x250(%rsp), %rdi
leaq 0x260(%rsp), %rax
cmpq %rax, %rdi
je 0x3cc32
movq 0x260(%rsp), %rsi
jmp 0x3cc2a
movq %rax, %rbx
jmp 0x3cb4f
movq %rax, %rbx
leaq 0x118(%rsp), %rdi
callq 0x19052
movq 0x1a8(%rsp), %rdi
leaq 0x1b8(%rsp), %rax
cmpq %rax, %rdi
je 0x3ccf0
movq 0x1b8(%rsp), %rsi
jmp 0x3cbb2
movq %rax, %rbx
jmp 0x3cb91
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x3cb91
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x7380
movq 0x118(%rsp), %rdi
leaq 0x128(%rsp), %rax
cmpq %rax, %rdi
je 0x3ccf0
movq 0x128(%rsp), %rsi
incq %rsi
callq 0x7380
jmp 0x3ccf0
movq %rax, %rbx
jmp 0x3cc0d
jmp 0x3cbfb
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3ccd9
movq 0x38(%rsp), %rsi
jmp 0x3ccaf
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x13fe0
jmp 0x3ccd9
movq %rax, %rbx
jmp 0x3cc5a
movq %rax, %rbx
jmp 0x3cc32
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x19052
movq 0x1e8(%rsp), %rdi
leaq 0x1f8(%rsp), %rax
cmpq %rax, %rdi
je 0x3cc32
movq 0x1f8(%rsp), %rsi
incq %rsi
callq 0x7380
leaq 0xc0(%rsp), %rdi
callq 0x3d17c
jmp 0x3ccd9
jmp 0x3ccb4
jmp 0x3ccb4
jmp 0x3ccb4
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x19052
movq 0x228(%rsp), %rdi
leaq 0x238(%rsp), %rax
cmpq %rax, %rdi
je 0x3ccd9
movq 0x238(%rsp), %rsi
jmp 0x3ccaf
jmp 0x3ccb4
movq %rax, %rbx
jmp 0x3cc92
jmp 0x3ccb4
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x19052
movq 0x208(%rsp), %rdi
leaq 0x218(%rsp), %rax
cmpq %rax, %rdi
je 0x3ccd9
movq 0x218(%rsp), %rsi
incq %rsi
jmp 0x3ccd4
movq %rax, %rbx
jmp 0x3ccd9
movq %rax, %rbx
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0x3ccd9
movq 0xd0(%rsp), %rsi
subq %rdi, %rsi
callq 0x7380
leaq 0x118(%rsp), %rdi
callq 0x48642
leaq 0x50(%rsp), %rdi
callq 0x48642
movq %rbx, %rdi
callq 0x7600
| /pboettch[P]json-schema-validator/src/json-validator.cpp |
wide_bit_sum | void wide_bit_sum(RK_U8 *data, RK_U32 len, RK_ULONG *sum)
{
RK_U8 *data8 = NULL;
RK_U32 loop;
data8 = data;
#if LONG_MAX == INT_MAX
RK_U16 *data_rk = NULL;
data_rk = (RK_U16 *)data;
#else
RK_U32 *data_rk = NULL;
data_rk = (RK_U32 *)data;
#endif
for (loop = 0; loop < len / CAL_BYTE; loop++) {
*sum += data_rk[loop];
}
for (loop = len / CAL_BYTE * CAL_BYTE; loop < len; loop++) {
*sum += data8[loop];
}
return;
} | cmpl $0x4, %esi
jb 0x3537
movl %esi, %eax
shrl $0x2, %eax
movq (%rdx), %rcx
xorl %r8d, %r8d
movl (%rdi,%r8,4), %r9d
addq %r9, %rcx
incq %r8
cmpq %r8, %rax
jne 0x3525
movq %rcx, (%rdx)
testb $0x3, %sil
je 0x355a
movq (%rdx), %rax
movl %esi, %ecx
movl %ecx, %esi
andl $-0x4, %esi
movzbl (%rdi,%rsi), %r8d
addq %r8, %rax
movq %rax, (%rdx)
incq %rsi
cmpq %rcx, %rsi
jb 0x3547
retq
| /HermanChen[P]mpp/utils/utils.c |
calc_frm_crc | void calc_frm_crc(MppFrame frame, FrmCrc *crc)
{
RK_ULONG data_grp_byte_cnt = MAX_HALF_WORD_SUM_CNT * CAL_BYTE;
RK_U32 grp_line_cnt = 0;
RK_U32 grp_cnt = 0;
RK_U32 y = 0, x = 0;
RK_U8 *dat8 = NULL;
RK_U32 *dat32 = NULL;
RK_U32 xor = 0;
RK_U32 width = mpp_frame_get_width(frame);
RK_U32 height = mpp_frame_get_height(frame);
RK_U32 stride = mpp_frame_get_hor_stride(frame);
RK_U8 *buf = (RK_U8 *)mpp_buffer_get_ptr(mpp_frame_get_buffer(frame));
grp_line_cnt = data_grp_byte_cnt / ((width + CAL_BYTE - 1) / CAL_BYTE * CAL_BYTE);
/* luma */
grp_cnt = (height + grp_line_cnt - 1) / grp_line_cnt;
crc->luma.sum_cnt = grp_cnt;
dat8 = buf;
for (y = 0; y < height / grp_line_cnt * grp_line_cnt; y++) {
wide_bit_sum(&dat8[y * stride], width, &crc->luma.sum[y / grp_line_cnt]);
}
if (height % grp_line_cnt) {
for (y = height / grp_line_cnt * grp_line_cnt; y < height; y++) {
wide_bit_sum(&dat8[y * stride], width, &crc->luma.sum[y / grp_line_cnt]);
}
}
dat8 = buf;
for (y = 0; y < height; y++) {
dat32 = (RK_U32 *)&dat8[y * stride];
for (x = 0; x < width / 4; x++)
xor ^= dat32[x];
}
crc->luma.len = height * width;
crc->luma.vor = xor;
/* chroma */
grp_cnt = (height / 2 + grp_line_cnt - 1) / grp_line_cnt;
crc->chroma.sum_cnt = grp_cnt;
dat8 = buf + height * stride;
for (y = 0; y < height / 2 / grp_line_cnt * grp_line_cnt; y++) {
wide_bit_sum(&dat8[y * stride], width, &crc->chroma.sum[y / grp_line_cnt]);
}
if (height / 2 % grp_line_cnt) {
for (y = height / 2 / grp_line_cnt * grp_line_cnt; y < height / 2; y++) {
wide_bit_sum(&dat8[y * stride], width, &crc->chroma.sum[y / grp_line_cnt]);
}
}
dat8 = buf + height * stride;
for (y = 0; y < height / 2; y++) {
dat32 = (RK_U32 *)&dat8[y * stride];
for (x = 0; x < width / 4; x++)
xor ^= dat32[x];
}
crc->chroma.len = height * width / 2;
crc->chroma.vor = xor;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x21e0
movl %eax, %r12d
movq %rbx, %rdi
callq 0x2080
movl %eax, %r15d
movq %rbx, %rdi
callq 0x2110
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
callq 0x2290
leaq 0x7e0e(%rip), %rsi # 0xb56e
movq %rax, %rdi
callq 0x2120
movq %r12, %rsi
movq %r14, %r9
movq %rax, %r8
leal 0x3(%r12), %ecx
andl $-0x4, %ecx
xorl %ebx, %ebx
movabsq $0x400000004, %rax # imm = 0x400000004
xorl %edx, %edx
divq %rcx
movq %rax, %r13
addl %r15d, %eax
decl %eax
xorl %edx, %edx
divl %r13d
movl %eax, 0x4(%r14)
movl %r15d, %eax
xorl %edx, %edx
divl %r13d
movq %r15, 0x8(%rsp)
movl %r15d, %r14d
movl %edx, 0x20(%rsp)
subl %edx, %r14d
movq %r8, 0x10(%rsp)
je 0x37f7
xorl %r12d, %r12d
movl %ebx, %edi
addq %r8, %rdi
movl %r12d, %eax
xorl %edx, %edx
divl %r13d
leaq (,%rax,8), %rdx
addq 0x8(%r9), %rdx
movq %r9, %rbp
movq %rsi, %r15
callq 0x3515
movq %r15, %rsi
movq %rbp, %r9
movq 0x10(%rsp), %r8
incq %r12
addl 0x4(%rsp), %ebx
cmpq %r14, %r12
jb 0x37bc
movl 0x8(%rsp), %ebx
cmpl $0x0, 0x20(%rsp)
movq %r13, %rbp
movq %r9, %r15
movq %rsi, %r14
je 0x384f
movq 0x8(%rsp), %r12
movl %r12d, %eax
xorl %edx, %edx
divl %ebp
subl %edx, %r12d
movl 0x4(%rsp), %eax
movl %eax, %edi
imull %r12d, %edi
addq %r8, %rdi
movl %r12d, %eax
xorl %edx, %edx
divl %ebp
leaq (,%rax,8), %rdx
addq 0x8(%r15), %rdx
movl %r14d, %esi
callq 0x3515
movq 0x10(%rsp), %r8
incq %r12
cmpq %rbx, %r12
jb 0x381a
movl 0x4(%rsp), %esi
movq %r15, %r10
movq %rbp, %r9
cmpl $0x0, 0x8(%rsp)
je 0x3894
movl %r14d, %eax
shrl $0x2, %eax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %r15d, %r15d
movl %esi, %ebp
cmpl $0x4, %r14d
jb 0x3888
movl %ecx, %esi
addq %r8, %rsi
xorl %edi, %edi
xorl (%rsi,%rdi,4), %r15d
incq %rdi
cmpq %rdi, %rax
jne 0x387c
incq %rdx
addl %ebp, %ecx
cmpq %rbx, %rdx
jne 0x386f
jmp 0x3899
xorl %r15d, %r15d
movl %esi, %ebp
movq 0x8(%rsp), %rcx
movl %ecx, %eax
imull %r14d, %eax
movl %eax, 0x1c(%rsp)
movl %eax, (%r10)
movl %r15d, 0x10(%r10)
movl %ecx, %r12d
shrl %r12d
leal (%r12,%r9), %eax
decl %eax
xorl %r13d, %r13d
xorl %edx, %edx
divl %r9d
movl %eax, 0x1c(%r10)
movl %ecx, %eax
imull %ebp, %eax
addq %rax, %r8
movl %r12d, %eax
xorl %edx, %edx
divl %r9d
movl %r12d, %eax
movl %edx, 0x2c(%rsp)
subl %edx, %eax
movq %r8, 0x10(%rsp)
movq %r9, 0x20(%rsp)
je 0x3938
xorl %ebx, %ebx
movq %rax, 0x30(%rsp)
movl %r13d, %edi
addq %r8, %rdi
movl %ebx, %eax
xorl %edx, %edx
divl %r9d
leaq (,%rax,8), %rdx
addq 0x20(%r10), %rdx
movl %r14d, %esi
movq %r10, %rbp
callq 0x3515
movq 0x30(%rsp), %rax
movq %rbp, %r10
movl 0x4(%rsp), %ebp
movq 0x20(%rsp), %r9
movq 0x10(%rsp), %r8
incq %rbx
addl %ebp, %r13d
cmpq %rax, %rbx
jb 0x38f3
movl %r12d, %r13d
cmpl $0x0, 0x2c(%rsp)
movq %r10, %r11
movq %r14, %rsi
je 0x3993
movl %r12d, %eax
xorl %edx, %edx
divl %r9d
subl %edx, %r12d
movl %ebp, %edi
imull %r12d, %edi
addq %r8, %rdi
movl %r12d, %eax
xorl %edx, %edx
divl %r9d
leaq (,%rax,8), %rdx
addq 0x20(%r11), %rdx
movq %rsi, %r14
movq %r11, %rbx
callq 0x3515
movq 0x20(%rsp), %r9
movq %rbx, %r11
movq %r14, %rsi
movq 0x10(%rsp), %r8
incq %r12
cmpq %r13, %r12
jb 0x3953
cmpl $0x2, 0x8(%rsp)
jae 0x39a1
movl 0x1c(%rsp), %r10d
jmp 0x39d6
movl %esi, %eax
shrl $0x2, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movl %ebp, %r9d
movl 0x1c(%rsp), %r10d
cmpl $0x4, %esi
jb 0x39cb
movl %ecx, %r14d
addq %r8, %r14
xorl %edi, %edi
xorl (%r14,%rdi,4), %r15d
incq %rdi
cmpq %rdi, %rax
jne 0x39bf
incq %rdx
addl %r9d, %ecx
cmpq %r13, %rdx
jne 0x39b2
shrl %r10d
movl %r10d, 0x18(%r11)
movl %r15d, 0x28(%r11)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /HermanChen[P]mpp/utils/utils.c |
fill_MPP_FMT_ARGB8888 | static void fill_MPP_FMT_ARGB8888(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be)
{
// MPP_FMT_ARGB8888
// 32 bit pixel MSB --------> LSB
// (XXXX,XXXX,rrrr,rrrr,gggg,gggg,bbbb,bbbb)
// big endian | byte 0 | byte 1 | byte 2 | byte 3 |
// little endian | byte 3 | byte 2 | byte 1 | byte 0 |
if (be) {
p[0] = 0xff;
p[1] = R;
p[2] = G;
p[3] = B;
} else {
p[0] = B;
p[1] = G;
p[2] = R;
p[3] = 0xff;
}
} | xorl %eax, %eax
movl %r8d, %r9d
negl %r9d
movl $0x0, %r9d
sbbl %r9d, %r9d
orb %cl, %r9b
cmpl $0x1, %r8d
sbbl %eax, %eax
orb %cl, %al
testl %r8d, %r8d
movl %edx, %ecx
cmovel %esi, %ecx
cmovel %edx, %esi
movb %r9b, (%rdi)
movb %sil, 0x1(%rdi)
movb %cl, 0x2(%rdi)
movb %al, 0x3(%rdi)
retq
| /HermanChen[P]mpp/utils/utils.c |
get_extension | static void get_extension(const char *file_name, char *extension)
{
size_t length = strlen(file_name);
size_t ext_len = 0;
size_t i = 0;
const char *p = file_name + length - 1;
while (p >= file_name) {
if (p[0] == '.') {
for (i = 0; i < ext_len; i++)
extension[i] = tolower(p[i + 1]);
extension[i] = '\0';
return ;
}
ext_len++;
p--;
}
extension[0] = '\0';
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2090
movq %rax, %r14
addq %r15, %rax
decq %rax
cmpq %r15, %rax
jb 0x95c0
addq %r15, %r14
cmpb $0x2e, (%rax)
jne 0x9574
xorl %r12d, %r12d
jmp 0x9595
movq $-0x2, %rax
xorl %r12d, %r12d
leaq (%r14,%rax), %rcx
cmpq %r15, %rcx
jb 0x95c0
incq %r12
decq %rax
cmpb $0x2e, (%rcx)
jne 0x957e
subq %r12, %r14
testq %r12, %r12
je 0x95bd
xorl %r15d, %r15d
callq 0x2050
movq (%rax), %rcx
movsbq (%r14,%r15), %rdx
movb (%rcx,%rdx,4), %cl
movb %cl, (%rbx,%r15)
leaq 0x1(%r15), %rcx
movq %rcx, %r15
cmpq %rcx, %r12
jne 0x95a2
addq %r12, %rbx
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /HermanChen[P]mpp/utils/utils.c |
rga_copy(void*, void*, void*) | MPP_RET rga_copy(RgaCtx ctx, MppFrame src, MppFrame dst)
{
MPP_RET ret = MPP_OK;
RgaCtxImpl *impl = (RgaCtxImpl *)ctx;
MppBuffer src_buf = mpp_frame_get_buffer(src);
MppBuffer dst_buf = mpp_frame_get_buffer(dst);
RK_U32 src_w = mpp_frame_get_width(src);
RK_U32 src_h = mpp_frame_get_height(src);
RK_U32 dst_w = mpp_frame_get_width(dst);
RK_U32 dst_h = mpp_frame_get_height(dst);
RK_S32 src_fd = mpp_buffer_get_fd(src_buf);
RK_S32 dst_fd = mpp_buffer_get_fd(dst_buf);
RgaReq *request = &impl->request;
RgaFormat src_fmt = rga_fmt_map(mpp_frame_get_fmt(src));
RgaFormat dst_fmt = rga_fmt_map(mpp_frame_get_fmt(dst));
rga_dbg_func("in\n");
if (src_fmt >= RGA_FMT_BUTT || dst_fmt >= RGA_FMT_BUTT) {
mpp_err("invalid input format for rga process src %d dst %d\n",
src_fmt, dst_fmt);
ret = MPP_NOK;
goto END;
}
mpp_assert(src_w > 0 && src_h > 0);
if (dst_w == 0 || dst_h == 0) {
dst_w = src_w;
dst_h = src_h;
}
rga_dbg_copy("[fd:w:h:fmt] src - %d:%d:%d:%d dst - %d:%d:%d:%d\n",
src_fd, src_w, src_h, src_fmt,
dst_fd, dst_w, dst_h, dst_fmt);
memset(request, 0, sizeof(*request));
request->src.yrgb_addr = src_fd;
request->src.format = (RK_U32)src_fmt;
request->src.vir_w = mpp_frame_get_hor_stride(src);
request->src.vir_h = mpp_frame_get_ver_stride(src);
request->src.act_w = src_w;
request->src.act_h = src_h;
request->dst.yrgb_addr = dst_fd;
request->dst.vir_w = dst_w;
request->dst.vir_h = dst_h;
request->dst.format = (RK_U32)dst_fmt;
request->clip.xmin = 0;
request->clip.xmax = dst_w - 1;
request->clip.ymin = 0;
request->clip.ymax = dst_h - 1;
request->dst.act_w = dst_w;
request->dst.act_h = dst_h;
config_rga_yuv2rgb_mode(ctx);
request->mmu_info.mmu_en = 1;
request->mmu_info.mmu_flag = 1;
request->mmu_info.mmu_flag = ((2 & 0x3) << 4) | 1;
request->mmu_info.mmu_flag |= (1 << 31) | (1 << 10) | (1 << 8);
ret = rga_ioctl(impl);
END:
rga_dbg_func("out\n");
return ret;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2290
movq %rax, %r13
movq %r12, %rdi
callq 0x2290
movq %rax, %rbp
movq %r15, %rdi
callq 0x21e0
movl %eax, 0x10(%rsp)
movq %r15, %rdi
callq 0x2080
movl %eax, 0xc(%rsp)
movq %r12, %rdi
callq 0x21e0
movl %eax, 0x24(%rsp)
movq %r12, %rdi
callq 0x2080
movl %eax, 0x20(%rsp)
leaq 0x1f00(%rip), %r14 # 0xbc25
movq %r13, %rdi
movq %r14, %rsi
callq 0x2140
movl %eax, 0x1c(%rsp)
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2140
movl %eax, %ebp
movq %r15, %rdi
callq 0x22c0
movl %eax, %edi
callq 0x9f19
movl %eax, %r13d
movq %r12, %rdi
callq 0x22c0
movl %eax, %edi
callq 0x9f19
movl %eax, %r9d
cmpl $0x14, %r13d
setb %al
cmpl $0x14, %r9d
setb %cl
testb %cl, %al
jne 0x9da5
leaq 0x1eb0(%rip), %rdx # 0xbc2e
movl $0x2, %edi
xorl %esi, %esi
xorl %ecx, %ecx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x22e0
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, 0x14(%rsp)
movl %r9d, 0x18(%rsp)
cmpl $0x0, 0x10(%rsp)
setne %al
cmpl $0x0, 0xc(%rsp)
setne %cl
testb %cl, %al
jne 0x9dff
movl $0x136, (%rsp) # imm = 0x136
leaq 0x1e92(%rip), %rdx # 0xbc62
leaq 0x1ea9(%rip), %r8 # 0xbc80
leaq 0x1e47(%rip), %r9 # 0xbc25
movl $0x2, %edi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x22e0
movq 0x41eb(%rip), %rax # 0xdfe0
testb $0x10, 0x3(%rax)
jne 0x9f14
leaq 0x8(%rbx), %rdi
movl 0x24(%rsp), %ebp
testl %ebp, %ebp
sete %al
movl 0x20(%rsp), %r12d
testl %r12d, %r12d
sete %r14b
orb %al, %r14b
movl $0x128, %edx # imm = 0x128
xorl %esi, %esi
callq 0x20e0
movslq 0x1c(%rsp), %rax
movq %rax, 0x10(%rbx)
movl %r13d, 0x28(%rbx)
movq %r15, %rdi
callq 0x2110
movw %ax, 0x34(%rbx)
movq %r15, %rdi
callq 0x22a0
movw %ax, 0x36(%rbx)
movl 0x10(%rsp), %ecx
movw %cx, 0x2c(%rbx)
movl 0xc(%rsp), %edx
movw %dx, 0x2e(%rbx)
movslq 0x14(%rsp), %rax
movq %rax, 0x40(%rbx)
testb %r14b, %r14b
cmovnel %ecx, %ebp
movw %bp, 0x64(%rbx)
cmovnel %edx, %r12d
movw %r12w, 0x66(%rbx)
movl 0x18(%rsp), %edi
movl %edi, 0x58(%rbx)
xorl %ecx, %ecx
movw %cx, 0xb0(%rbx)
movl %ebp, %eax
decl %eax
movw %ax, 0xb2(%rbx)
movw %cx, 0xb4(%rbx)
movl %r12d, %eax
decl %eax
movw %ax, 0xb6(%rbx)
movw %bp, 0x5c(%rbx)
movw %r12w, 0x5e(%rbx)
movl 0x28(%rbx), %eax
movb $0x0, 0x102(%rbx)
movl %eax, %ecx
andl $-0x8, %ecx
cmpl $0x8, %ecx
sete %dl
cmpl $0x8, %edi
setb %sil
movb $0x1, %cl
testb %dl, %sil
jne 0x9ee7
cmpl $0x8, %eax
setae %al
andl $-0x8, %edi
cmpl $0x8, %edi
setne %dl
movb $0x20, %cl
orb %al, %dl
jne 0x9eed
movb %cl, 0x102(%rbx)
movb $0x1, 0x108(%rbx)
movl $0x80000521, 0x118(%rbx) # imm = 0x80000521
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9c72
callq 0x20f0
| /HermanChen[P]mpp/mpp/vproc/rga/rga.cpp |
ThreadPoolGetAttr | int ThreadPoolGetAttr(ThreadPool *tp, ThreadPoolAttr *out)
{
if (!tp || !out)
return EINVAL;
if (!tp->shutdown)
ithread_mutex_lock(&tp->mutex);
*out = tp->attr;
if (!tp->shutdown)
ithread_mutex_unlock(&tp->mutex);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1f43e
cmpq $0x0, -0x18(%rbp)
jne 0x1f447
movl $0x16, -0x4(%rbp)
jmp 0x1f493
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8c(%rax)
jne 0x1f45d
movq -0x10(%rbp), %rdi
callq 0x46d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1e0, %rsi # imm = 0x1E0
movl $0x28, %edx
callq 0x4370
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8c(%rax)
jne 0x1f48c
movq -0x10(%rbp), %rdi
callq 0x4400
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /pupnp[P]pupnp/upnp/src/threadutil/ThreadPool.c |
ThreadPoolSetAttr | int ThreadPoolSetAttr(ThreadPool *tp, ThreadPoolAttr *attr)
{
int retCode = 0;
ThreadPoolAttr temp;
int i = 0;
if (!tp)
return EINVAL;
ithread_mutex_lock(&tp->mutex);
if (attr)
temp = *attr;
else
TPAttrInit(&temp);
if (SetPolicyType(temp.schedPolicy) != 0) {
ithread_mutex_unlock(&tp->mutex);
return INVALID_POLICY;
}
tp->attr = temp;
/* add threads */
if (tp->totalThreads < tp->attr.minThreads) {
for (i = tp->totalThreads; i < tp->attr.minThreads; i++) {
retCode = CreateWorker(tp);
if (retCode != 0) {
break;
}
}
}
/* signal changes */
ithread_cond_signal(&tp->condition);
ithread_mutex_unlock(&tp->mutex);
if (retCode != 0)
/* clean up if the min threads could not be created */
ThreadPoolShutdown(tp);
return retCode;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x4c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1f4d1
movl $0x16, -0x4(%rbp)
jmp 0x1f5b9
movq -0x10(%rbp), %rdi
callq 0x46d0
cmpq $0x0, -0x18(%rbp)
je 0x1f4f5
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movl $0x28, %edx
callq 0x4370
jmp 0x1f4fe
leaq -0x48(%rbp), %rdi
callq 0x1e700
movl -0x28(%rbp), %edi
callq 0x1e780
cmpl $0x0, %eax
je 0x1f520
movq -0x10(%rbp), %rdi
callq 0x4400
movl $0x20000000, -0x4(%rbp) # imm = 0x20000000
jmp 0x1f5b9
movq -0x10(%rbp), %rdi
addq $0x1e0, %rdi # imm = 0x1E0
leaq -0x48(%rbp), %rsi
movl $0x28, %edx
callq 0x4370
movq -0x10(%rbp), %rax
movl 0x90(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1e0(%rcx), %eax
jge 0x1f58e
movq -0x10(%rbp), %rax
movl 0x90(%rax), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1e0(%rcx), %eax
jge 0x1f58c
movq -0x10(%rbp), %rdi
callq 0x1e910
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1f57f
jmp 0x1f58c
jmp 0x1f581
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x1f55c
jmp 0x1f58e
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x42f0
movq -0x10(%rbp), %rdi
callq 0x4400
cmpl $0x0, -0x1c(%rbp)
je 0x1f5b3
movq -0x10(%rbp), %rdi
callq 0x1ea40
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /pupnp[P]pupnp/upnp/src/threadutil/ThreadPool.c |
TPJobInit | int TPJobInit(ThreadPoolJob *job, start_routine func, void *arg)
{
if (!job || !func)
return EINVAL;
job->func = func;
job->arg = arg;
job->priority = DEFAULT_PRIORITY;
job->free_func = DEFAULT_FREE_ROUTINE;
return 0;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1f60e
cmpq $0x0, -0x18(%rbp)
jne 0x1f617
movl $0x16, -0x4(%rbp)
jmp 0x1f64c
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /pupnp[P]pupnp/upnp/src/threadutil/ThreadPool.c |
ixmlNamedNodeMap_item | IXML_Node *ixmlNamedNodeMap_item(
/* IN */ IXML_NamedNodeMap *nnMap,
/* IN */ unsigned long index)
{
IXML_Node *tempNode;
unsigned int i;
if (nnMap == NULL) {
return NULL;
}
if (index > ixmlNamedNodeMap_getLength(nnMap) - 1lu) {
return NULL;
}
tempNode = nnMap->nodeItem;
for (i = 0u; i < index && tempNode != NULL; ++i) {
tempNode = tempNode->nextSibling;
}
return tempNode;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x41314
movq $0x0, -0x8(%rbp)
jmp 0x41394
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x413a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x4133f
movq $0x0, -0x8(%rbp)
jmp 0x41394
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0x4136c
cmpq $0x0, -0x20(%rbp)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x41375
jmp 0x4138c
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x41351
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| /pupnp[P]pupnp/ixml/src/namedNodeMap.c |
ixmlNamedNodeMap_getLength | unsigned long ixmlNamedNodeMap_getLength(IXML_NamedNodeMap *nnMap)
{
IXML_Node *tempNode;
unsigned long length = 0lu;
if (nnMap != NULL) {
tempNode = nnMap->nodeItem;
for (length = 0lu; tempNode != NULL; ++length) {
tempNode = tempNode->nextSibling;
}
}
return length;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x413ed
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x413eb
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x413ca
jmp 0x413ed
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /pupnp[P]pupnp/ixml/src/namedNodeMap.c |
ixmlNamedNodeMap_addToNamedNodeMap | int ixmlNamedNodeMap_addToNamedNodeMap(
IXML_NamedNodeMap **nnMap, IXML_Node *add)
{
IXML_NamedNodeMap *traverse = NULL;
IXML_NamedNodeMap *p = NULL;
IXML_NamedNodeMap *newItem = NULL;
if (add == NULL) {
return IXML_SUCCESS;
}
if (*nnMap == NULL) {
/* nodelist is empty */
*nnMap = (IXML_NamedNodeMap *)malloc(sizeof(IXML_NamedNodeMap));
if (*nnMap == NULL) {
return IXML_INSUFFICIENT_MEMORY;
}
ixmlNamedNodeMap_init(*nnMap);
}
if ((*nnMap)->nodeItem == NULL) {
(*nnMap)->nodeItem = add;
} else {
traverse = *nnMap;
p = traverse;
while (traverse != NULL) {
p = traverse;
traverse = traverse->next;
}
newItem =
(IXML_NamedNodeMap *)malloc(sizeof(IXML_NamedNodeMap));
if (newItem == NULL) {
return IXML_INSUFFICIENT_MEMORY;
}
p->next = newItem;
newItem->nodeItem = add;
newItem->next = NULL;
}
return IXML_SUCCESS;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4147b
movl $0x0, -0x4(%rbp)
jmp 0x41550
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x414bb
movl $0x10, %edi
callq 0x4410
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x414af
movl $0x66, -0x4(%rbp)
jmp 0x41550
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x41170
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
jne 0x414d8
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
jmp 0x41549
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x41508
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x414eb
movl $0x10, %edi
callq 0x4410
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x41526
movl $0x66, -0x4(%rbp)
jmp 0x41550
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
| /pupnp[P]pupnp/ixml/src/namedNodeMap.c |
candella::loop() | void loop()
{
backlight_adjuster adjuster;
ambient_light sensor{config.light_sensor};
using steady_clock = std::chrono::system_clock;
std::multimap<steady_clock::time_point, action_type> timer_queue;
timer_queue.emplace(steady_clock::now(), action_type::BACKLIGHT_POLL);
int32_t curr_bright = 0;
int32_t new_bright = 0;
int32_t step_size = 0;
while (true)
{
std::this_thread::sleep_until(timer_queue.begin()->first);
if (timer_queue.begin()->second == action_type::BACKLIGHT_POLL)
{
// read the current ambient light value
auto ambient_light = sensor.poll();
std::cerr << "[info]: Ambient light value was " << ambient_light
<< "\n";
// read the current backlight value
curr_bright = adjuster.current_brightness();
std::cerr << "[info]: current brightness " << curr_bright << "\n";
// calculate the new brightness value
new_bright = config.desired_brightness(adjuster.max_brightness(),
ambient_light);
new_bright = std::max(new_bright, config.min_bright);
if (curr_bright != new_bright)
{
std::cerr << "[info]: Adjusting brightness to " << new_bright
<< "\n";
step_size = (new_bright - curr_bright) / config.fade_steps;
for (std::size_t i = 0; i < config.fade_steps; ++i)
{
timer_queue.emplace(steady_clock::now()
+ i * config.fade_time
/ config.fade_steps,
action_type::BACKLIGHT_FADE);
}
}
timer_queue.emplace(steady_clock::now() + config.poll_time,
action_type::BACKLIGHT_POLL);
}
else if (timer_queue.begin()->second == action_type::BACKLIGHT_FADE)
{
curr_bright += step_size;
if (step_size == 0 || curr_bright > new_bright)
curr_bright = new_bright;
adjuster.set_brightness(curr_bright);
if (curr_bright != new_bright)
{
timer_queue.emplace(steady_clock::now()
+ config.fade_time / config.fade_steps,
action_type::BACKLIGHT_FADE);
}
}
timer_queue.erase(timer_queue.begin());
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2d8, %rsp # imm = 0x2D8
leaq 0x38(%rsp), %rdi
callq 0x3ab0
leaq 0x3c42(%rip), %rsi # 0x7230
leaq 0x80(%rsp), %rdi
callq 0x3c82
leaq 0x58(%rsp), %rax
xorl %r14d, %r14d
movl %r14d, (%rax)
movq %r14, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %r14, 0x20(%rax)
callq 0x3040
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xc(%rsp), %rdx
movl %r14d, (%rdx)
leaq 0x50(%rsp), %rdi
callq 0x409a
movabsq $0x44b82fa09b5a53, %r12 # imm = 0x44B82FA09B5A53
leaq 0x10(%rsp), %r15
leaq 0x50(%rsp), %r13
movq $0x0, 0x20(%rsp)
xorl %ebx, %ebx
movq 0x68(%rsp), %rbp
callq 0x3040
movq 0x20(%rbp), %rcx
cmpq %rcx, %rax
jge 0x36aa
subq %rax, %rcx
jle 0x3659
movq %rcx, %rax
shrq $0x9, %rax
mulq %r12
shrq $0xb, %rdx
imulq $-0x3b9aca00, %rdx, %rax # imm = 0xC4653600
addq %rcx, %rax
movq %rdx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq %r15, %rdi
movq %r15, %rsi
callq 0x30a0
cmpl $-0x1, %eax
jne 0x3659
callq 0x3030
cmpl $0x4, (%rax)
je 0x368e
jmp 0x3659
movq 0x68(%rsp), %rax
movl 0x28(%rax), %eax
cmpl $0x1, %eax
je 0x38c3
testl %eax, %eax
jne 0x392c
movl $0x48, %edx
leaq 0x288(%rsp), %rdi
leaq 0x290(%rsp), %rsi
callq 0x32f0
leaq 0x80(%rsp), %rdi
callq 0x3e16
movsd %xmm0, 0x2d0(%rsp)
xorpd %xmm0, %xmm0
movq $-0x50, %rax
addsd 0x2d8(%rsp,%rax), %xmm0
addq $0x8, %rax
jne 0x36fe
divsd 0x18f3(%rip), %xmm0 # 0x5008
movsd %xmm0, 0x28(%rsp)
movl $0x20, %edx
movq 0x38c9(%rip), %rdi # 0x6ff0
leaq 0x1902(%rip), %rsi # 0x5030
callq 0x3210
movq 0x38b6(%rip), %rdi # 0x6ff0
movsd 0x28(%rsp), %xmm0
callq 0x32d0
movl $0x1, %edx
movq %rax, %rdi
leaq 0x194f(%rip), %rsi # 0x50a3
callq 0x3210
leaq 0x38(%rsp), %rdi
callq 0x3cdc
movl %eax, %ebx
movl $0x1b, %edx
movq 0x387f(%rip), %rdi # 0x6ff0
leaq 0x18d9(%rip), %rsi # 0x5051
callq 0x3210
movq 0x386c(%rip), %rdi # 0x6ff0
movl %ebx, %esi
callq 0x3330
movl $0x1, %edx
movq %rax, %rdi
leaq 0x1909(%rip), %rsi # 0x50a3
callq 0x3210
xorps %xmm0, %xmm0
cvtsi2sdl 0x4c(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x28(%rsp), %xmm0
mulsd 0x1854(%rip), %xmm0 # 0x5010
addsd 0x1854(%rip), %xmm0 # 0x5018
callq 0x3160
mulsd 0x30(%rsp), %xmm0
divsd 0x1849(%rip), %xmm0 # 0x5020
cvttsd2si %xmm0, %r14d
movl 0x3a72(%rip), %eax # 0x7254
cmpl %r14d, %eax
cmovgl %eax, %r14d
movl %r14d, %ebp
subl %ebx, %ebp
je 0x3891
movl $0x20, %edx
movq 0x37f0(%rip), %rdi # 0x6ff0
leaq 0x1866(%rip), %rsi # 0x506d
callq 0x3210
movq 0x37dd(%rip), %rdi # 0x6ff0
movl %r14d, %esi
callq 0x3330
movl $0x1, %edx
movq %rax, %rdi
leaq 0x1879(%rip), %rsi # 0x50a3
callq 0x3210
movslq %ebp, %rax
xorl %edx, %edx
divq 0x39ed(%rip) # 0x7228
movq %rax, 0x20(%rsp)
xorl %ebp, %ebp
callq 0x3040
movq %rax, %rcx
movq 0x39cf(%rip), %rax # 0x7220
imulq %rbp, %rax
xorl %edx, %edx
divq 0x39ca(%rip) # 0x7228
imulq $0xf4240, %rax, %rax # imm = 0xF4240
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movq %r13, %rdi
movq %r15, %rsi
leaq 0xc(%rsp), %rdx
callq 0x417e
incq %rbp
cmpq 0x3999(%rip), %rbp # 0x7228
jb 0x3842
callq 0x3040
imulq $0xf4240, 0x3977(%rip), %rcx # imm = 0xF4240
addq %rax, %rcx
movq %rcx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq %r13, %rdi
movq %r15, %rsi
leaq 0xc(%rsp), %rdx
callq 0x409a
jmp 0x392c
movq 0x20(%rsp), %rax
addl %eax, %ebx
cmpl %r14d, %ebx
cmovgel %r14d, %ebx
testl %eax, %eax
cmovel %r14d, %ebx
leaq 0x38(%rsp), %rdi
movl %ebx, %esi
callq 0x3d9c
cmpl %r14d, %ebx
jne 0x38ed
movl %r14d, %ebx
jmp 0x392c
callq 0x3040
movq %rax, %rcx
movq 0x3924(%rip), %rax # 0x7220
xorl %edx, %edx
divq 0x3923(%rip) # 0x7228
imulq $0xf4240, %rax, %rax # imm = 0xF4240
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movq %r13, %rdi
movq %r15, %rsi
leaq 0xc(%rsp), %rdx
callq 0x417e
movq 0x68(%rsp), %rsi
movq %r13, %rdi
callq 0x421a
jmp 0x3654
jmp 0x394a
jmp 0x394a
jmp 0x394a
jmp 0x394a
jmp 0x394a
jmp 0x394a
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x404a
leaq 0x80(%rsp), %rdi
callq 0x3080
jmp 0x3969
movq %rax, %rbx
movq 0x38(%rsp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3340
movq %rax, %rdi
callq 0x3ddc
| /skystrife[P]candela/src/candela.cpp |
void KDIS::KDataStream::Write<unsigned short>(unsigned short) | void KDataStream::Write( Type T )
{
KBOOL bSwapBytes = true;
if (m_MachineEndian == m_NetEndian)
bSwapBytes = false;
NetToDataType<Type> OctArray( T, bSwapBytes );
for( KUINT8 i = 0; i < sizeof T; ++i )
{
m_vBuffer.push_back( OctArray.m_Octs[i] );
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
movl %esi, %ebp
shrl $0x8, %ebp
cmpl 0x4(%rdi), %eax
movl %ebp, %eax
cmovel %esi, %eax
cmovnel %esi, %ebp
addq $0x8, %rbx
leaq 0xf(%rsp), %r14
movb %al, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26f3a
movb %bpl, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26f3a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/././../KDataStream.h |
KDIS::DATA_TYPE::TimeStamp::CalculateTimeStamp() | void TimeStamp::CalculateTimeStamp()
{
// Calculate the time by taking the minutes, seconds and milliseconds(if supported by os) since the hour and dividing them by 0.000001676
KINT32 iTs = 0;
#if defined( WIN32 ) | defined( WIN64 ) // Microsoft Windows
SYSTEMTIME now;
GetSystemTime( &now );
KFLOAT64 f = ( now.wMinute * 60 ) + now.wSecond + ( now.wMilliseconds / 1000.0 );
iTs = f / 0.00000167638;
#else
time_t aclock;
time( &aclock );
struct tm * newtime = localtime( &aclock );
iTs = newtime->tm_sec + ( newtime->tm_min * 60 );
iTs = iTs / 0.00000167638;
#endif
#if defined( linux ) // Linux -- Note: You need to include the rt library for clock_gettime.
// Add nano seconds
timespec ts;
clock_gettime( 0, &ts );
iTs += ts.tv_nsec / 1676.38;
#endif
m_TimeStampUnion.m_ui32Time = iTs;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x25330
movq %r14, %rdi
callq 0x252a0
imull $0x3c, 0x4(%rax), %ecx
addl (%rax), %ecx
cvtsi2sd %ecx, %xmm0
divsd 0x90981(%rip), %xmm0 # 0xbb940
movapd %xmm0, (%rsp)
leaq 0x18(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x25320
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%r14), %xmm0
divsd 0x90964(%rip), %xmm0 # 0xbb948
cvttpd2dq (%rsp), %xmm1
cvtdq2pd %xmm1, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl 0x8(%rbx), %ecx
andl $0x1, %ecx
leal (%rcx,%rax,2), %eax
movl %eax, 0x8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
| /jarvisfriends[P]KDIS/KDIS/DataTypes/TimeStamp.cpp |
KDIS::PDU::Designator_PDU::SetDesignatingEntityID(KDIS::DATA_TYPE::EntityIdentifier const&) | class KDIS_EXPORT SimulationIdentifier : public DataTypeBase
{
protected:
KUINT16 m_ui16SiteID;
KUINT16 m_ui16ApplicationID;
public:
static const KUINT16 SIMULATION_IDENTIFIER_SIZE = 4;
SimulationIdentifier();
SimulationIdentifier( KUINT16 SiteID, KUINT16 ApplicatonID );
SimulationIdentifier(KDataStream &stream) noexcept(false);
virtual ~SimulationIdentifier();
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::SetSiteID
// KDIS::DATA_TYPE::SimulationIdentifier::GetSiteID
// Description: Site ID.
// A site is defined as a facility, installation, organizational unit or a geographic
// location that has one or more simulation applications capable of participating in a
// distributed event. A facility, installation, organizational unit or geographic location
// may have multiple sites associated with it.
// Each site participating in an event (e.g., training exercise, experiment, test) shall be
// assigned a unique Site Number that is different from any other site that is part of the same event.
// A simulation site is a site that generates simulated objects based on simulated data. A live site
// is a site that is associated with producing live objects from live sources such as producing
// entities representing live aircraft flying in a live training range. A simulation associated
// with a live site may issue Live Entity PDUs (e.g., the TSPI PDU) for the live objects or may
// issue Entity State PDUs for them.
// Parameter: KUINT16 ID
//************************************
void SetSiteID( KUINT16 ID );
KUINT16 GetSiteID() const;
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::SetApplicationID
// KDIS::DATA_TYPE::SimulationIdentifier::GetApplicationID
// Description: Application ID.
// An application is defined as a software program that is used to generate and process
// distributed simulation data including live, virtual and constructive data.
// Each application participating in an event (e.g., training exercise) shall be
// assigned a unique Application Number for the site with which the application is associated.
// Parameter: KUINT16 ID
//************************************
void SetApplicationID( KUINT16 ID );
KUINT16 GetApplicationID() const;
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::GetAsString
// Description: Returns a string representation.
//************************************
virtual KString GetAsString() const;
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::Decode
// Description: Convert From Network Data.
// Parameter: KDataStream & stream
//************************************
virtual void Decode(KDataStream &stream) noexcept(false);
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::Encode
// Description: Convert To Network Data.
// Parameter: KDataStream & stream
//************************************
virtual KDataStream Encode() const;
virtual void Encode( KDataStream & stream ) const;
KBOOL operator == ( const SimulationIdentifier & Value ) const;
KBOOL operator != ( const SimulationIdentifier & Value ) const;
KBOOL operator < ( const SimulationIdentifier & Value ) const;
} | movl 0x8(%rsi), %eax
movl %eax, 0x30(%rdi)
movzwl 0xc(%rsi), %eax
movw %ax, 0x34(%rdi)
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Distributed_Emission_Regeneration/././../../DataTypes/./SimulationIdentifier.h |
KDIS::PDU::Designator_PDU::GetAsString[abi:cxx11]() const | KString Designator_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Designator PDU-\n"
<< "Designating Entity ID:\n"
<< IndentString( m_DesignatingEntityID.GetAsString(), 1 )
<< "Code Name: " << m_ui16CodeName << "\n"
<< "Designated Entity ID:\n"
<< IndentString( m_DesignatedEntityID.GetAsString(), 1 )
<< "Code: " << m_ui16Code << "\n"
<< "Power(watts): " << m_f32Power << "\n"
<< "Wave Length(microns): " << m_f32WaveLength << "\n"
<< "Spot Location(Entity): " << m_SpotRegardsToEntity.GetAsString()
<< "Spot World Location: " << m_SpotLocation.GetAsString()
<< "Dead Reckoning Algorithm: " << ( KUINT16 )m_ui8DeadReckoningAlgorithm << "\n"
<< "Entity Linear Acceleration: " << m_EntityLinearAcceleration.GetAsString();
return ss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x290, %rsp # imm = 0x290
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x108(%rsp), %rdi
callq 0x25250
leaq 0xa8(%rsp), %rdi
movq %r14, %rsi
callq 0x2b662
leaq 0x118(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
callq 0x253e0
movq %rax, %r15
leaq 0x901cf(%rip), %rsi # 0xbc3d5
movl $0x11, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x901cd(%rip), %rsi # 0xbc3e7
movl $0x17, %edx
movq %r15, %rdi
callq 0x253e0
leaq 0x28(%r14), %rsi
leaq 0xe8(%rsp), %rdi
callq 0x7f1d4
leaq 0x88(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x2c706
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0x90190(%rip), %rsi # 0xbc3ff
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
movzwl 0x38(%r14), %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r15
leaq 0x92833(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x90176(%rip), %rsi # 0xbc41d
movl $0x16, %edx
movq %r15, %rdi
callq 0x253e0
leaq 0x40(%r14), %rsi
leaq 0xc8(%rsp), %rdi
callq 0x7f1d4
leaq 0x68(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x2c706
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0x90141(%rip), %rsi # 0xbc434
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
movzwl 0x50(%r14), %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r15
leaq 0x927af(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x90127(%rip), %rsi # 0xbc452
movl $0x1d, %edx
movq %r15, %rdi
callq 0x253e0
cvtss2sd 0x54(%r14), %xmm0
movq %r15, %rdi
callq 0x254a0
movq %rax, %r15
leaq 0x92776(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x9010c(%rip), %rsi # 0xbc470
movl $0x1d, %edx
movq %r15, %rdi
callq 0x253e0
xorps %xmm0, %xmm0
cvtss2sd 0x58(%r14), %xmm0
movq %r15, %rdi
callq 0x254a0
movq %rax, %r15
leaq 0x9273a(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x900ee(%rip), %rsi # 0xbc48e
movl $0x1d, %edx
movq %r15, %rdi
callq 0x253e0
leaq 0x60(%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x877fa
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0x900d5(%rip), %rsi # 0xbc4ac
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x78(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x88048
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0x900bc(%rip), %rsi # 0xbc4ca
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
movzbl 0x98(%r14), %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r15
leaq 0x92691(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x9009f(%rip), %rsi # 0xbc4e8
movl $0x1d, %edx
movq %r15, %rdi
callq 0x253e0
addq $0xa0, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x877fa
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c497
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c4b2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c4cd
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c4e8
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c509
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c52a
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xf8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c54b
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c56c
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x120(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0x108a35(%rip), %rsi # 0x134fb8
leaq 0x108(%rsp), %rdi
callq 0x25280
leaq 0x188(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x290, %rsp # imm = 0x290
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2c5e6
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c5fe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
jmp 0x2c5fe
jmp 0x2c5fb
jmp 0x2c5ee
jmp 0x2c63b
movq %rax, %rbx
jmp 0x2c659
jmp 0x2c636
movq %rax, %rbx
jmp 0x2c69b
jmp 0x2c5f3
movq %rax, %rbx
jmp 0x2c6dd
movq %rax, %rbx
jmp 0x2c619
movq %rax, %rbx
jmp 0x2c6bc
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c619
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c63e
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x25390
jmp 0x2c63e
movq %rax, %rbx
jmp 0x2c67a
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c659
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c67a
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c69b
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xf8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c6bc
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c6dd
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x1088d4(%rip), %rsi # 0x134fb8
leaq 0x108(%rsp), %rdi
callq 0x25280
leaq 0x188(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Distributed_Emission_Regeneration/Designator_PDU.cpp |
KDIS::PDU::LE_Fire_PDU::operator==(KDIS::PDU::LE_Fire_PDU const&) const | KBOOL LE_Fire_PDU::operator == ( const LE_Fire_PDU & Value ) const
{
if( LE_Header::operator != ( Value ) ) return false;
if( m_FireFlagUnion.m_ui8Flag != Value.m_FireFlagUnion.m_ui8Flag ) return false;
if( m_TargetID != Value.m_TargetID ) return false;
if( m_MunitionID != Value.m_MunitionID ) return false;
if( m_EventID != Value.m_EventID ) return false;
if( m_MunitionDesc != Value.m_MunitionDesc ) return false;
if( m_Loc != Value.m_Loc ) return false;
if( m_Vel != Value.m_Vel ) return false;
if( m_ui16Range != Value.m_ui16Range ) return false;
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x49236
testb %al, %al
jne 0x48cbc
movb 0x38(%r14), %al
cmpb 0x38(%rbx), %al
jne 0x48cbc
leaq 0x40(%r14), %rdi
leaq 0x40(%rbx), %rsi
callq 0x98bca
testb %al, %al
jne 0x48cbc
leaq 0x50(%r14), %rdi
leaq 0x50(%rbx), %rsi
callq 0x98bca
testb %al, %al
jne 0x48cbc
leaq 0x60(%r14), %rdi
leaq 0x60(%rbx), %rsi
callq 0x98bca
testb %al, %al
jne 0x48cbc
leaq 0x70(%r14), %rdi
leaq 0x70(%rbx), %rsi
callq 0x83990
testb %al, %al
jne 0x48cbc
movl $0x90, %esi
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0xa5e06
testb %al, %al
jne 0x48cbc
movl $0xd0, %esi
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0x9a556
testb %al, %al
je 0x48cc6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movzwl 0x108(%r14), %eax
cmpw 0x108(%rbx), %ax
sete %al
jmp 0x48cbe
| /jarvisfriends[P]KDIS/KDIS/PDU/Live_Entity/LE_Fire_PDU.cpp |
KDIS::PDU::LE_Header::Decode(KDIS::KDataStream&, bool) | void LE_Header::Decode(KDataStream &stream, bool ignoreHeader /*= true*/ ) noexcept(false)
{
if( ( stream.GetBufferSize() + ( ignoreHeader ? Header::HEADER6_PDU_SIZE : 0 ) ) < LE_HEADER_SIZE )throw KException( __FUNCTION__, NOT_ENOUGH_DATA_IN_BUFFER );
Header::Decode( stream, ignoreHeader );
stream >> KDIS_STREAM m_EntID;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26758
movzwl %ax, %eax
testl %ebp, %ebp
movl $0xc, %ecx
cmovel %ebp, %ecx
addl %eax, %ecx
cmpl $0xf, %ecx
jbe 0x490fb
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ba26
movq 0x28(%r14), %rax
addq $0x28, %r14
movq 0x18(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl $0x30, %edi
callq 0x25180
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x726cc(%rip), %rsi # 0xbb7e4
leaq 0x726cb(%rip), %rdx # 0xbb7ea
leaq 0x8(%rsp), %rdi
callq 0x2652e
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x2746c
xorl %ebp, %ebp
leaq 0xd9a29(%rip), %rsi # 0x122b70
leaq -0x22262(%rip), %rdx # 0x26eec
movq %rbx, %rdi
callq 0x25500
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x49170
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
testb %bpl, %bpl
jne 0x4917a
jmp 0x49182
movq %rax, %r14
movq %rbx, %rdi
callq 0x25270
movq %r14, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Live_Entity/LE_Header.cpp |
KDIS::PDU::TSPI_PDU::TSPI_PDU() | TSPI_PDU::TSPI_PDU() :
m_ui8SSDLen( 0 )
{
m_ui8PDUType = TSPI_PDU_Type;
m_ui16PDULength = TSPI_PDU_SIZE;
m_TSPIFlagUnion.m_ui8Flag = 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x48ce4
leaq 0xdaad3(%rip), %rax # 0x123d30
movq %rax, (%rbx)
leaq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0xa5750
leaq 0x80(%rbx), %r15
movq %r15, %rdi
movq %r14, 0x10(%rsp)
callq 0x99ef4
leaq 0xb8(%rbx), %r12
movq %r12, %rdi
callq 0x98bf4
leaq 0xf0(%rbx), %rbp
movq %rbp, %rdi
callq 0xa2fa8
leaq 0x118(%rbx), %r13
movq %r13, %rdi
callq 0xa1524
leaq 0x150(%rbx), %r14
movq %r14, %rdi
callq 0x982c8
leaq 0x1d0(%rbx), %rdi
callq 0x9634c
xorl %eax, %eax
movb %al, 0x1e0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1e8(%rbx)
movq $0x0, 0x1f8(%rbx)
movb $0x2e, 0xa(%rbx)
movw $0x19, 0x20(%rbx)
movb %al, 0x38(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0x98424
jmp 0x49315
movq %rax, 0x8(%rsp)
movq %r13, %rdi
callq 0xa1690
jmp 0x49324
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
callq 0xa30ba
jmp 0x49333
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x98d5a
jmp 0x49342
movq %rax, 0x8(%rsp)
movq %r15, %rdi
callq 0x9a060
movq 0x10(%rsp), %rdi
callq 0xa58c8
movq %rbx, %rdi
callq 0x48eb0
movq 0x8(%rsp), %rdi
callq 0x25530
movq %rax, 0x8(%rsp)
jmp 0x4934a
movq %rax, 0x8(%rsp)
jmp 0x49354
| /jarvisfriends[P]KDIS/KDIS/PDU/Live_Entity/TSPI_PDU.cpp |
KDIS::PDU::TSPI_PDU::SetEntityLinearVelocityFlag(bool) | void TSPI_PDU::SetEntityLinearVelocityFlag( KBOOL F )
{
if( ( KUINT8 )F == m_TSPIFlagUnion.m_ui8LinVel )return;
m_TSPIFlagUnion.m_ui8LinVel = F;
if( F )
{
m_ui16PDULength += LE_Vector16_3::LE_VECTOR_SIZE;
}
else
{
m_ui16PDULength -= LE_Vector16_3::LE_VECTOR_SIZE;
}
} | movb 0x38(%rdi), %al
movl %eax, %ecx
andb $0x1, %cl
cmpb %sil, %cl
je 0x49843
andb $-0x2, %al
orb %sil, %al
testb %sil, %sil
movl $0x6, %ecx
movl $0xfffa, %edx # imm = 0xFFFA
cmovnel %ecx, %edx
movb %al, 0x38(%rdi)
addw %dx, 0x20(%rdi)
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Live_Entity/TSPI_PDU.cpp |
KDIS::PDU::TSPI_PDU::SetEntityOrientationFlag(bool) | void TSPI_PDU::SetEntityOrientationFlag( KBOOL F )
{
if( ( KUINT8 )F == m_TSPIFlagUnion.m_ui8Ori )return;
m_TSPIFlagUnion.m_ui8Ori = F;
if( F )
{
m_ui16PDULength += LE_EulerAngles::LE_EULER_ANGLES_SIZE;
}
else
{
m_ui16PDULength -= LE_EulerAngles::LE_EULER_ANGLES_SIZE;
}
} | movb 0x38(%rdi), %al
testb $0x2, %al
sete %cl
xorb %sil, %cl
jne 0x49875
leal (%rsi,%rsi), %ecx
andb $-0x3, %al
orb %cl, %al
testb %sil, %sil
movl $0x3, %ecx
movl $0xfffd, %edx # imm = 0xFFFD
cmovnel %ecx, %edx
movb %al, 0x38(%rdi)
addw %dx, 0x20(%rdi)
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Live_Entity/TSPI_PDU.cpp |
KDIS::PDU::Service_Request_PDU::Encode(KDIS::KDataStream&) const | void Service_Request_PDU::Encode( KDataStream & stream ) const
{
Logistics_Header::Encode( stream );
stream << m_ui8ServiceTypeRequested
<< m_ui8NumSupplyTypes
<< m_ui16Padding1;
vector<Supplies>::const_iterator citr = m_vSupplies.begin();
vector<Supplies>::const_iterator citrEnd = m_vSupplies.end();
// Add supplies to the stream
for( ; citr != citrEnd; ++citr )
{
citr->Encode( stream );
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0xb1fd4
movzbl 0x68(%r15), %esi
movq %rbx, %rdi
callq 0x26a4c
movzbl 0x48(%r15), %esi
movq %rbx, %rdi
callq 0x26a4c
movzwl 0x4a(%r15), %esi
movq %rbx, %rdi
callq 0x29f54
movq 0x50(%r15), %r14
movq 0x58(%r15), %r15
cmpq %r15, %r14
je 0x4d6f2
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x28(%rax)
addq $0x18, %r14
jmp 0x4d6db
popq %rbx
popq %r14
popq %r15
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Logistics/Service_Request_PDU.cpp |
KDIS::PDU::Minefield_Data_PDU::Minefield_Data_PDU() | Minefield_Data_PDU::Minefield_Data_PDU() :
m_ui8ReqID( 0 ),
m_ui8PduSeqNum( 0 ),
m_ui8NumPdus( 0 ),
m_ui8NumMines( 0 ),
m_ui8NumSensTyp( 0 ),
m_ui8Padding1( 0 )
{
m_ui8PDUType = MinefieldData_PDU_Type;
m_ui16PDULength = MINEFIELD_DATA_PDU_SIZE;
m_SeqNumUnion.m_ui16SeqNum = 0;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x50eac
leaq 0xd67d5(%rip), %rax # 0x123ff0
movq %rax, (%rbx)
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x7f104
leaq 0x50(%rbx), %r12
movw $0x0, 0x4e(%rbx)
movl $0x0, 0x4a(%rbx)
movq %r12, %rdi
callq 0x9f8a4
leaq 0x60(%rbx), %rdi
callq 0x7fc18
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0x80(%rbx)
movups %xmm0, 0x70(%rbx)
movb $0x27, 0xa(%rbx)
movw $0x2c, 0x20(%rbx)
movw $0x0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r12, %rdi
callq 0x9f98c
jmp 0x4d88d
movq %rax, %r15
movq %r14, %rdi
callq 0x7f1aa
jmp 0x4d89a
movq %rax, %r15
movq %rbx, %rdi
callq 0x51078
movq %r15, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Minefield/Minefield_Data_PDU.cpp |
KDIS::PDU::Minefield_Data_PDU::Minefield_Data_PDU(KDIS::DATA_TYPE::EntityIdentifier const&, KDIS::DATA_TYPE::EntityIdentifier const&, unsigned short, unsigned char, unsigned char, unsigned char, KDIS::DATA_TYPE::MinefieldDataFilter const&, KDIS::DATA_TYPE::EntityType const&) | Minefield_Data_PDU::Minefield_Data_PDU( const EntityIdentifier & MinefieldID, const EntityIdentifier & RequestingSimulationID,
KUINT16 SeqNum, KUINT8 RequestID, KUINT8 PduSeqNum, KUINT8 NumPdus,
const MinefieldDataFilter & DF, const EntityType & MineType ) :
m_ReqID( RequestingSimulationID ),
m_ui8ReqID( RequestID ),
m_ui8PduSeqNum( PduSeqNum ),
m_ui8NumPdus( NumPdus ),
m_DataFilter( DF ),
m_MineTyp( MineType ),
m_ui8NumMines( 0 ),
m_ui8NumSensTyp( 0 ),
m_ui8Padding1( 0 )
{
m_ui8PDUType = MinefieldData_PDU_Type;
m_ui16PDULength = MINEFIELD_DATA_PDU_SIZE;
m_SeqNumUnion.m_ui16SeqNum15 = SeqNum;
m_MinefieldID = MinefieldID;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r12d
movl %ecx, %r15d
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
callq 0x50eac
leaq 0xd657f(%rip), %rax # 0x123ff0
movq %rax, (%rbx)
leaq 0xd84d5(%rip), %rax # 0x125f50
addq $0x10, %rax
movq %rax, 0x38(%rbx)
movl 0x8(%r13), %eax
movl %eax, 0x40(%rbx)
leaq 0xd815f(%rip), %rax # 0x125bf0
addq $0x10, %rax
movq %rax, 0x38(%rbx)
movzwl 0xc(%r13), %eax
movw %ax, 0x44(%rbx)
movb %r12b, 0x4a(%rbx)
movb %bpl, 0x4b(%rbx)
movb 0x40(%rsp), %al
movb %al, 0x4c(%rbx)
movw $0x0, 0x4d(%rbx)
movb $0x0, 0x4f(%rbx)
leaq 0xd973e(%rip), %rax # 0x127200
addq $0x10, %rax
movq %rax, 0x50(%rbx)
movq 0x48(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x58(%rbx)
leaq 0xd81c4(%rip), %rax # 0x125ca0
addq $0x10, %rax
movq %rax, 0x60(%rbx)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x68(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x80(%rbx)
movups %xmm0, 0x90(%rbx)
movb $0x27, 0xa(%rbx)
movw $0x2c, 0x20(%rbx)
movzwl 0x48(%rbx), %eax
andl $0x1, %eax
leal (%rax,%r15,2), %eax
movw %ax, 0x48(%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x30(%rbx)
movzwl 0xc(%r14), %eax
movw %ax, 0x34(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Minefield/Minefield_Data_PDU.cpp |
KDIS::PDU::Minefield_Data_PDU::AddMine(KDIS::DATA_TYPE::Mine const&) | void Minefield_Data_PDU::AddMine(const Mine &M) noexcept(false)
{
// First check the mine has the same optional fields set as MinefieldDataFilter.
if( M.MinefieldDataFilter::operator != ( m_DataFilter ) )
{
throw KException( __FUNCTION__, INVALID_OPERATION, "The Mine filter does not match the PDU MinefieldDataFilter. \
All mines must have the same optional values set as specified by \
the PDU MinefieldDataFilter. This mine has been ignored." );
}
m_vMines.push_back( M );
m_ui16PDULength += M.GetLength();
++m_ui8NumMines;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rdi), %rsi
movq %r14, %rdi
callq 0x9fe3e
testb %al, %al
jne 0x4dcf5
leaq 0x88(%rbx), %rdi
movq %r14, %rsi
callq 0x4f98a
movq %r14, %rdi
callq 0x9e2b6
addw %ax, 0x20(%rbx)
incb 0x4d(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x25180
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6ff02(%rip), %rsi # 0xbdc14
leaq 0x6ff02(%rip), %rdx # 0xbdc1b
leaq 0x8(%rsp), %rdi
callq 0x2652e
movb $0x1, %bpl
leaq 0x6feef(%rip), %rcx # 0xbdc1c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0xa, %edx
callq 0x30544
xorl %ebp, %ebp
leaq 0xd4e28(%rip), %rsi # 0x122b70
leaq -0x26e63(%rip), %rdx # 0x26eec
movq %rbx, %rdi
callq 0x25500
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4dd71
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
testb %bpl, %bpl
jne 0x4dd7b
jmp 0x4dd83
movq %rax, %r14
movq %rbx, %rdi
callq 0x25270
movq %r14, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Minefield/Minefield_Data_PDU.cpp |
KDIS::UTILS::IndentString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned short, char) | static inline KString IndentString( const KString & S, KUINT16 Tabs = 1, KCHAR8 Tab = '\t' )
{
KStringStream NewS;
// Add tab to first item and then check all new lines
AddTabsToStringStream( NewS, Tabs, Tab );
for( KUINT16 i = 0; i < S.size(); ++i )
{
if( S.c_str()[i] == '\n' && i != ( S.size() - 1 ) )
{
NewS << S.c_str()[i];
AddTabsToStringStream( NewS, Tabs, Tab );
}
else
{
NewS << S.c_str()[i];
}
}
return NewS.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25250
leaq 0x18(%rsp), %r15
leaq 0x7(%rsp), %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x253e0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x5202e
movw $0x1, %r13w
xorl %ecx, %ecx
leaq 0x7(%rsp), %r12
movq (%r14), %rdx
movb (%rdx,%rcx), %dl
cmpb $0xa, %dl
setne %sil
decq %rax
cmpq %rcx, %rax
sete %al
orb %sil, %al
je 0x51ff4
movb %dl, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
jmp 0x5201e
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
movb $0x9, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
movzwl %r13w, %ecx
movq 0x8(%r14), %rax
incl %r13d
cmpq %rcx, %rax
ja 0x51fc3
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0xe2f76(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5206c
movq %rax, %rbx
movq 0xe2f42(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Minefield/./././.././././.././Extras/KUtils.h |
KDIS::PDU::Minefield_State_PDU::GetAsString[abi:cxx11]() const | KString Minefield_State_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Minefield State PDU-\n"
<< Minefield_Header::GetAsString()
<< "Sequence Number: " << m_SeqNumUnion.m_ui16SeqNum15 << "\n"
<< "Force ID: " << GetEnumAsStringForceID( m_ui8ForceID ) << "\n"
<< "Number Perim Points: " << ( KUINT16 )m_ui8NumPerimPoints << "\n"
<< "Minefield Type: " << m_MinefieldType.GetAsString()
<< "Number Mine Types: " << m_ui16NumMineTypes << "\n"
<< "Minefield Location: " << m_Loc.GetAsString()
<< "Orientation: " << m_Ori.GetAsString()
<< m_App.GetAsString()
<< "Protocol Mode: " << GetEnumAsStringMinefieldProtocolMode( m_ui16ProtocolModeUnion.m_ui16ProtocolMode2 ) << "\n"
<< "Perimeter Points:\n";
std::vector<PerimeterPointCoordinate>::const_iterator citrPnt = m_vPoints.begin();
std::vector<PerimeterPointCoordinate>::const_iterator citrEndPnt = m_vPoints.end();
for( ; citrPnt != citrEndPnt; ++citrPnt )
{
ss << IndentString( citrPnt->GetAsString(), 1 );
}
ss << "Mine Types:\n";
std::vector<EntityType>::const_iterator citrTyp = m_vMineTypes.begin();
std::vector<EntityType>::const_iterator citrEndTyp = m_vMineTypes.end();
for( ; citrTyp != citrEndTyp; ++citrTyp )
{
ss << IndentString( citrTyp->GetAsString(), 1 );
}
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x110(%rsp), %rdi
callq 0x25250
movq %rsp, %rdi
movq %r15, %rsi
callq 0x2b662
leaq 0x120(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x253e0
movq %rax, %r12
leaq 0x6a8fa(%rip), %rsi # 0xbe205
movl $0x16, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x510e2
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x6a8db(%rip), %rsi # 0xbe21c
movl $0x15, %edx
movq %rax, %rdi
callq 0x253e0
movzwl 0x38(%r15), %esi
shrl %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x6b15f(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x6a8b7(%rip), %rsi # 0xbe232
movl $0x15, %edx
movq %r12, %rdi
callq 0x253e0
movzbl 0x3a(%r15), %esi
leaq 0xf0(%rsp), %rdi
callq 0xafe45
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x6b10a(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x6a878(%rip), %rsi # 0xbe248
movl $0x15, %edx
movq %r12, %rdi
callq 0x253e0
movzbl 0x3b(%r15), %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x6b0d2(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x6a856(%rip), %rsi # 0xbe25e
movl $0x15, %edx
movq %r12, %rdi
callq 0x253e0
leaq 0x40(%r15), %rsi
leaq 0xd0(%rsp), %rdi
callq 0x800ac
movq 0xd0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x6a82c(%rip), %rsi # 0xbe274
movl $0x15, %edx
movq %rax, %rdi
callq 0x253e0
movzwl 0x50(%r15), %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x6b05a(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x6a80a(%rip), %rsi # 0xbe28a
movl $0x15, %edx
movq %r12, %rdi
callq 0x253e0
leaq 0x58(%r15), %rsi
leaq 0xb0(%rsp), %rdi
callq 0x88048
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x6a7e0(%rip), %rsi # 0xbe2a0
movl $0x15, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x78(%r15), %rsi
leaq 0x90(%rsp), %rdi
callq 0x80916
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x90(%r15), %rsi
leaq 0x70(%rsp), %rdi
callq 0x9f5d4
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x6a790(%rip), %rsi # 0xbe2b6
movl $0x15, %edx
movq %rax, %rdi
callq 0x253e0
movzwl 0xa0(%r15), %esi
andl $0x3, %esi
leaq 0x50(%rsp), %rdi
callq 0xb07d9
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x6af62(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x6a5c3(%rip), %rsi # 0xbe13b
movl $0x12, %edx
movq %r12, %rdi
callq 0x253e0
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53ba0
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53bc1
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53be2
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xc0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53c03
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xe0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53c24
movq 0xe0(%rsp), %rsi
incq %rsi
callq 0x25390
movq %rbx, 0x40(%rsp)
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53c4a
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x30(%rsp), %rbx
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x53c65
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x53c80
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0xa8(%r15), %r12
movq %r15, 0x48(%rsp)
movq 0xb0(%r15), %r15
cmpq %r15, %r12
je 0x53d04
leaq 0x20(%rsp), %r13
movq %rsp, %rbp
movq (%r12), %rax
movq %r13, %rdi
movq %r12, %rsi
callq *0x10(%rax)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x53f94
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x120(%rsp), %rdi
callq 0x253e0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x53ce4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbx, %rdi
je 0x53cfb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
addq $0x10, %r12
cmpq %r15, %r12
jne 0x53ca0
leaq 0x6a5c1(%rip), %rsi # 0xbe2cc
movl $0xc, %edx
leaq 0x120(%rsp), %rdi
callq 0x253e0
movq 0x48(%rsp), %rax
movq 0xc0(%rax), %r12
movq 0xc8(%rax), %rbp
cmpq %rbp, %r12
je 0x53da1
leaq 0x20(%rsp), %r15
movq %rsp, %r13
movq (%r12), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x10(%rax)
movq %r13, %rdi
movq %r15, %rsi
callq 0x53f94
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x120(%rsp), %rdi
callq 0x253e0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x53d81
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbx, %rdi
je 0x53d98
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
addq $0x10, %r12
cmpq %rbp, %r12
jne 0x53d3d
leaq 0x128(%rsp), %rsi
movq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x25480
movq 0xe11fb(%rip), %rsi # 0x134fb8
leaq 0x110(%rsp), %rdi
callq 0x25280
leaq 0x190(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x298, %rsp # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53f31
jmp 0x53f31
jmp 0x53e17
jmp 0x53dfa
movq %rax, %r15
jmp 0x53e68
jmp 0x53e1c
jmp 0x53eac
jmp 0x53ed7
jmp 0x53ed2
jmp 0x53e21
jmp 0x53f31
movq %rax, %r15
jmp 0x53e47
movq %rax, %r15
jmp 0x53e89
movq %rax, %r15
jmp 0x53f16
movq %rax, %r15
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53e47
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53e68
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53e89
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xc0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53eaf
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x25390
jmp 0x53eaf
movq %rax, %r15
leaq 0xe0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53eda
movq 0xe0(%rsp), %rsi
incq %rsi
callq 0x25390
jmp 0x53eda
movq %rax, %r15
jmp 0x53efb
movq %rax, %r15
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53efb
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53f16
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53f6b
movq 0x10(%rsp), %rsi
jmp 0x53f63
jmp 0x53f31
jmp 0x53f36
jmp 0x53f3b
movq %rax, %r15
jmp 0x53f6b
movq %rax, %r15
jmp 0x53f54
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x53f54
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbx, %rdi
je 0x53f6b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0xe1046(%rip), %rsi # 0x134fb8
leaq 0x110(%rsp), %rdi
callq 0x25280
leaq 0x190(%rsp), %rdi
callq 0x25120
movq %r15, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Minefield/Minefield_State_PDU.cpp |
KDIS::PDU::Signal_PDU::~Signal_PDU() | Signal_PDU::~Signal_PDU()
{
m_vData.clear();
} | pushq %rbx
movq %rdi, %rbx
leaq 0xced7f(%rip), %rax # 0x124200
movq %rax, (%rdi)
movq 0x58(%rdi), %rdi
cmpq %rdi, 0x60(%rbx)
je 0x55492
movq %rdi, 0x60(%rbx)
testq %rdi, %rdi
je 0x554a3
movq 0x68(%rbx), %rsi
subq %rdi, %rsi
callq 0x25390
leaq 0x40(%rbx), %rdi
callq 0x7e222
movq %rbx, %rdi
popq %rbx
jmp 0xb2296
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Radio_Communications/Signal_PDU.cpp |
KDIS::PDU::Signal_PDU::GetData(char*, unsigned short) const | void Signal_PDU::GetData(KOCTET *D, KUINT16 Length) const noexcept(false)
{
if( Length < m_ui16DataLength )throw KException( __FUNCTION__, BUFFER_TOO_SMALL );
// Only return the data, not any padding that may have been added.
KUINT16 uiDataSz = m_ui16DataLength / 8;
for( KUINT16 i = 0; i < uiDataSz; ++i )
{
D[i] = m_vData[i];
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movzwl 0x54(%rdi), %eax
cmpw %dx, %ax
ja 0x5555b
cmpw $0x8, %ax
jb 0x55550
shrl $0x3, %eax
xorl %ecx, %ecx
movq 0x58(%rdi), %rdx
movb (%rdx,%rcx), %dl
movb %dl, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x5553e
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x25180
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x68de5(%rip), %rsi # 0xbe35d
leaq 0x68de5(%rip), %rdx # 0xbe364
leaq 0x8(%rsp), %rdi
callq 0x2652e
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2746c
xorl %ebp, %ebp
leaq 0xcd5c9(%rip), %rsi # 0x122b70
leaq -0x2e6c2(%rip), %rdx # 0x26eec
movq %rbx, %rdi
callq 0x25500
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x555d0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
testb %bpl, %bpl
jne 0x555da
jmp 0x555e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x25270
movq %r14, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Radio_Communications/Signal_PDU.cpp |
KDIS::PDU::Signal_PDU::GetAsString[abi:cxx11]() const | KString Signal_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Signal PDU-\n"
<< Radio_Communications_Header::GetAsString()
<< m_EncodingScheme.GetAsString()
<< "Sample Rate: " << m_ui32SampleRate << "\n"
<< "Data Length: " << m_ui16DataLength << "\n"
<< "Samples: " << m_ui16Samples << "\n";
// Data is not printed as we don't know how to interpret the data.
// You could create a derived class and override the GetAsString
// if you wanted to interpret a particular type of data.
return ss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1f0, %rsp # imm = 0x1F0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
callq 0x25250
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x2b662
leaq 0x78(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x253e0
movq %rax, %r15
leaq 0x68d34(%rip), %rsi # 0xbe365
movl $0xd, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xb230c
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0x40(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x7e29e
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0x68ce9(%rip), %rsi # 0xbe373
movl $0x11, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x50(%r14), %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r15
leaq 0x69419(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x68cc4(%rip), %rsi # 0xbe385
movl $0x11, %edx
movq %r15, %rdi
callq 0x253e0
movzwl 0x54(%r14), %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r15
leaq 0x693e1(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x68c9e(%rip), %rsi # 0xbe397
movl $0x11, %edx
movq %r15, %rdi
callq 0x253e0
movzwl 0x56(%r14), %esi
movq %r15, %rdi
callq 0x25220
leaq 0x693ac(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55742
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5575d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55778
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0xdf829(%rip), %rsi # 0x134fb8
leaq 0x68(%rsp), %rdi
callq 0x25280
leaq 0xe8(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x1f0, %rsp # imm = 0x1F0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x557c1
jmp 0x557ba
movq %rax, %rbx
jmp 0x557e9
jmp 0x557c6
movq %rax, %rbx
jmp 0x5581f
movq %rax, %rbx
jmp 0x55804
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x557e9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55804
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5581f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0xdf792(%rip), %rsi # 0x134fb8
leaq 0x68(%rsp), %rdi
callq 0x25280
leaq 0xe8(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Radio_Communications/Signal_PDU.cpp |
KDIS::PDU::Signal_PDU::Decode(KDIS::KDataStream&, bool) | void Signal_PDU::Decode(KDataStream &stream, bool ignoreHeader /*= true*/ ) noexcept(false)
{
if( ( stream.GetBufferSize() + ( ignoreHeader ? Header::HEADER6_PDU_SIZE : 0 ) ) < SIGNAL_PDU_SIZE )throw KException( __FUNCTION__, NOT_ENOUGH_DATA_IN_BUFFER );
Radio_Communications_Header::Decode( stream, ignoreHeader );
stream >> KDIS_STREAM m_EncodingScheme
>> m_ui32SampleRate
>> m_ui16DataLength
>> m_ui16Samples;
KUINT16 dl = m_ui16DataLength / 8;
dl += ( dl % 4 == 0 ? 0 : ( 4 - dl % 4 ) ); // Add padding
for( KUINT16 i = 0; i < dl; ++i )
{
KOCTET o;
stream >> o;
m_vData.push_back( o );
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26758
movzwl %ax, %eax
testl %ebp, %ebp
movl $0xc, %ecx
cmovel %ebp, %ecx
addl %eax, %ecx
cmpl $0x1f, %ecx
jbe 0x5591d
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb257e
leaq 0x40(%r14), %rdi
movq 0x40(%r14), %rax
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x2b290
leaq 0x54(%r14), %rsi
movq %rbx, %rdi
callq 0x29ef0
leaq 0x56(%r14), %rsi
movq %rbx, %rdi
callq 0x29ef0
movzwl 0x54(%r14), %eax
shrl $0x3, %eax
movl %eax, %ecx
andl $0x3, %ecx
movl $0x4, %ebp
subl %ecx, %ebp
testl %ecx, %ecx
cmovel %ecx, %ebp
addw %ax, %bp
je 0x55910
leaq 0x58(%r14), %r15
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26aa4
movq 0x60(%r14), %rsi
cmpq 0x68(%r14), %rsi
je 0x55900
movb (%rsp), %al
movb %al, (%rsi)
incq 0x60(%r14)
jmp 0x5590b
movq %r15, %rdi
movq %r12, %rdx
callq 0x4ab0a
decw %bp
jne 0x558e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x25180
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x65eaa(%rip), %rsi # 0xbb7e4
leaq 0x65ea9(%rip), %rdx # 0xbb7ea
movq %rsp, %rdi
callq 0x2652e
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x2746c
xorl %ebp, %ebp
leaq 0xcd20b(%rip), %rsi # 0x122b70
leaq -0x2ea80(%rip), %rdx # 0x26eec
movq %rbx, %rdi
callq 0x25500
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5598d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
testb %bpl, %bpl
jne 0x55997
jmp 0x5599f
movq %rax, %r14
movq %rbx, %rdi
callq 0x25270
movq %r14, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Radio_Communications/Signal_PDU.cpp |
KDIS::PDU::Transmitter_PDU::Transmitter_PDU(KDIS::PDU::Header7 const&) | Transmitter_PDU::Transmitter_PDU( const Header & H ) :
Radio_Communications_Header( H ),
m_ui16Padding1( 0 ),
m_ui16AntennaPatternLength( 0 ),
m_ui8LengthOfModulationParam( 0 ),
m_ui16Padding2( 0 ),
m_ui8Padding3( 0 )
{
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0xb20a4
leaq 0xce4d6(%rip), %rax # 0x124258
movq %rax, (%rbx)
leaq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x83d10
movw $0x0, 0x52(%rbx)
leaq 0x58(%rbx), %r15
movq %r15, %rdi
callq 0x7992c
movw $0x0, 0x9a(%rbx)
leaq 0xb0(%rbx), %r13
movq %r13, %rdi
callq 0x82e9c
leaq 0xc0(%rbx), %rdi
callq 0x7ad18
xorl %eax, %eax
movb %al, 0xd0(%rbx)
movw $0x0, 0xd2(%rbx)
movb %al, 0xd4(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rbx)
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xf8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
movq %r13, %rdi
callq 0x82f64
jmp 0x55e10
movq %rax, %r12
movq %r15, %rdi
callq 0x79a5a
jmp 0x55e1d
movq %rax, %r12
movq %r14, %rdi
callq 0x83e26
jmp 0x55e2a
movq %rax, %r12
movq %rbx, %rdi
callq 0xb2296
movq %r12, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Radio_Communications/Transmitter_PDU.cpp |
KDIS::PDU::Transmitter_PDU::SetModulationType(KDIS::DATA_TYPE::ModulationType const&) | class KDIS_EXPORT ModulationType : public DataTypeBase
{
protected:
union
{
struct
{
KUINT16 m_ui16FreqHop : 1;
KUINT16 m_ui16PseudoNoise : 1;
KUINT16 m_ui16TimeHop : 1;
// Bits 3 - 15 TBD
};
KUINT16 m_ui16SpreadSpectrum;
};
KUINT16 m_ui16MajorModulationType;
KUINT16 m_ui16Detail;
KUINT16 m_ui16System;
public:
static const KUINT16 MODULATION_TYPE_SIZE = 8;
ModulationType();
ModulationType(KDataStream &stream) noexcept(false);
ModulationType( KBOOL FreqHop, KBOOL PseudoNoise, KBOOL TimeHop,
KUINT16 MajorModulation, KUINT16 Detail,
KUINT16 System );
virtual ~ModulationType();
//************************************
// FullName: KDIS::DATA_TYPE::ModulationType::SetSpreadSpectrum
// KDIS::DATA_TYPE::ModulationType::GetSpreadSpectrum
// Description: Spread Spectrum Boolean array.
// Parameter: KUINT16 SS, void
//************************************
void SetSpreadSpectrum( KUINT16 SS );
KUINT16 GetSpreadSpectrum() const;
//************************************
// FullName: KDIS::DATA_TYPE::ModulationType::SetFrequencyHop
// KDIS::DATA_TYPE::ModulationType::GetFrequencyHop
// Description: Spread Spectrum Boolean array value 0.
// Parameter: KBOOL FH, void
//************************************
void SetFrequencyHop( KBOOL FH );
KBOOL GetFrequencyHop() const;
//************************************
// FullName: KDIS::DATA_TYPE::ModulationType::SetPseudoNoise
// KDIS::DATA_TYPE::ModulationType::GetPseudoNoise
// Description: Spread Spectrum Boolean array value 1.
// Parameter: KBOOL PN, void
//************************************
void SetPseudoNoise( KBOOL PN );
KBOOL GetPseudoNoise() const;
//************************************
// FullName: KDIS::DATA_TYPE::ModulationType::SetTimeHop
// KDIS::DATA_TYPE::ModulationType::GetTimeHop
// Description: Spread Spectrum Boolean array value 2.
// Parameter: KBOOL TH, void
//************************************
void SetTimeHop( KBOOL TH );
KBOOL GetTimeHop() const;
//************************************
// FullName: KDIS::DATA_TYPE::ModulationType::GetMajorModulation
// Description: Major classification of the modulation type.
// Note: This value is set automatically from the SetDetails function.
//************************************
KDIS::DATA_TYPE::ENUMS::RadioMajorModulation GetMajorModulation() const;
//************************************
// FullName: KDIS::DATA_TYPE::ModulationType::GetMajorModulation
// Description: Determines major modulation param.
// Provides details information.
// Parameter: <various>
//************************************
void SetDetail( KDIS::DATA_TYPE::ENUMS::DetailAmplitude A );
void SetDetail( KDIS::DATA_TYPE::ENUMS::DetailAmplitudeAndAngle AA );
void SetDetail( KDIS::DATA_TYPE::ENUMS::DetailAngle A );
void SetDetail( KDIS::DATA_TYPE::ENUMS::DetailCombination C );
void SetDetail( KDIS::DATA_TYPE::ENUMS::DetailPulse P );
void SetDetail( KDIS::DATA_TYPE::ENUMS::DetailUnmodulated U );
void SetDetail( KDIS::DATA_TYPE::ENUMS::DetailCarrierPhaseShift CPS );
KUINT16 GetDetail() const;
//************************************
// FullName: KDIS::DATA_TYPE::ModulationType::SetSystem
// KDIS::DATA_TYPE::ModulationType::GetSystem
// Description: Specifies the interpretation of the
// modulation parameter field(s).
// Parameter: ModulationSystem S
//************************************
void SetSystem( KDIS::DATA_TYPE::ENUMS::ModulationSystem S );
KDIS::DATA_TYPE::ENUMS::ModulationSystem GetSystem() const;
//************************************
// FullName: KDIS::DATA_TYPE::ModulationType::GetAsString
// Description: Returns a string representation
//************************************
virtual KString GetAsString() const;
//************************************
// FullName: KDIS::DATA_TYPE::ModulationType::Decode
// Description: Convert From Network Data.
// Parameter: KDataStream & stream
//************************************
virtual void Decode(KDataStream &stream) noexcept(false);
//************************************
// FullName: KDIS::DATA_TYPE::ModulationType::Encode
// Description: Convert To Network Data.
// Parameter: KDataStream & stream
//************************************
virtual KDataStream Encode() const;
virtual void Encode( KDataStream & stream ) const;
KBOOL operator == ( const ModulationType & Value ) const;
KBOOL operator != ( const ModulationType & Value ) const;
} | movq 0x8(%rsi), %rax
movq %rax, 0xb8(%rdi)
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Radio_Communications/././../../DataTypes/ModulationType.h |
KDIS::PDU::Transmitter_PDU::Decode(KDIS::KDataStream&, bool) | void Transmitter_PDU::Decode(KDataStream &stream, bool ignoreHeader /*= true*/ ) noexcept(false)
{
if( ( stream.GetBufferSize() + ( ignoreHeader ? Header::HEADER6_PDU_SIZE : 0 ) ) < TRANSMITTER_PDU_SIZE )throw KException( __FUNCTION__, NOT_ENOUGH_DATA_IN_BUFFER );
Radio_Communications_Header::Decode( stream, ignoreHeader );
stream >> KDIS_STREAM m_RadioEntityType
>> m_ui8TransmitterState
>> m_ui8InputSource
>> m_ui16Padding1
>> KDIS_STREAM m_AntennaLocation
>> m_ui16AntennaPatternType
>> m_ui16AntennaPatternLength
>> m_ui64Freq
>> m_f32TransmitFreqBW
>> m_f32Power
>> KDIS_STREAM m_ModulationType
>> KDIS_STREAM m_CryptoSystem
>> m_ui8LengthOfModulationParam
>> m_ui16Padding2
>> m_ui8Padding3;
for( KUINT8 i = 0; i < m_ui8LengthOfModulationParam; ++i )
{
KOCTET o;
stream >> o;
m_vModulationParams.push_back( o );
}
for( KUINT16 i = 0; i < m_ui16AntennaPatternLength; ++i )
{
KOCTET o;
stream >> o;
m_vAntennaPattern.push_back( o );
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26758
movzwl %ax, %eax
testl %ebp, %ebp
movl $0xc, %ecx
cmovel %ebp, %ecx
addl %eax, %ecx
cmpl $0x67, %ecx
jbe 0x56eac
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb257e
leaq 0x40(%r14), %rdi
movq 0x40(%r14), %rax
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x26a8e
leaq 0x51(%r14), %rsi
movq %rbx, %rdi
callq 0x26a8e
leaq 0x52(%r14), %rsi
movq %rbx, %rdi
callq 0x29ef0
leaq 0x58(%r14), %rdi
movq 0x58(%r14), %rax
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0x98(%r14), %rsi
movq %rbx, %rdi
callq 0x29ef0
leaq 0x9a(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29ef0
leaq 0xa0(%r14), %rsi
movq %rbx, %rdi
callq 0x571be
leaq 0xa8(%r14), %rsi
movq %rbx, %rdi
callq 0x2cb90
leaq 0xac(%r14), %rsi
movq %rbx, %rdi
callq 0x2cb90
leaq 0xb0(%r14), %rdi
movq 0xb0(%r14), %rax
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0xc0(%r14), %rdi
movq 0xc0(%r14), %rax
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0xd0(%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26a8e
leaq 0xd2(%r14), %rsi
movq %rbx, %rdi
callq 0x29ef0
leaq 0xd4(%r14), %rsi
movq %rbx, %rdi
callq 0x26a8e
cmpb $0x0, 0xd0(%r14)
je 0x56e4e
leaq 0xd8(%r14), %rax
movq %rax, 0x20(%rsp)
xorl %r13d, %r13d
movq %rsp, %rbp
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x26aa4
movq 0xe0(%r14), %rsi
cmpq 0xe8(%r14), %rsi
je 0x56e38
movb (%rsp), %al
movb %al, (%rsi)
incq 0xe0(%r14)
jmp 0x56e45
movq 0x20(%rsp), %rdi
movq %rbp, %rdx
callq 0x4ab0a
incb %r13b
cmpb (%r12), %r13b
jb 0x56e0f
cmpw $0x0, (%r15)
je 0x56e9d
leaq 0xf0(%r14), %r12
xorl %ebp, %ebp
movq %rsp, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x26aa4
movq 0xf8(%r14), %rsi
cmpq 0x100(%r14), %rsi
je 0x56e8a
movb (%rsp), %al
movb %al, (%rsi)
incq 0xf8(%r14)
jmp 0x56e95
movq %r12, %rdi
movq %r13, %rdx
callq 0x4ab0a
incl %ebp
cmpw (%r15), %bp
jb 0x56e61
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x25180
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6491b(%rip), %rsi # 0xbb7e4
leaq 0x6491a(%rip), %rdx # 0xbb7ea
movq %rsp, %rdi
callq 0x2652e
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x2746c
xorl %ebp, %ebp
leaq 0xcbc7c(%rip), %rsi # 0x122b70
leaq -0x3000f(%rip), %rdx # 0x26eec
movq %rbx, %rdi
callq 0x25500
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x56f1c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
testb %bpl, %bpl
jne 0x56f26
jmp 0x56f2e
movq %rax, %r14
movq %rbx, %rdi
callq 0x25270
movq %r14, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Radio_Communications/Transmitter_PDU.cpp |
void KDIS::KDataStream::Read<unsigned long long>(unsigned long long&) | void KDataStream::Read( Type & T )
{
NetToDataType<Type> OctArray( T, false );
// Copy octets into data type
for( KUINT8 i = 0; i < sizeof T; ++i, ++m_ui16CurrentWritePos )
{
OctArray.m_Octs[i] = m_vBuffer[m_ui16CurrentWritePos];
}
if( m_MachineEndian != m_NetEndian )
{
OctArray.SwapBytes();
}
T = OctArray.m_Value;
} | movq (%rsi), %rax
movq %rax, -0x8(%rsp)
movq 0x8(%rdi), %rax
movzwl 0x20(%rdi), %ecx
leal 0x1(%rcx), %edx
movzwl %dx, %edx
xorl %r9d, %r9d
xorl %r8d, %r8d
leal (%rcx,%r9), %r10d
movzwl %r10w, %r10d
movb (%rax,%r10), %r10b
movb %r10b, -0x8(%rsp,%r9)
incq %r8
addl %edx, %r9d
movw %r9w, 0x20(%rdi)
movq %r8, %r9
cmpq $0x8, %r8
jne 0x571da
movl (%rdi), %eax
cmpl 0x4(%rdi), %eax
je 0x5722d
movq -0x8(%rsp), %xmm0
pxor %xmm1, %xmm1
punpcklbw %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
pshufd $0x4e, %xmm0, %xmm0 # xmm0 = xmm0[2,3,0,1]
pshuflw $0x1b, %xmm0, %xmm0 # xmm0 = xmm0[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm0, %xmm0 # xmm0 = xmm0[0,1,2,3,7,6,5,4]
packuswb %xmm0, %xmm0
movq %xmm0, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, (%rsi)
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Radio_Communications/./././.././././../KDataStream.h |
void KDIS::KDataStream::Write<unsigned long long>(unsigned long long) | void KDataStream::Write( Type T )
{
KBOOL bSwapBytes = true;
if (m_MachineEndian == m_NetEndian)
bSwapBytes = false;
NetToDataType<Type> OctArray( T, bSwapBytes );
for( KUINT8 i = 0; i < sizeof T; ++i )
{
m_vBuffer.push_back( OctArray.m_Octs[i] );
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
cmpl 0x4(%rdi), %eax
jne 0x57250
movq %rsi, %xmm0
jmp 0x57270
movq %rsi, %xmm0
pxor %xmm1, %xmm1
punpcklbw %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
pshufd $0x4e, %xmm0, %xmm0 # xmm0 = xmm0[2,3,0,1]
pshuflw $0x1b, %xmm0, %xmm0 # xmm0 = xmm0[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm0, %xmm0 # xmm0 = xmm0[0,1,2,3,7,6,5,4]
packuswb %xmm0, %xmm0
movq %xmm0, 0x8(%rsp)
addq $0x8, %rbx
xorl %r15d, %r15d
leaq 0x7(%rsp), %r14
movb 0x8(%rsp,%r15), %al
movb %al, 0x7(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26f3a
incq %r15
cmpq $0x8, %r15
jne 0x57282
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
| /jarvisfriends[P]KDIS/KDIS/PDU/Radio_Communications/./././.././././../KDataStream.h |
KDIS::PDU::Intercom_Control_PDU::SetSourceEntityID(KDIS::DATA_TYPE::EntityIdentifier const&) | class KDIS_EXPORT SimulationIdentifier : public DataTypeBase
{
protected:
KUINT16 m_ui16SiteID;
KUINT16 m_ui16ApplicationID;
public:
static const KUINT16 SIMULATION_IDENTIFIER_SIZE = 4;
SimulationIdentifier();
SimulationIdentifier( KUINT16 SiteID, KUINT16 ApplicatonID );
SimulationIdentifier(KDataStream &stream) noexcept(false);
virtual ~SimulationIdentifier();
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::SetSiteID
// KDIS::DATA_TYPE::SimulationIdentifier::GetSiteID
// Description: Site ID.
// A site is defined as a facility, installation, organizational unit or a geographic
// location that has one or more simulation applications capable of participating in a
// distributed event. A facility, installation, organizational unit or geographic location
// may have multiple sites associated with it.
// Each site participating in an event (e.g., training exercise, experiment, test) shall be
// assigned a unique Site Number that is different from any other site that is part of the same event.
// A simulation site is a site that generates simulated objects based on simulated data. A live site
// is a site that is associated with producing live objects from live sources such as producing
// entities representing live aircraft flying in a live training range. A simulation associated
// with a live site may issue Live Entity PDUs (e.g., the TSPI PDU) for the live objects or may
// issue Entity State PDUs for them.
// Parameter: KUINT16 ID
//************************************
void SetSiteID( KUINT16 ID );
KUINT16 GetSiteID() const;
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::SetApplicationID
// KDIS::DATA_TYPE::SimulationIdentifier::GetApplicationID
// Description: Application ID.
// An application is defined as a software program that is used to generate and process
// distributed simulation data including live, virtual and constructive data.
// Each application participating in an event (e.g., training exercise) shall be
// assigned a unique Application Number for the site with which the application is associated.
// Parameter: KUINT16 ID
//************************************
void SetApplicationID( KUINT16 ID );
KUINT16 GetApplicationID() const;
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::GetAsString
// Description: Returns a string representation.
//************************************
virtual KString GetAsString() const;
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::Decode
// Description: Convert From Network Data.
// Parameter: KDataStream & stream
//************************************
virtual void Decode(KDataStream &stream) noexcept(false);
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::Encode
// Description: Convert To Network Data.
// Parameter: KDataStream & stream
//************************************
virtual KDataStream Encode() const;
virtual void Encode( KDataStream & stream ) const;
KBOOL operator == ( const SimulationIdentifier & Value ) const;
KBOOL operator != ( const SimulationIdentifier & Value ) const;
KBOOL operator < ( const SimulationIdentifier & Value ) const;
} | movl 0x8(%rsi), %eax
movl %eax, 0x40(%rdi)
movzwl 0xc(%rsi), %eax
movw %ax, 0x44(%rdi)
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Radio_Communications/././../../DataTypes/./SimulationIdentifier.h |
KDIS::PDU::Intercom_Control_PDU::SetMasterEntityID(KDIS::DATA_TYPE::EntityIdentifier const&) | class KDIS_EXPORT SimulationIdentifier : public DataTypeBase
{
protected:
KUINT16 m_ui16SiteID;
KUINT16 m_ui16ApplicationID;
public:
static const KUINT16 SIMULATION_IDENTIFIER_SIZE = 4;
SimulationIdentifier();
SimulationIdentifier( KUINT16 SiteID, KUINT16 ApplicatonID );
SimulationIdentifier(KDataStream &stream) noexcept(false);
virtual ~SimulationIdentifier();
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::SetSiteID
// KDIS::DATA_TYPE::SimulationIdentifier::GetSiteID
// Description: Site ID.
// A site is defined as a facility, installation, organizational unit or a geographic
// location that has one or more simulation applications capable of participating in a
// distributed event. A facility, installation, organizational unit or geographic location
// may have multiple sites associated with it.
// Each site participating in an event (e.g., training exercise, experiment, test) shall be
// assigned a unique Site Number that is different from any other site that is part of the same event.
// A simulation site is a site that generates simulated objects based on simulated data. A live site
// is a site that is associated with producing live objects from live sources such as producing
// entities representing live aircraft flying in a live training range. A simulation associated
// with a live site may issue Live Entity PDUs (e.g., the TSPI PDU) for the live objects or may
// issue Entity State PDUs for them.
// Parameter: KUINT16 ID
//************************************
void SetSiteID( KUINT16 ID );
KUINT16 GetSiteID() const;
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::SetApplicationID
// KDIS::DATA_TYPE::SimulationIdentifier::GetApplicationID
// Description: Application ID.
// An application is defined as a software program that is used to generate and process
// distributed simulation data including live, virtual and constructive data.
// Each application participating in an event (e.g., training exercise) shall be
// assigned a unique Application Number for the site with which the application is associated.
// Parameter: KUINT16 ID
//************************************
void SetApplicationID( KUINT16 ID );
KUINT16 GetApplicationID() const;
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::GetAsString
// Description: Returns a string representation.
//************************************
virtual KString GetAsString() const;
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::Decode
// Description: Convert From Network Data.
// Parameter: KDataStream & stream
//************************************
virtual void Decode(KDataStream &stream) noexcept(false);
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::Encode
// Description: Convert To Network Data.
// Parameter: KDataStream & stream
//************************************
virtual KDataStream Encode() const;
virtual void Encode( KDataStream & stream ) const;
KBOOL operator == ( const SimulationIdentifier & Value ) const;
KBOOL operator != ( const SimulationIdentifier & Value ) const;
KBOOL operator < ( const SimulationIdentifier & Value ) const;
} | movl 0x8(%rsi), %eax
movl %eax, 0x58(%rdi)
movzwl 0xc(%rsi), %eax
movw %ax, 0x5c(%rdi)
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Radio_Communications/././../../DataTypes/./SimulationIdentifier.h |
KDIS::PDU::Intercom_Control_PDU::AddIntercomCommunicationParameters(KDIS::DATA_TYPE::IntercomCommunicationParameters const&) | void Intercom_Control_PDU::AddIntercomCommunicationParameters( const IntercomCommunicationParameters & ICP )
{
m_ui16PDULength += ICP.GetLength() + IntercomCommunicationParameters::INTERCOM_COMMS_PARAM_SIZE;
m_vICP.push_back( ICP );
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x95e5c
addw 0x20(%r14), %ax
addl $0x4, %eax
movw %ax, 0x20(%r14)
movq 0x70(%r14), %rsi
cmpq 0x78(%r14), %rsi
je 0x5765a
leaq 0xcf740(%rip), %rax # 0x126d78
addq $0x10, %rax
movq %rax, (%rsi)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x8(%rsi)
movb 0x18(%rbx), %al
movb %al, 0x18(%rsi)
addq $0x20, 0x70(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x68, %r14
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5847e
| /jarvisfriends[P]KDIS/KDIS/PDU/Radio_Communications/Intercom_Control_PDU.cpp |
KDIS::PDU::Intercom_Control_PDU::GetAsString[abi:cxx11]() const | KString Intercom_Control_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Intercom Control PDU-\n"
<< "Control Type: " << GetEnumAsStringControlType( m_ui8CtrlTyp ) << "\n"
<< m_CommChannelType.GetAsString()
<< "Source Entity:\n"
<< IndentString( m_SrcEnt.GetAsString(), 1 )
<< "Source Communications Device ID: " << m_ui16SrcCommDevID << "\n"
<< "Source Line ID: " << ( KUINT16 )m_ui8SrcLineID << "\n"
<< "Transmit Priority: " << ( KUINT16 )m_ui8TransmitPriority << "\n"
<< "Transmit Line State: " << GetEnumAsStringTransmitLineState( m_ui8TransmitLineState ) << "\n"
<< "Command: " << GetEnumAsStringLineStateCommand( m_ui8Command ) << "\n"
<< "Master Entity ID:\n"
<< m_MstrEntID.GetAsString()
<< "Master Communications Device ID: " << m_ui16MstrCommDeviceID << "\n"
<< "Master Channel ID: " << m_ui16MstrChannelID << "\n"
<< "Intercom Parameter Length: " << m_ui32IntrParamLen << "\n";
vector<IntercomCommunicationParameters>::const_iterator citr = m_vICP.begin();
vector<IntercomCommunicationParameters>::const_iterator citrEnd = m_vICP.end();
for( ; citr != citrEnd; ++citr )
{
ss << citr->GetAsString();
}
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp # imm = 0x3F8
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x270(%rsp), %rdi
callq 0x25250
leaq 0xc8(%rsp), %rdi
movq %r15, %rsi
callq 0x2b662
leaq 0x280(%rsp), %r14
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
movq %r14, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x66e3f(%rip), %rsi # 0xbe557
movl $0x17, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x66e43(%rip), %rsi # 0xbe56f
movl $0x22, %edx
movq %r12, %rdi
callq 0x253e0
movzbl 0x27(%r15), %esi
leaq 0xa8(%rsp), %rdi
callq 0xb0e35
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x67359(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
movq %rbx, 0x20(%rsp)
leaq 0x28(%r15), %rsi
leaq 0x88(%rsp), %rdi
callq 0x8acba
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r13
leaq 0x66de0(%rip), %rsi # 0xbe592
movl $0xf, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x38(%r15), %rsi
leaq 0x28(%rsp), %rdi
callq 0x7f1d4
leaq 0xe8(%rsp), %rdi
callq 0x25250
leaq 0xf8(%rsp), %r12
movq %rsp, %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x253e0
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x57869
movw $0x1, %bx
xorl %ecx, %ecx
movq %rsp, %rbp
movq 0x28(%rsp), %rdx
movb (%rdx,%rcx), %dl
decq %rax
cmpq %rcx, %rax
je 0x57847
cmpb $0xa, %dl
jne 0x57847
movb $0xa, (%rsp)
movl $0x1, %edx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x253e0
movb $0x9, (%rsp)
movl $0x1, %edx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x253e0
jmp 0x5785a
movb %dl, (%rsp)
movl $0x1, %edx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x253e0
movzwl %bx, %ecx
movq 0x30(%rsp), %rax
incl %ebx
cmpq %rcx, %rax
ja 0x57808
leaq 0x100(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x25480
movq 0xdd736(%rip), %rsi # 0x134fb8
leaq 0xe8(%rsp), %rdi
callq 0x25280
leaq 0x168(%rsp), %rdi
callq 0x25120
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq %r13, %rdi
callq 0x253e0
movq %rax, %r13
leaq 0x66cea(%rip), %rsi # 0xbe5a2
movl $0x22, %edx
movq %rax, %rdi
callq 0x253e0
movzwl 0x48(%r15), %esi
movq %r13, %rdi
callq 0x25220
movq %rax, %r13
leaq 0x671ea(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x66cd5(%rip), %rsi # 0xbe5c5
movl $0x22, %edx
movq %r13, %rdi
callq 0x253e0
movzbl 0x4a(%r15), %esi
movq %r13, %rdi
callq 0x25220
movq %rax, %r13
leaq 0x671b2(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x66cc0(%rip), %rsi # 0xbe5e8
movl $0x22, %edx
movq %r13, %rdi
callq 0x253e0
movzbl 0x4b(%r15), %esi
movq %r13, %rdi
callq 0x25220
movq %rax, %r13
leaq 0x6717a(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x66cab(%rip), %rsi # 0xbe60b
movl $0x22, %edx
movq %r13, %rdi
callq 0x253e0
movzbl 0x4c(%r15), %esi
leaq 0xe8(%rsp), %rdi
callq 0xb0f13
movq 0xe8(%rsp), %rsi
movq 0xf0(%rsp), %rdx
movq %r13, %rdi
callq 0x253e0
movq %rax, %r13
leaq 0x67125(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x66c79(%rip), %rsi # 0xbe62e
movl $0x22, %edx
movq %r13, %rdi
callq 0x253e0
movzbl 0x4d(%r15), %esi
movq %rsp, %rdi
callq 0xb0f5d
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rdi
callq 0x253e0
movq %rax, %r13
leaq 0x670dc(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x66c53(%rip), %rsi # 0xbe651
movl $0x12, %edx
movq %r13, %rdi
callq 0x253e0
leaq 0x50(%r15), %rsi
leaq 0x48(%rsp), %rdi
callq 0x7f1d4
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %r13, %rdi
callq 0x253e0
movq %rax, %r13
leaq 0x66c2f(%rip), %rsi # 0xbe664
movl $0x22, %edx
movq %rax, %rdi
callq 0x253e0
movzwl 0x60(%r15), %esi
movq %r13, %rdi
callq 0x25220
movq %rax, %r13
leaq 0x6706d(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x66c1a(%rip), %rsi # 0xbe687
movl $0x22, %edx
movq %r13, %rdi
callq 0x253e0
movzwl 0x62(%r15), %esi
movq %r13, %rdi
callq 0x25220
movq %rax, %r13
leaq 0x67035(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x66c05(%rip), %rsi # 0xbe6aa
movl $0x22, %edx
movq %r13, %rdi
callq 0x253e0
movl 0x64(%r15), %esi
movq %r13, %rdi
callq 0x25220
leaq 0x67001(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57aed
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57b08
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0xe8(%rsp), %rdi
cmpq %r12, %rdi
je 0x57b25
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57b40
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57b5b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57b7c
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57b9d
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57bbe
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x68(%r15), %r13
movq 0x70(%r15), %rbx
cmpq %rbx, %r13
je 0x57c1e
leaq 0xe8(%rsp), %r15
movq (%r13), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *0x10(%rax)
movq 0xe8(%rsp), %rsi
movq 0xf0(%rsp), %rdx
movq %r14, %rdi
callq 0x253e0
movq 0xe8(%rsp), %rdi
cmpq %r12, %rdi
je 0x57c15
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x25390
addq $0x20, %r13
cmpq %rbx, %r13
jne 0x57bd3
leaq 0x288(%rsp), %rsi
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x25480
movq 0xdd37e(%rip), %rsi # 0x134fb8
leaq 0x270(%rsp), %rdi
callq 0x25280
leaq 0x2f0(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x3f8, %rsp # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x57d29
jmp 0x57c9f
jmp 0x57ca4
jmp 0x57d09
movq %rax, %rbx
jmp 0x57d76
jmp 0x57c8f
jmp 0x57c97
jmp 0x57ca9
jmp 0x57d29
jmp 0x57d52
movq %rax, %rbx
jmp 0x57d91
movq %rax, %rbx
jmp 0x57db2
movq %rax, %rbx
jmp 0x57ccf
movq %rax, %rbx
jmp 0x57cea
movq %rax, %rbx
jmp 0x57dd3
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57ccf
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57cea
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0xe8(%rsp), %rdi
cmpq %r12, %rdi
je 0x57d0c
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x25390
jmp 0x57d0c
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57d76
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x25390
jmp 0x57d76
movq %rax, %rbx
jmp 0x57df4
movq %rax, %rbx
movq 0xe8(%rsp), %rdi
cmpq %r12, %rdi
je 0x57df4
movq 0xf8(%rsp), %rsi
jmp 0x57dec
movq %rax, %rbx
movq 0xdd25c(%rip), %rsi # 0x134fb8
leaq 0xe8(%rsp), %rdi
callq 0x25280
leaq 0x168(%rsp), %rdi
callq 0x25120
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57d91
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57db2
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57dd3
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57df4
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0xdd1bd(%rip), %rsi # 0x134fb8
leaq 0x270(%rsp), %rdi
callq 0x25280
leaq 0x2f0(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Radio_Communications/Intercom_Control_PDU.cpp |
KDIS::PDU::Acknowledge_PDU::Acknowledge_PDU(KDIS::PDU::Simulation_Management_Header const&, KDIS::DATA_TYPE::ENUMS::AcknowledgeFlag, KDIS::DATA_TYPE::ENUMS::AcknowledgeResponseFlag, unsigned int) | Acknowledge_PDU::Acknowledge_PDU( const Simulation_Management_Header & SimMgrHeader, AcknowledgeFlag AF,
AcknowledgeResponseFlag ARF, KUINT32 RequestID ) :
Simulation_Management_Header( SimMgrHeader ),
m_ui16AcknowledgeFlag( AF ),
m_ui16ResponseFlag( ARF ),
m_ui32RequestID( RequestID )
{
m_ui8PDUType = Acknowledge_PDU_Type;
m_ui16PDULength = ACKNOWLEDGE_PDU_SIZE;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %r15
callq 0x5ea0a
leaq 0xcb89a(%rip), %rax # 0x124360
movq %rax, (%r15)
movw %r14w, 0x48(%r15)
movw %bp, 0x4a(%r15)
movl %ebx, 0x4c(%r15)
movb $0xf, 0xa(%r15)
movw $0x20, 0x20(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/Acknowledge_PDU.cpp |
KDIS::UTILS::KRef_Ptr<KDIS::DATA_TYPE::FactoryDecoder<KDIS::DATA_TYPE::FixedDatum>>::unRef() | void unRef()
{
if( m_pRef )
{
--( *m_piCount );
if( *m_piCount == 0 )
{
delete m_piCount;
delete m_pRef;
m_piCount = NULL;
m_pRef = NULL;
}
}
} | pushq %rbx
cmpq $0x0, 0x8(%rdi)
je 0x59cec
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
decw (%rdi)
jne 0x59cec
addq $0x8, %rbx
movl $0x2, %esi
callq 0x25390
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x59ce6
movq (%rdi), %rax
callq *0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/././././../../DataTypes/././../Extras/KRef_Ptr.h |
KDIS::PDU::Comment_PDU::GetAsString[abi:cxx11]() const | KString Comment_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Comment PDU-\n"
<< Simulation_Management_Header::GetAsString()
<< "\nNumber Fixed Datum: " << m_ui32NumFixedDatum
<< "\nNumber Variable Datum: " << m_ui32NumVariableDatum
<< "\n";
ss << "Fixed Datum\n";
vector<FixDtmPtr>::const_iterator citrFixed = m_vFixedDatum.begin();
vector<FixDtmPtr>::const_iterator citrFixedEnd = m_vFixedDatum.end();
for( ; citrFixed != citrFixedEnd; ++citrFixed )
{
ss << IndentString( ( *citrFixed )->GetAsString() );
}
ss << "Variable Datum\n";
vector<VarDtmPtr>::const_iterator citrVar = m_vVariableDatum.begin();
vector<VarDtmPtr>::const_iterator citrVarEnd = m_vVariableDatum.end();
for( ; citrVar != citrVarEnd; ++citrVar )
{
ss << IndentString( ( *citrVar )->GetAsString() );
}
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0x25250
movq %rsp, %rdi
movq %r14, %rsi
callq 0x2b662
leaq 0x60(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x253e0
movq %rax, %r12
leaq 0x63982(%rip), %rsi # 0xbe979
movl $0xe, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x5ed86
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x6395b(%rip), %rsi # 0xbe988
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x48(%r14), %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x63956(%rip), %rsi # 0xbe9a6
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x4c(%r14), %esi
movq %r12, %rdi
callq 0x25220
leaq 0x63a56(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
movq %rbx, 0x40(%rsp)
leaq 0x30(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x5b09d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %rbx
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x5b0b8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x63905(%rip), %rsi # 0xbe9c4
movl $0xc, %edx
leaq 0x60(%rsp), %rdi
callq 0x253e0
movq 0x50(%r14), %r15
movq %r14, 0x48(%rsp)
movq 0x58(%r14), %r14
cmpq %r14, %r15
je 0x5b149
leaq 0x20(%rsp), %r12
movq %rsp, %r13
movq 0x8(%r15), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x5b2c7
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x253e0
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x5b129
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5b140
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
addq $0x18, %r15
cmpq %r14, %r15
jne 0x5b0e8
leaq 0x63881(%rip), %rsi # 0xbe9d1
movl $0xf, %edx
leaq 0x60(%rsp), %rdi
callq 0x253e0
movq 0x48(%rsp), %rax
movq 0x68(%rax), %r13
movq 0x70(%rax), %r14
cmpq %r14, %r13
je 0x5b1da
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq 0x8(%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5b2c7
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x253e0
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x5b1ba
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5b1d1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
addq $0x18, %r13
cmpq %r14, %r13
jne 0x5b179
leaq 0x68(%rsp), %rsi
movq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x25480
movq 0xd9dc5(%rip), %rsi # 0x134fb8
leaq 0x50(%rsp), %rdi
callq 0x25280
leaq 0xd0(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b267
jmp 0x5b267
jmp 0x5b267
jmp 0x5b229
jmp 0x5b267
movq %rax, %r14
jmp 0x5b24c
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5b24c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5b2a1
movq 0x10(%rsp), %rsi
jmp 0x5b299
jmp 0x5b267
jmp 0x5b26c
jmp 0x5b271
movq %rax, %r14
jmp 0x5b2a1
movq %rax, %r14
jmp 0x5b28a
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x5b28a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5b2a1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0xd9d10(%rip), %rsi # 0x134fb8
leaq 0x50(%rsp), %rdi
callq 0x25280
leaq 0xd0(%rsp), %rdi
callq 0x25120
movq %r14, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/Comment_PDU.cpp |
KDIS::PDU::Create_Entity_PDU::Decode(KDIS::KDataStream&, bool) | void Create_Entity_PDU::Decode(KDataStream &stream, bool ignoreHeader /*= true*/ ) noexcept(false)
{
if( ( stream.GetBufferSize() + ( ignoreHeader ? Header::HEADER6_PDU_SIZE : 0 ) ) < CREATE_ENTITY_PDU_SIZE )throw KException( __FUNCTION__, NOT_ENOUGH_DATA_IN_BUFFER );
Simulation_Management_Header::Decode( stream, ignoreHeader );
stream >> m_ui32RequestID;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26758
movzwl %ax, %eax
testl %ebp, %ebp
movl $0xc, %ecx
cmovel %ebp, %ecx
addl %eax, %ecx
cmpl $0x1b, %ecx
jbe 0x5bda4
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f0b8
addq $0x48, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b290
movl $0x30, %edi
callq 0x25180
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5fa23(%rip), %rsi # 0xbb7e4
leaq 0x5fa22(%rip), %rdx # 0xbb7ea
leaq 0x8(%rsp), %rdi
callq 0x2652e
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x2746c
xorl %ebp, %ebp
leaq 0xc6d80(%rip), %rsi # 0x122b70
leaq -0x34f0b(%rip), %rdx # 0x26eec
movq %rbx, %rdi
callq 0x25500
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5be19
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
testb %bpl, %bpl
jne 0x5be23
jmp 0x5be2b
movq %rax, %r14
movq %rbx, %rdi
callq 0x25270
movq %r14, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/Create_Entity_PDU.cpp |
KDIS::PDU::Data_PDU::GetAsString[abi:cxx11]() const | KString Data_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Data PDU-\n"
<< Simulation_Management_Header::GetAsString()
<< "Request ID: " << m_ui32RequestID
<< "\nNumber Fixed Datum: " << m_ui32NumFixedDatum
<< "\nNumber Variable Datum: " << m_ui32NumVariableDatum
<< "\n";
ss << "Fixed Datum\n";
vector<FixDtmPtr>::const_iterator citrFixed = m_vFixedDatum.begin();
vector<FixDtmPtr>::const_iterator citrFixedEnd = m_vFixedDatum.end();
for( ; citrFixed != citrFixedEnd; ++citrFixed )
{
ss << IndentString( ( *citrFixed )->GetAsString() );
}
ss << "Variable Datum\n";
vector<VarDtmPtr>::const_iterator citrVar = m_vVariableDatum.begin();
vector<VarDtmPtr>::const_iterator citrVarEnd = m_vVariableDatum.end();
for( ; citrVar != citrVarEnd; ++citrVar )
{
ss << IndentString( ( *citrVar )->GetAsString() );
}
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0x25250
movq %rsp, %rdi
movq %r14, %rsi
callq 0x2b662
leaq 0x60(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x253e0
movq %rax, %r12
leaq 0x629b7(%rip), %rsi # 0xbea2e
movl $0xb, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x5ed86
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x6298d(%rip), %rsi # 0xbea3a
movl $0x17, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x80(%r14), %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x6297f(%rip), %rsi # 0xbea52
movl $0x18, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x48(%r14), %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x62975(%rip), %rsi # 0xbea6b
movl $0x18, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x4c(%r14), %esi
movq %r12, %rdi
callq 0x25220
leaq 0x629b0(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
movq %rbx, 0x40(%rsp)
leaq 0x30(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x5c143
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %rbx
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x5c15e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x6285f(%rip), %rsi # 0xbe9c4
movl $0xc, %edx
leaq 0x60(%rsp), %rdi
callq 0x253e0
movq 0x50(%r14), %r15
movq %r14, 0x48(%rsp)
movq 0x58(%r14), %r14
cmpq %r14, %r15
je 0x5c1ef
leaq 0x20(%rsp), %r12
movq %rsp, %r13
movq 0x8(%r15), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x5c36d
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x253e0
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x5c1cf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5c1e6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
addq $0x18, %r15
cmpq %r14, %r15
jne 0x5c18e
leaq 0x627db(%rip), %rsi # 0xbe9d1
movl $0xf, %edx
leaq 0x60(%rsp), %rdi
callq 0x253e0
movq 0x48(%rsp), %rax
movq 0x68(%rax), %r13
movq 0x70(%rax), %r14
cmpq %r14, %r13
je 0x5c280
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq 0x8(%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5c36d
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x253e0
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x5c260
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5c277
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
addq $0x18, %r13
cmpq %r14, %r13
jne 0x5c21f
leaq 0x68(%rsp), %rsi
movq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x25480
movq 0xd8d1f(%rip), %rsi # 0x134fb8
leaq 0x50(%rsp), %rdi
callq 0x25280
leaq 0xd0(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5c30d
jmp 0x5c30d
jmp 0x5c30d
jmp 0x5c2cf
jmp 0x5c30d
movq %rax, %r14
jmp 0x5c2f2
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5c2f2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5c347
movq 0x10(%rsp), %rsi
jmp 0x5c33f
jmp 0x5c30d
jmp 0x5c312
jmp 0x5c317
movq %rax, %r14
jmp 0x5c347
movq %rax, %r14
jmp 0x5c330
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x5c330
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5c347
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0xd8c6a(%rip), %rsi # 0x134fb8
leaq 0x50(%rsp), %rdi
callq 0x25280
leaq 0xd0(%rsp), %rdi
callq 0x25120
movq %r14, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/Data_PDU.cpp |
KDIS::UTILS::IndentString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned short, char) | static inline KString IndentString( const KString & S, KUINT16 Tabs = 1, KCHAR8 Tab = '\t' )
{
KStringStream NewS;
// Add tab to first item and then check all new lines
AddTabsToStringStream( NewS, Tabs, Tab );
for( KUINT16 i = 0; i < S.size(); ++i )
{
if( S.c_str()[i] == '\n' && i != ( S.size() - 1 ) )
{
NewS << S.c_str()[i];
AddTabsToStringStream( NewS, Tabs, Tab );
}
else
{
NewS << S.c_str()[i];
}
}
return NewS.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25250
leaq 0x18(%rsp), %r15
leaq 0x7(%rsp), %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x253e0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x5c427
movw $0x1, %r13w
xorl %ecx, %ecx
leaq 0x7(%rsp), %r12
movq (%r14), %rdx
movb (%rdx,%rcx), %dl
cmpb $0xa, %dl
setne %sil
decq %rax
cmpq %rcx, %rax
sete %al
orb %sil, %al
je 0x5c3ed
movb %dl, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
jmp 0x5c417
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
movb $0x9, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
movzwl %r13w, %ecx
movq 0x8(%r14), %rax
incl %r13d
cmpq %rcx, %rax
ja 0x5c3bc
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0xd8b7d(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5c465
movq %rax, %rbx
movq 0xd8b49(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/././././.././././.././Extras/KUtils.h |
KDIS::PDU::Data_PDU::Decode(KDIS::KDataStream&, bool) | void Data_PDU::Decode(KDataStream &stream, bool ignoreHeader /*= true*/ ) noexcept(false)
{
if( ( stream.GetBufferSize() + ( ignoreHeader ? Header::HEADER6_PDU_SIZE : 0 ) ) < DATA_PDU_SIZE )throw KException( __FUNCTION__, NOT_ENOUGH_DATA_IN_BUFFER );
Simulation_Management_Header::Decode( stream, ignoreHeader );
stream >> m_ui32RequestID
>> m_ui32Padding
>> m_ui32NumFixedDatum
>> m_ui32NumVariableDatum;
// FixedDatum
for( KUINT16 i = 0; i < m_ui32NumFixedDatum; ++i )
{
// Save the current write position so we can peek.
KUINT16 pos = stream.GetCurrentWritePosition();
KUINT32 datumID;
// Extract the datum id then reset the stream.
stream >> datumID;
stream.SetCurrentWritePosition( pos );
// Use the factory decoder.
FixedDatum * p = FixedDatum::FactoryDecode( datumID, stream );
// Did we find a custom decoder? if not then use the default.
if( p )
{
m_vFixedDatum.push_back( FixDtmPtr( p ) );
}
else
{
// Default
m_vFixedDatum.push_back( FixDtmPtr( new FixedDatum( stream ) ) );
}
}
// VariableDatum
for( KUINT16 i = 0; i < m_ui32NumVariableDatum; ++i )
{
// Save the current write position so we can peek.
KUINT16 pos = stream.GetCurrentWritePosition();
KUINT32 datumID;
// Extract the datum id then reset the stream.
stream >> datumID;
stream.SetCurrentWritePosition( pos );
// Use the factory decoder.
VariableDatum * p = VariableDatum::FactoryDecode( datumID, stream );
// Did we find a custom decoder? if not then use the default.
if( p )
{
m_vVariableDatum.push_back( VarDtmPtr( p ) );
}
else
{
// Default
m_vVariableDatum.push_back( VarDtmPtr( new VariableDatum( stream ) ) );
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26758
movzwl %ax, %eax
testl %ebp, %ebp
movl $0xc, %ecx
cmovel %ebp, %ecx
addl %eax, %ecx
cmpl $0x27, %ecx
jbe 0x5c70d
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f0b8
leaq 0x80(%r14), %rsi
movq %rbx, %rdi
callq 0x2b290
leaq 0x84(%r14), %rsi
movq %rbx, %rdi
callq 0x2b290
leaq 0x48(%r14), %rsi
movq %rbx, %rdi
movq %rsi, 0x40(%rsp)
callq 0x2b290
leaq 0x4c(%r14), %rsi
movq %rbx, %rdi
movq %rsi, 0x38(%rsp)
callq 0x2b290
movq %r14, 0x30(%rsp)
cmpl $0x0, 0x48(%r14)
je 0x5c5ff
movq 0x30(%rsp), %rax
leaq 0x50(%rax), %r13
movw $0x1, %r14w
leaq 0xc7f10(%rip), %r12 # 0x124448
leaq 0x10(%rsp), %rbp
movq %rbx, %rdi
callq 0x26860
movl %eax, %r15d
movq %rbx, %rdi
leaq 0xc(%rsp), %rsi
callq 0x2b290
movzwl %r15w, %esi
movq %rbx, %rdi
callq 0x2685a
movl 0xc(%rsp), %edi
movq %rbx, %rsi
callq 0x59bd4
testq %rax, %rax
je 0x5c59d
movq %r12, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movl $0x2, %edi
callq 0x25370
movq %rax, 0x20(%rsp)
movw $0x1, (%rax)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x59d6a
jmp 0x5c5de
movl $0x10, %edi
callq 0x25370
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x80eb2
movq %r12, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movl $0x2, %edi
callq 0x25370
movq %rax, 0x20(%rsp)
movw $0x1, (%rax)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x59d6a
movq %r12, 0x10(%rsp)
movq %rbp, %rdi
callq 0x59d32
movzwl %r14w, %eax
incl %r14d
movq 0x40(%rsp), %rcx
cmpl %eax, (%rcx)
ja 0x5c53d
movq 0x38(%rsp), %rax
cmpl $0x0, (%rax)
je 0x5c6fe
addq $0x68, 0x30(%rsp)
movw $0x1, %r12w
leaq 0xc(%rsp), %r15
leaq 0xc730c(%rip), %r14 # 0x123930
leaq 0x10(%rsp), %r13
movq %rbx, %rdi
callq 0x26860
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2b290
movzwl %bp, %esi
movq %rbx, %rdi
callq 0x2685a
movl 0xc(%rsp), %edi
movq %rbx, %rsi
callq 0x3ebe2
testq %rax, %rax
je 0x5c694
movq %r14, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movl $0x2, %edi
callq 0x25370
movq %rax, 0x20(%rsp)
movw $0x1, (%rax)
movq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x406fa
movq %r14, 0x10(%rsp)
movq %r13, %rdi
callq 0x3fec8
jmp 0x5c6ea
movq %r15, %rbp
movl $0x28, %edi
callq 0x25370
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x861e4
movq %r14, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movl $0x2, %edi
callq 0x25370
movq %rax, 0x20(%rsp)
movw $0x1, (%rax)
movq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x406fa
movq %r14, 0x10(%rsp)
movq %r13, %rdi
callq 0x3fec8
movq %rbp, %r15
movzwl %r12w, %eax
incl %r12d
movq 0x38(%rsp), %rcx
cmpl %eax, (%rcx)
ja 0x5c629
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x25180
movq %rax, %r14
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5f0ba(%rip), %rsi # 0xbb7e4
leaq 0x5f0b9(%rip), %rdx # 0xbb7ea
leaq 0x10(%rsp), %rdi
callq 0x2652e
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl $0x2, %edx
callq 0x2746c
xorl %ebp, %ebp
leaq 0xc6417(%rip), %rsi # 0x122b70
leaq -0x35874(%rip), %rdx # 0x26eec
movq %r14, %rdi
callq 0x25500
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x5c782
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x25390
testb %bpl, %bpl
jne 0x5c78c
jmp 0x5c7d8
movq %rax, %rbx
movq %r14, %rdi
callq 0x25270
jmp 0x5c7d8
movq %rax, %rbx
movl $0x28, %esi
jmp 0x5c7a8
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x25390
jmp 0x5c7d8
jmp 0x5c7b6
jmp 0x5c7c8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
movq %r14, (%rdi)
callq 0x3fec8
jmp 0x5c7d8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
movq %r12, (%rdi)
callq 0x59d32
movq %rbx, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/Data_PDU.cpp |
KDIS::PDU::Simulation_Management_Header::Simulation_Management_Header(KDIS::DATA_TYPE::EntityIdentifier const&, KDIS::DATA_TYPE::EntityIdentifier const&) | Simulation_Management_Header::Simulation_Management_Header( const EntityIdentifier & OriginatingEntityID, const EntityIdentifier & ReceivingEntityID ) :
m_OriginatingEntityID( OriginatingEntityID ),
m_ReceivingEntityID( ReceivingEntityID )
{
m_ui8ProtocolFamily = Simulation_Management;
m_ui8ProtocolVersion = IEEE_1278_1_1995;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2b4d0
leaq 0xc5ab0(%rip), %rax # 0x124760
movq %rax, (%r15)
leaq 0xc7296(%rip), %rax # 0x125f50
addq $0x10, %rax
movq %rax, 0x28(%r15)
movl 0x8(%r14), %ecx
movl %ecx, 0x30(%r15)
leaq 0xc6f1f(%rip), %rcx # 0x125bf0
addq $0x10, %rcx
movq %rcx, 0x28(%r15)
movzwl 0xc(%r14), %edx
movw %dx, 0x34(%r15)
movq %rax, 0x38(%r15)
movl 0x8(%rbx), %eax
movl %eax, 0x40(%r15)
movq %rcx, 0x38(%r15)
movzwl 0xc(%rbx), %eax
movw %ax, 0x44(%r15)
movb $0x5, %al
movb %al, 0xb(%r15)
movb %al, 0x8(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/Simulation_Management_Header.cpp |
KDIS::PDU::Simulation_Management_Header::SetOriginatingEntityID(KDIS::DATA_TYPE::EntityIdentifier const&) | class KDIS_EXPORT SimulationIdentifier : public DataTypeBase
{
protected:
KUINT16 m_ui16SiteID;
KUINT16 m_ui16ApplicationID;
public:
static const KUINT16 SIMULATION_IDENTIFIER_SIZE = 4;
SimulationIdentifier();
SimulationIdentifier( KUINT16 SiteID, KUINT16 ApplicatonID );
SimulationIdentifier(KDataStream &stream) noexcept(false);
virtual ~SimulationIdentifier();
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::SetSiteID
// KDIS::DATA_TYPE::SimulationIdentifier::GetSiteID
// Description: Site ID.
// A site is defined as a facility, installation, organizational unit or a geographic
// location that has one or more simulation applications capable of participating in a
// distributed event. A facility, installation, organizational unit or geographic location
// may have multiple sites associated with it.
// Each site participating in an event (e.g., training exercise, experiment, test) shall be
// assigned a unique Site Number that is different from any other site that is part of the same event.
// A simulation site is a site that generates simulated objects based on simulated data. A live site
// is a site that is associated with producing live objects from live sources such as producing
// entities representing live aircraft flying in a live training range. A simulation associated
// with a live site may issue Live Entity PDUs (e.g., the TSPI PDU) for the live objects or may
// issue Entity State PDUs for them.
// Parameter: KUINT16 ID
//************************************
void SetSiteID( KUINT16 ID );
KUINT16 GetSiteID() const;
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::SetApplicationID
// KDIS::DATA_TYPE::SimulationIdentifier::GetApplicationID
// Description: Application ID.
// An application is defined as a software program that is used to generate and process
// distributed simulation data including live, virtual and constructive data.
// Each application participating in an event (e.g., training exercise) shall be
// assigned a unique Application Number for the site with which the application is associated.
// Parameter: KUINT16 ID
//************************************
void SetApplicationID( KUINT16 ID );
KUINT16 GetApplicationID() const;
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::GetAsString
// Description: Returns a string representation.
//************************************
virtual KString GetAsString() const;
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::Decode
// Description: Convert From Network Data.
// Parameter: KDataStream & stream
//************************************
virtual void Decode(KDataStream &stream) noexcept(false);
//************************************
// FullName: KDIS::DATA_TYPE::SimulationIdentifier::Encode
// Description: Convert To Network Data.
// Parameter: KDataStream & stream
//************************************
virtual KDataStream Encode() const;
virtual void Encode( KDataStream & stream ) const;
KBOOL operator == ( const SimulationIdentifier & Value ) const;
KBOOL operator != ( const SimulationIdentifier & Value ) const;
KBOOL operator < ( const SimulationIdentifier & Value ) const;
} | movl 0x8(%rsi), %eax
movl %eax, 0x30(%rdi)
movzwl 0xc(%rsi), %eax
movw %ax, 0x34(%rdi)
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/././../../DataTypes/./SimulationIdentifier.h |
KDIS::PDU::Start_Resume_PDU::SetSimulationTime(KDIS::DATA_TYPE::ClockTime const&) | class KDIS_EXPORT ClockTime : public DataTypeBase
{
protected:
KINT32 m_i32Hour;
KUINT32 m_ui32TimePastHour;
public:
static const KUINT16 CLOCK_TIME_SIZE = 8;
ClockTime();
ClockTime( KINT32 Hour, KUINT32 TimePastHour );
explicit ClockTime(KDataStream &stream) noexcept(false);
~ClockTime() override = default;
//************************************
// FullName: KDIS::DATA_TYPE::ClockTime::SetHour
// KDIS::DATA_TYPE::ClockTime::GetHour
// Description: Time.
// Parameter: KINT32 H, void
//************************************
void SetHour( KINT32 H );
KINT32 GetHour() const;
//************************************
// FullName: KDIS::DATA_TYPE::ClockTime::SetTimePastHour
// KDIS::DATA_TYPE::ClockTime::GetTimePastHour
// Description: Time Past Hour. The time past the hour field.
// Parameter: KFLOAT32 Z, void
//************************************
void SetTimePastHour( KUINT32 TPH );
KUINT32 GetTimePastHour() const;
//************************************
// FullName: KDIS::DATA_TYPE::ClockTime::GetAsString
// Description: Returns a string representation
//************************************
KString GetAsString() const override;
//************************************
// FullName: KDIS::DATA_TYPE::ClockTime::Decode
// Description: Convert From Network Data.
// Parameter: KDataStream & stream
//************************************
void Decode(KDataStream &stream) noexcept(false) override;
//************************************
// FullName: KDIS::DATA_TYPE::ClockTime::Encode
// Description: Convert To Network Data.
// Parameter: KDataStream & stream
//************************************
KDataStream Encode() const override;
void Encode(KDataStream &stream) const override;
KBOOL operator == ( const ClockTime & Value ) const;
KBOOL operator != ( const ClockTime & Value ) const;
KBOOL operator < ( const ClockTime & Value ) const;
} | movq 0x8(%rsi), %rax
movq %rax, 0x60(%rdi)
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/././../../DataTypes/ClockTime.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.