name string | code string | asm string | file string |
|---|---|---|---|
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... | 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 = 0xCCCCC... | /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++) {
Label... | 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(... | /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 == ... | 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... | /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 %r... | /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 resul... | 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, %... | /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
m... | /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... | 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 %r1... | /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, w... | 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, %r... | /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, e... | 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
se... | /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),
GetM... | 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 0x... | /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... | /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
... | /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, fu... | 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... | /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");
Re... | 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... | /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);
... | 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, %r... | /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(la... | 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 ... | /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) == kLabelTyp... | 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 (... | /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
... | /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_... | 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
c... | /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)... | 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
c... | /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
... | 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 ... | /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 ... | /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 (typ... | 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, ... | /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
... | /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;
}
... | 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
le... | /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... | 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... | /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 t... | 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... | /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:... | 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
cal... | /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,... | /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)
add... | /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 0... | /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 %r... | /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... | /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(... | json_value(value_t t)
{
switch (t)
{
case value_t::object:
{
object = create<object_t>();
break;
}
case value_t::array:
{
array = create<array_t>()... | 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... | /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:... | 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... | /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... | 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 %r... | /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(nlo... | 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::... | 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 $0x... | /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 (&) [2... | 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 0... | /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 ... | /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_... | 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 0x2... | /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::js... | 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... | /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)... | /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, %r... | /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, st... | 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::... | 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... | /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::all... | 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... | /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>>, ... | 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 f... | 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
cmp... | /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... | 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, pa... | 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(%ri... | /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, lon... | 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.... | 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... | /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; l... | 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
mo... | /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... | 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, %... | /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 | ... | 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]... | 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 ... | /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);
... | 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... | /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... | /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... | 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), %rd... | /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,... | /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 && tempN... | 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 0x4... | /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... | /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 *)ma... | 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... | /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... | 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)
m... | /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, %... | /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 );
KFLOA... | 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
... | /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 );
SimulationIdentif... | 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 ... | 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 ... | /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 fal... | 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
jn... | /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 >> KDI... | 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 ... | /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
m... | /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 ... | 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 (%r... | /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 0... | /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 EntityT... | 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(... | /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 Mi... | 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
po... | /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.... | 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... | /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: " << GetEnumAsString... | 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... | /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; ++... | 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
p... | /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_ui16DataL... | 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 ... | /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, ignoreHeade... | 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 0... | /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 %r... | /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;
... | 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, i... | 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, %... | /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 )
{
Oct... | 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,... | /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],... | /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 );
SimulationIdentif... | 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 );
SimulationIdentif... | 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,... | /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"
... | 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 0... | /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_ui32Reques... | 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
po... | /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
... | 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 0... | /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( stre... | 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... | /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... | 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 0... | /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.... | 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... | /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 )... | 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, %... | /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_ui8ProtocolVers... | 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 ... | /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 );
SimulationIdentif... | 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);
~ClockT... | movq 0x8(%rsi), %rax
movq %rax, 0x60(%rdi)
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/././../../DataTypes/ClockTime.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.