name
string | code
string | asm
string | file
string |
|---|---|---|---|
llvm::codeview::CodeViewRecordIO::mapEncodedInteger(unsigned long&, llvm::Twine const&)
|
Error CodeViewRecordIO::mapEncodedInteger(uint64_t &Value,
const Twine &Comment) {
if (isStreaming())
emitEncodedUnsignedInteger(Value, Comment);
else if (isWriting()) {
if (auto EC = writeEncodedUnsignedInteger(Value))
return EC;
} else {
APSInt N;
if (auto EC = consume(*Reader, N))
return EC;
Value = N.getZExtValue();
}
return Error::success();
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rdx
testq %rdx, %rdx
setne %r8b
movq 0x28(%rsi), %rax
movq 0x30(%rsi), %rdi
testq %rax, %rax
sete %r9b
andb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x140b04
testq %rdi, %rdi
jne 0x140b2a
movq %rsi, %rdi
movq %r14, %rsi
movq %rcx, %rdx
callq 0x1403ea
jmp 0x140b86
testq %rdi, %rdi
setne %cl
orq %rax, %rdx
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x140b2a
movq %rbx, %rdi
movq %r14, %rdx
callq 0x14068c
cmpq $0x0, (%rbx)
jne 0x140b8d
jmp 0x140b86
leaq 0x8(%rsp), %r15
movl $0x1, 0x8(%r15)
movq $0x0, (%r15)
movb $0x0, 0xc(%r15)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x141143
movq (%rbx), %r12
movl 0x8(%r15), %eax
testq %r12, %r12
jne 0x140b6d
cmpl $0x41, %eax
jb 0x140b67
movq 0x8(%rsp), %r15
movq (%r15), %rcx
movq %rcx, (%r14)
cmpl $0x41, %eax
jb 0x140b81
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x140b81
callq 0x26260
testq %r12, %r12
jne 0x140b8d
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/DebugInfo/CodeView/CodeViewRecordIO.cpp
|
llvm::Regex::Regex(llvm::StringRef, llvm::Regex::RegexFlags)
|
Regex::Regex(StringRef regex, RegexFlags Flags) {
unsigned flags = 0;
preg = new llvm_regex();
preg->re_endp = regex.end();
if (Flags & IgnoreCase)
flags |= REG_ICASE;
if (Flags & Newline)
flags |= REG_NEWLINE;
if (!(Flags & BasicRegex))
flags |= REG_EXTENDED;
error = llvm_regcomp(preg, regex.data(), flags|REG_PEND);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x20, %edi
callq 0x26100
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rax, (%rbx)
addq %r14, %r15
movq %r15, 0x10(%rax)
movl %ebp, %ecx
andl $0x1, %ecx
movl %ebp, %edx
andl $0x2, %edx
shll $0x2, %edx
leal (%rdx,%rcx,2), %ecx
shrl $0x2, %ebp
andl $0x1, %ebp
orl %ecx, %ebp
xorl $0x21, %ebp
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1416a1
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/Support/Regex.cpp
|
llvm_regerror
|
size_t
llvm_regerror(int errcode, const llvm_regex_t *preg, char *errbuf, size_t errbuf_size)
{
struct rerr *r;
size_t len;
int target = errcode &~ REG_ITOA;
const char *s;
char convbuf[50];
if (errcode == REG_ATOI)
s = regatoi(preg, convbuf, sizeof convbuf);
else {
for (r = rerrs; r->code != 0; r++)
if (r->code == target)
break;
if (errcode®_ITOA) {
if (r->code != 0) {
assert(strlen(r->name) < sizeof(convbuf));
(void) llvm_strlcpy(convbuf, r->name, sizeof convbuf);
} else
(void)snprintf(convbuf, sizeof convbuf,
"REG_0x%x", target);
s = convbuf;
} else
s = r->explain;
}
len = strlen(s) + 1;
if (errbuf_size > 0) {
llvm_strlcpy(errbuf, s, errbuf_size);
}
return(len);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r14
cmpl $0xff, %edi
jne 0x143aed
movq 0x10(%rsi), %r12
leaq 0x9fce9(%rip), %rdi # 0x1e379a
movq %r12, %rsi
callq 0x26600
testl %eax, %eax
je 0x143b30
leaq 0x104eac(%rip), %r13 # 0x248970
leaq 0x25644(%rip), %r15 # 0x16910f
movl -0x8(%r13), %ebp
testl %ebp, %ebp
je 0x143b64
movq (%r13), %rdi
movq %r12, %rsi
callq 0x26600
addq $0x18, %r13
testl %eax, %eax
jne 0x143acb
jmp 0x143b35
movl %edi, %ecx
andl $0xfffffeff, %ecx # imm = 0xFFFFFEFF
leaq 0x104e54(%rip), %rax # 0x248950
movl (%rax), %edx
addq $0x18, %rax
testl %edx, %edx
je 0x143b0a
cmpl %ecx, %edx
jne 0x143afc
btl $0x8, %edi
jb 0x143b16
movq -0x8(%rax), %r15
jmp 0x143b64
testl %edx, %edx
je 0x143b4b
movq -0x10(%rax), %rsi
movq %rsp, %r15
movl $0x32, %edx
movq %r15, %rdi
callq 0x143bfa
jmp 0x143b64
movl $0x1, %ebp
leaq 0x26576(%rip), %rdx # 0x16a0b2
movq %rsp, %r15
movl $0x32, %esi
movq %r15, %rdi
movl %ebp, %ecx
jmp 0x143b5d
leaq 0x9fc3f(%rip), %rdx # 0x1e3791
movq %rsp, %r15
movl $0x32, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x26330
movq %r15, %rdi
callq 0x26280
movq %rax, %r12
testq %rbx, %rbx
je 0x143b82
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x143bfa
incq %r12
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Support/regerror.c
|
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseUnscopedName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::NameState*, bool*)
|
Node *
AbstractManglingParser<Derived, Alloc>::parseUnscopedName(NameState *State,
bool *IsSubst) {
Node *Std = nullptr;
if (consumeIf("St")) {
Std = make<NameType>("std");
if (Std == nullptr)
return nullptr;
}
Node *Res = nullptr;
ModuleName *Module = nullptr;
if (look() == 'S') {
Node *S = getDerived().parseSubstitution();
if (!S)
return nullptr;
if (S->getKind() == Node::KModuleName)
Module = static_cast<ModuleName *>(S);
else if (IsSubst && Std == nullptr) {
Res = S;
*IsSubst = true;
} else {
return nullptr;
}
}
if (Res == nullptr || Std != nullptr) {
Res = getDerived().parseUnqualifiedName(State, Std, Module);
}
return Res;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x2, %rdx
jb 0x146e0b
cmpw $0x7453, (%rax) # imm = 0x7453
je 0x146e5f
xorl %r12d, %r12d
cmpq %rax, %rcx
je 0x146e44
cmpb $0x53, (%rax)
jne 0x146e44
movq %r14, %rdi
callq 0x14747a
testq %rax, %rax
je 0x146e81
movq %rax, %rcx
cmpb $0x1b, 0x8(%rax)
je 0x146e46
testq %r15, %r15
sete %al
testq %r12, %r12
setne %dl
orb %al, %dl
jne 0x146e81
movb $0x1, (%r15)
jmp 0x146e83
xorl %ecx, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x147612
addq $0x2, %rax
movq %rax, (%r14)
leaq 0x54398(%rip), %rsi # 0x19b205
movq %r14, %rdi
callq 0x14741a
movq %rax, %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
jmp 0x146e0e
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [4]>(char const (&) [4])
|
Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
addq $0x330, %rdi # imm = 0x330
movl $0x20, %esi
callq 0x146988
movq %rax, %r14
movq %rbx, %rdi
callq 0x26280
movb $0x8, 0x8(%r14)
movzwl 0x9(%r14), %ecx
andl $0xfffff000, %ecx # imm = 0xFFFFF000
orl $0x540, %ecx # imm = 0x540
movw %cx, 0x9(%r14)
leaq 0x101739(%rip), %rcx # 0x248b98
addq $0x10, %rcx
movq %rcx, (%r14)
movq %rax, 0x10(%r14)
movq %rbx, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parsePrefixExpr(std::basic_string_view<char, std::char_traits<char>>, llvm::itanium_demangle::Node::Prec)
|
Node *
AbstractManglingParser<Derived, Alloc>::parsePrefixExpr(std::string_view Kind,
Node::Prec Prec) {
Node *E = getDerived().parseExpr();
if (E == nullptr)
return nullptr;
return make<PrefixExpr>(Kind, E, Prec);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
callq 0x147dbe
testq %rax, %rax
je 0x148cdd
movq %rax, %r15
addq $0x330, %r13 # imm = 0x330
movl $0x28, %esi
movq %r13, %rdi
callq 0x146988
movb $0x42, 0x8(%rax)
movzwl 0x9(%rax), %ecx
andl $0x3f, %r12d
andl $0xfffff000, %ecx # imm = 0xFFFFF000
addl %r12d, %ecx
addl $0x540, %ecx # imm = 0x540
movw %cx, 0x9(%rax)
leaq 0x100410(%rip), %rcx # 0x2490d8
addq $0x10, %rcx
movq %rcx, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %r15, 0x20(%rax)
jmp 0x148cdf
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::MemberExpr, llvm::itanium_demangle::Node*&, std::basic_string_view<char, std::char_traits<char>>&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec>(llvm::itanium_demangle::Node*&, std::basic_string_view<char, std::char_traits<char>>&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec&&)
|
Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
addq $0x330, %rdi # imm = 0x330
movl $0x30, %esi
callq 0x146988
movq (%r12), %rcx
movups (%r15), %xmm0
movq (%r14), %rdx
movzwl (%rbx), %esi
movb $0x3a, 0x8(%rax)
movzwl 0x9(%rax), %edi
andl $0x3f, %esi
andl $0xfffff000, %edi # imm = 0xFFFFF000
addl %edi, %esi
addl $0x540, %esi # imm = 0x540
movw %si, 0x9(%rax)
leaq 0x10049f(%rip), %rsi # 0x2491e0
addq $0x10, %rsi
movq %rsi, (%rax)
movq %rcx, 0x10(%rax)
movups %xmm0, 0x18(%rax)
movq %rdx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::BoolExpr, int>(int&&)
|
Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
}
|
pushq %rbx
movq %rsi, %rbx
addq $0x330, %rdi # imm = 0x330
movl $0x10, %esi
callq 0x146988
movzwl 0x9(%rax), %ecx
andl $0xfffff000, %ecx # imm = 0xFFFFF000
orl $0x540, %ecx # imm = 0x540
leaq 0xfe496(%rip), %rdx # 0x2494f8
addq $0x10, %rdx
cmpl $0x0, (%rbx)
movb $0x49, 0x8(%rax)
movw %cx, 0x9(%rax)
movq %rdx, (%rax)
setne 0xb(%rax)
popq %rbx
retq
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::UnnamedTypeName::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
OB += "'unnamed";
OB += Count;
OB += "\'";
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movabsq $0x64656d616e6e7527, %rdx # imm = 0x64656D616E6E7527
movq %rdx, (%rax,%rcx)
addq $0x8, 0x8(%rbx)
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x14c120
movq 0x18(%r15), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1441a8
movq (%rbx), %rdi
addq 0x8(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x26080
addq %r14, 0x8(%rbx)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x27, (%rax,%rcx)
incq 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::SyntheticTemplateParamName::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
switch (Kind) {
case TemplateParamKind::Type:
OB += "$T";
break;
case TemplateParamKind::NonType:
OB += "$N";
break;
case TemplateParamKind::Template:
OB += "$TT";
break;
}
if (Index > 0)
OB << Index - 1;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0xc(%rdi), %eax
cmpl $0x2, %eax
je 0x14c1ec
cmpl $0x1, %eax
je 0x14c1c6
testl %eax, %eax
jne 0x14c218
movl $0x2, %r15d
movl $0x2, %esi
movq %rbx, %rdi
callq 0x1441a8
leaq 0x8(%rbx), %rax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
jmp 0x14c20f
movl $0x2, %r15d
movl $0x2, %esi
movq %rbx, %rdi
callq 0x1441a8
leaq 0x8(%rbx), %rax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movw $0x4e24, (%rcx,%rdx) # imm = 0x4E24
jmp 0x14c215
movl $0x3, %r15d
movl $0x3, %esi
movq %rbx, %rdi
callq 0x1441a8
leaq 0x8(%rbx), %rax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movb $0x54, 0x2(%rcx,%rdx)
movw $0x5424, (%rcx,%rdx) # imm = 0x5424
addq %r15, (%rax)
movl 0x10(%r14), %esi
testl %esi, %esi
je 0x14c231
decl %esi
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x14c242
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::ConstrainedTypeTemplateParamDecl::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
Constraint->print(OB);
OB += " ";
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movzwl 0x9(%r14), %eax
andl $0xc0, %eax
cmpw $0x40, %ax
je 0x14c41a
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x28(%rax)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x20, (%rax,%rcx)
incq 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::NonTypeTemplateParamDecl::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
Type->printLeft(OB);
if (!Type->hasRHSComponent(OB))
OB += " ";
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x18(%r14), %rdi
movb 0x9(%rdi), %al
movl %eax, %ecx
andb $-0x40, %cl
negb %cl
jno 0x14c4bc
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
testb %al, %al
je 0x14c4c0
jmp 0x14c4dc
cmpb $0x40, %al
jb 0x14c4dc
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x20, (%rax,%rcx)
incq 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::TemplateTemplateParamDecl::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
OB += "template<";
Params.printWithComma(OB);
OB += "> typename ";
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x20(%rsi), %ebp
movl $0x0, 0x20(%rsi)
movl $0x9, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movabsq $0x6574616c706d6574, %rdx # imm = 0x6574616C706D6574
movq %rdx, (%rax,%rcx)
movb $0x3c, 0x8(%rax,%rcx)
addq $0x9, 0x8(%rbx)
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x144100
movl $0xb, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movabsq $0x616e65707974203e, %rdx # imm = 0x616E65707974203E
movq %rdx, (%rax,%rcx)
movl $0x20656d61, 0x7(%rax,%rcx) # imm = 0x20656D61
addq $0xb, 0x8(%rbx)
movl %ebp, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::ClosureTypeName::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
// FIXME: This demangling is not particularly readable.
OB += "\'lambda";
OB += Count;
OB += "\'";
printDeclarator(OB);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x7, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl $0x6164626d, 0x3(%rax,%rcx) # imm = 0x6164626D
movl $0x6d616c27, (%rax,%rcx) # imm = 0x6D616C27
addq $0x7, 0x8(%rbx)
movq 0x40(%r14), %r15
testq %r15, %r15
je 0x14c71c
movq 0x48(%r14), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1441a8
movq (%rbx), %rdi
addq 0x8(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x26080
addq %r15, 0x8(%rbx)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x27, (%rax,%rcx)
incq 0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x14c758
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::ThrowExpr::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
OB += "throw ";
Op->print(OB);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x6, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movw $0x2077, 0x4(%rax,%rcx) # imm = 0x2077
movl $0x6f726874, (%rax,%rcx) # imm = 0x6F726874
addq $0x6, 0x8(%rbx)
movq 0x10(%r14), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movzwl 0x9(%r14), %eax
andl $0xc0, %eax
cmpw $0x40, %ax
jne 0x14d9c7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
movq 0x28(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
nop
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::ConversionOperatorType::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
OB += "operator ";
Ty->print(OB);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x9, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movabsq $0x726f74617265706f, %rdx # imm = 0x726F74617265706F
movq %rdx, (%rax,%rcx)
movb $0x20, 0x8(%rax,%rcx)
addq $0x9, 0x8(%rbx)
movq 0x10(%r14), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movzwl 0x9(%r14), %eax
andl $0xc0, %eax
cmpw $0x40, %ax
jne 0x14df9e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
movq 0x28(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::SpecialSubstitution::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
OB << "std::" << getBaseName();
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x5, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x3a, 0x4(%rax,%rcx)
movl $0x3a647473, (%rax,%rcx) # imm = 0x3A647473
addq $0x5, 0x8(%rbx)
movl 0xc(%r14), %eax
leaq 0x95bcf(%rip), %rcx # 0x1e3d70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x9, %r14d
leaq 0x96148(%rip), %r15 # 0x1e42ff
jmp 0x14e206
movl $0x7, %r14d
leaq 0x9615e(%rip), %r15 # 0x1e4324
jmp 0x14e202
movl $0x6, %r14d
leaq 0x96134(%rip), %r15 # 0x1e4309
jmp 0x14e202
movl $0x7, %r14d
leaq 0x96132(%rip), %r15 # 0x1e4316
jmp 0x14e202
movl $0xc, %r14d
leaq 0x96116(%rip), %r15 # 0x1e4309
jmp 0x14e206
movl $0x8, %r14d
leaq 0x96130(%rip), %r15 # 0x1e4332
addq $0x6, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1441a8
movq (%rbx), %rdi
addq 0x8(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x26080
addq %r14, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::ExpandedSpecialSubstitution::getBaseName() const
|
std::string_view getBaseName() const override {
switch (SSK) {
case SpecialSubKind::allocator:
return {"allocator"};
case SpecialSubKind::basic_string:
return {"basic_string"};
case SpecialSubKind::string:
return {"basic_string"};
case SpecialSubKind::istream:
return {"basic_istream"};
case SpecialSubKind::ostream:
return {"basic_ostream"};
case SpecialSubKind::iostream:
return {"basic_iostream"};
}
DEMANGLE_UNREACHABLE;
}
|
movslq 0xc(%rdi), %rax
leaq 0x96103(%rip), %rcx # 0x1e44b4
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
leaq 0x96111(%rip), %rcx # 0x1e44d0
movq (%rcx,%rax,8), %rax
retq
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::LocalName::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
Encoding->print(OB);
OB += "::";
Entity->print(OB);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
movzwl 0x9(%r15), %eax
andl $0xc0, %eax
cmpw $0x40, %ax
je 0x14e82c
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x28(%rax)
movl $0x2, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movw $0x3a3a, (%rax,%rcx) # imm = 0x3A3A
addq $0x2, 0x8(%rbx)
movq 0x18(%r14), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movzwl 0x9(%r14), %eax
andl $0xc0, %eax
cmpw $0x40, %ax
jne 0x14e871
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq 0x28(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
nop
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::TemplateArgs::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
OB += "<";
Params.printWithComma(OB);
OB += ">";
// Don't print the requires clause to keep the output simple.
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x20(%rsi), %ebp
movl $0x0, 0x20(%rsi)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x3c, (%rax,%rcx)
incq 0x8(%rbx)
addq $0x10, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x144100
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x3e, (%rax,%rcx)
incq 0x8(%rbx)
movl %ebp, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::NameWithTemplateArgs::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
Name->print(OB);
TemplateArgs->print(OB);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
movzwl 0x9(%r15), %eax
andl $0xc0, %eax
cmpw $0x40, %ax
je 0x14eebe
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x28(%rax)
movq 0x18(%r14), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movzwl 0x9(%r14), %eax
andl $0xc0, %eax
cmpw $0x40, %ax
jne 0x14eee4
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq 0x28(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [10]>(char const (&) [10])
|
Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
addq $0x330, %rdi # imm = 0x330
movl $0x20, %esi
callq 0x146988
movq %rax, %r14
movq %rbx, %rdi
callq 0x26280
movb $0x8, 0x8(%r14)
movzwl 0x9(%r14), %ecx
andl $0xfffff000, %ecx # imm = 0xFFFFF000
orl $0x540, %ecx # imm = 0x540
movw %cx, 0x9(%r14)
leaq 0xf914b(%rip), %rcx # 0x248b98
addq $0x10, %rcx
movq %rcx, (%r14)
movq %rax, 0x10(%r14)
movq %rbx, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::TransformedType::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
OB += Transform;
OB += '(';
BaseType->print(OB);
OB += ')';
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x150602
movq 0x18(%r14), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1441a8
movq (%rbx), %rdi
addq 0x8(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x26080
addq %r15, 0x8(%rbx)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb $0x28, (%rax,%rcx)
movq 0x20(%r14), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movzwl 0x9(%r14), %eax
andl $0xc0, %eax
cmpw $0x40, %ax
je 0x15064e
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x28(%rax)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb $0x29, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::BitIntType::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
if (!Signed)
OB += "unsigned ";
OB += "_BitInt";
OB.printOpen();
Size->printAsOperand(OB);
OB.printClose();
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x18(%rdi)
jne 0x15073a
movl $0x9, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movabsq $0x64656e6769736e75, %rdx # imm = 0x64656E6769736E75
movq %rdx, (%rax,%rcx)
movb $0x20, 0x8(%rax,%rcx)
addq $0x9, 0x8(%rbx)
movl $0x7, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl $0x746e4974, 0x3(%rax,%rcx) # imm = 0x746E4974
movl $0x7469425f, (%rax,%rcx) # imm = 0x7469425F
addq $0x7, 0x8(%rbx)
incl 0x20(%rbx)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb $0x28, (%rax,%rcx)
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movl $0x13, %edx
xorl %ecx, %ecx
callq 0x1441e8
decl 0x20(%rbx)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb $0x29, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::PointerToMemberType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&)
|
Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
addq $0x330, %rdi # imm = 0x330
movl $0x20, %esi
callq 0x146988
movq (%r14), %rcx
movq (%rbx), %rdx
movzwl 0x9(%rdx), %esi
andl $0xc0, %esi
movb $0xe, 0x8(%rax)
movzwl 0x9(%rax), %edi
andl $0xfffff000, %edi # imm = 0xFFFFF000
addl %edi, %esi
addl $0x500, %esi # imm = 0x500
movw %si, 0x9(%rax)
leaq 0xfa114(%rip), %rsi # 0x24aba8
addq $0x10, %rsi
movq %rsi, (%rax)
movq %rcx, 0x10(%rax)
movq %rdx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::PointerToMemberType::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
MemberType->printLeft(OB);
if (MemberType->hasArray(OB) || MemberType->hasFunction(OB))
OB += "(";
else
OB += " ";
ClassType->print(OB);
OB += "::*";
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x18(%r14), %rdi
movzwl 0x9(%rdi), %eax
movl %eax, %ecx
shrl $0x8, %ecx
movb $0x28, %bpl
testb $0x3, %cl
je 0x150b32
andl $0x3, %ecx
cmpl $0x2, %ecx
jne 0x150b10
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
testb %al, %al
jne 0x150b32
movq 0x18(%r14), %rdi
movzwl 0x9(%rdi), %eax
movzwl %ax, %eax
shrl $0xa, %eax
testb $0x3, %al
je 0x150b32
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x150b2f
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
testb %al, %al
jne 0x150b32
movb $0x20, %bpl
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb %bpl, (%rax,%rcx)
incq 0x8(%rbx)
movq 0x10(%r14), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movzwl 0x9(%r14), %eax
andl $0xc0, %eax
cmpw $0x40, %ax
je 0x150b7a
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x28(%rax)
movl $0x3, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x2a, 0x2(%rax,%rcx)
movw $0x3a3a, (%rax,%rcx) # imm = 0x3A3A
addq $0x3, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::PointerType::printLeft(llvm::itanium_demangle::OutputBuffer&) const
|
void printLeft(OutputBuffer &OB) const override {
// We rewrite objc_object<SomeProtocol>* into id<SomeProtocol>.
if (Pointee->getKind() != KObjCProtoName ||
!static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) {
Pointee->printLeft(OB);
if (Pointee->hasArray(OB))
OB += " ";
if (Pointee->hasArray(OB) || Pointee->hasFunction(OB))
OB += "(";
OB += "*";
} else {
const auto *objcProto = static_cast<const ObjCProtoName *>(Pointee);
OB += "id<";
OB += objcProto->Protocol;
OB += ">";
}
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
cmpb $0xb, 0x8(%r15)
jne 0x150d90
movq %r15, %rdi
callq 0x150f16
movq 0x10(%r14), %r15
testb %al, %al
je 0x150d90
movl $0x3, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x3c, 0x2(%rax,%rcx)
movw $0x6469, (%rax,%rcx) # imm = 0x6469
addq $0x3, 0x8(%rbx)
movq 0x18(%r15), %r14
testq %r14, %r14
je 0x150d7c
movq 0x20(%r15), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1441a8
movq (%rbx), %rdi
addq 0x8(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x26080
addq %r14, 0x8(%rbx)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movb $0x3e, %al
jmp 0x150e52
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq 0x10(%r14), %rdi
movzbl 0xa(%rdi), %eax
testb $0x3, %al
je 0x150dbd
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x150dd9
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
testb %al, %al
je 0x150dd9
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x20, (%rax,%rcx)
incq 0x8(%rbx)
movq 0x10(%r14), %rdi
movzwl 0x9(%rdi), %eax
movl %eax, %ecx
shrl $0x8, %ecx
testb $0x3, %cl
je 0x150e27
andl $0x3, %ecx
cmpl $0x2, %ecx
jne 0x150e08
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
testb %al, %al
jne 0x150e27
movq 0x10(%r14), %rdi
movzwl 0x9(%rdi), %eax
movzwl %ax, %eax
shrl $0xa, %eax
testb $0x3, %al
je 0x150e27
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x150e43
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
testb %al, %al
je 0x150e43
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x28, (%rax,%rcx)
incq 0x8(%rbx)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1441a8
movb $0x2a, %al
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movb %al, (%rcx,%rdx)
incq 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
/llvm/Demangle/ItaniumDemangle.h
|
llvm::itanium_demangle::ObjCProtoName::isObjCObject() const
|
bool isObjCObject() const {
return Ty->getKind() == KNameType &&
static_cast<const NameType *>(Ty)->getName() == "objc_object";
}
|
movq 0x10(%rdi), %rax
cmpb $0x8, 0x8(%rax)
jne 0x150f4d
cmpq $0xb, 0x10(%rax)
jne 0x150f4d
movq 0x18(%rax), %rax
movabsq $0x6a626f5f636a626f, %rcx # imm = 0x6A626F5F636A626F
xorq (%rax), %rcx
movabsq $0x7463656a626f5f63, %rdx # imm = 0x7463656A626F5F63
xorq 0x3(%rax), %rdx
orq %rcx, %rdx
sete %al
retq
xorl %eax, %eax
retq
|
/llvm/Demangle/ItaniumDemangle.h
|
tf::Taskflow::_dump(std::ostream&, tf::Graph const*, tf::Taskflow::Dumper&) const
|
inline void Taskflow::_dump(
std::ostream& os, const Graph* graph, Dumper& dumper
) const {
for(auto itr = graph->begin(); itr != graph->end(); ++itr) {
Node* n = itr->get();
// regular task
if(n->_handle.index() != Node::MODULE) {
_dump(os, n, dumper);
}
// module task
else {
//auto module = &(std::get_if<Node::Module>(&n->_handle)->module);
auto module = &(std::get_if<Node::Module>(&n->_handle)->graph);
os << 'p' << n << "[shape=box3d, color=blue, label=\"";
if(n->_name.empty()) os << 'p' << n;
else os << n->_name;
if(dumper.visited.find(module) == dumper.visited.end()) {
dumper.visited[module] = dumper.id++;
dumper.stack.push({n, module});
}
os << " [m" << dumper.visited[module] << "]\"];\n";
//for(const auto s : n->_successors) {
for(size_t i=0; i<n->_num_successors; ++i) {
os << 'p' << n << "->" << 'p' << n->_edges[i] << ";\n";
}
}
}
}
|
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rdi
callq 0x1b3b0
movq %rax, 0x70(%rsp)
movq 0x80(%rsp), %rdi
callq 0x1b3e0
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x325f0
testb $0x1, %al
jne 0x2fb8d
jmp 0x2fe08
leaq 0x70(%rsp), %rdi
callq 0x32630
movq %rax, %rdi
callq 0x12e40
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
addq $0x88, %rdi
callq 0x9190
cmpq $0x6, %rax
je 0x2fbdc
movq 0x28(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x78(%rsp), %rcx
callq 0x32640
jmp 0x2fdf7
movq 0x60(%rsp), %rdi
addq $0x88, %rdi
callq 0x1b310
movq (%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x88(%rsp), %rdi
movl $0x70, %esi
callq 0x4410
movq %rax, %rdi
movq 0x60(%rsp), %rsi
callq 0x4290
movq %rax, %rdi
leaq 0x8b85(%rip), %rsi # 0x387a3
callq 0x4350
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x45d0
testb $0x1, %al
jne 0x2fc37
jmp 0x2fc58
movq 0x88(%rsp), %rdi
movl $0x70, %esi
callq 0x4410
movq %rax, %rdi
movq 0x60(%rsp), %rsi
callq 0x4290
jmp 0x2fc6e
movq 0x88(%rsp), %rdi
movq 0x60(%rsp), %rsi
addq $0x8, %rsi
callq 0x42f0
movq 0x78(%rsp), %rdi
addq $0x58, %rdi
leaq 0x58(%rsp), %rsi
callq 0x329f0
movq %rax, 0x50(%rsp)
movq 0x78(%rsp), %rdi
addq $0x58, %rdi
callq 0x32a20
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x329d0
testb $0x1, %al
jne 0x2fcae
jmp 0x2fd0e
movq 0x78(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x78(%rsp), %rdi
addq $0x58, %rdi
leaq 0x58(%rsp), %rsi
callq 0x2fa90
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x78(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x32a50
movq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x2fa30
movq 0x88(%rsp), %rdi
leaq 0x8aa8(%rip), %rsi # 0x387c5
callq 0x4350
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdi
addq $0x58, %rdi
leaq 0x58(%rsp), %rsi
callq 0x2fa90
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
callq 0x40a0
movq %rax, %rdi
leaq 0x8a78(%rip), %rsi # 0x387c9
callq 0x4350
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x60(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x2fdf5
movq 0x88(%rsp), %rdi
movl $0x70, %esi
callq 0x4410
movq %rax, %rdi
movq 0x60(%rsp), %rsi
callq 0x4290
movq %rax, %rdi
leaq 0x8a33(%rip), %rsi # 0x387cf
callq 0x4350
movq %rax, %rdi
movl $0x70, %esi
callq 0x4410
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
addq $0x48, %rdi
movq 0x30(%rsp), %rsi
callq 0x11cb0
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0x4290
movq %rax, %rdi
leaq 0x89c3(%rip), %rsi # 0x387a0
callq 0x4350
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x2fd5f
jmp 0x2fdf7
jmp 0x2fdf9
leaq 0x70(%rsp), %rdi
callq 0x32a80
jmp 0x2fb63
addq $0x98, %rsp
retq
|
/taskflow[P]taskflow/taskflow/core/taskflow.hpp
|
test
|
int test(char *URL)
{
CURLcode res;
CURL *curl;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
fprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(!curl) {
fprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
test_setopt(curl, CURLOPT_URL, URL);
test_setopt(curl, CURLOPT_FILETIME, 1L);
test_setopt(curl, CURLOPT_VERBOSE, 1L);
res = curl_easy_perform(curl);
test_cleanup:
curl_easy_cleanup(curl);
curl_global_cleanup();
return (int)res;
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x3, %edi
callq 0x10c0
testl %eax, %eax
je 0x1210
movq 0x2de8(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xe02(%rip), %rsi # 0x2004
xorl %eax, %eax
callq 0x10a0
movl $0x7e, %ebp
jmp 0x127a
callq 0x1050
testq %rax, %rax
je 0x1281
movq %rax, %rbx
movq %rax, %rdi
movl $0x2712, %esi # imm = 0x2712
movq %r14, %rdx
xorl %eax, %eax
callq 0x10b0
testl %eax, %eax
jne 0x126b
movl $0x1, %edx
movq %rbx, %rdi
movl $0x45, %esi
xorl %eax, %eax
callq 0x10b0
testl %eax, %eax
jne 0x126b
movl $0x1, %edx
movq %rbx, %rdi
movl $0x29, %esi
xorl %eax, %eax
callq 0x10b0
testl %eax, %eax
jne 0x126b
movq %rbx, %rdi
callq 0x1040
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1090
callq 0x10d0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2d58(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xd8d(%rip), %rsi # 0x201f
xorl %eax, %eax
callq 0x10a0
callq 0x10d0
jmp 0x1209
nop
|
/komeilkma[P]curl/tests/libtest/lib520.c
|
select_wrapper
|
int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset. IOW Winsock
* select() can not be used to sleep without a single fd_set.
*/
if(!nfds) {
Sleep((1000*tv->tv_sec) + (DWORD)(((double)tv->tv_usec)/1000.0));
return 0;
}
#endif
return select(nfds, rd, wr, exc, tv);
}
|
testl %edi, %edi
jns 0x1080
pushq %rax
callq 0x1030
movl $0x16, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
|
/komeilkma[P]curl/tests/libtest/first.c
|
hexdump
|
char *hexdump(const unsigned char *buffer, size_t len)
{
static char dump[200 * 3 + 1];
char *p = dump;
size_t i;
if(len > 200)
return NULL;
for(i = 0; i<len; i++, p += 3)
msnprintf(p, 4, "%02x ", buffer[i]);
return dump;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0xc8, %rsi
jbe 0x1323
xorl %ebx, %ebx
jmp 0x136d
movq %rsi, %r14
testq %rsi, %rsi
je 0x1366
movq %rdi, %r15
leaq 0x2d6b(%rip), %rbx # 0x40a0
leaq 0xcfc(%rip), %r12 # 0x2038
xorl %ebp, %ebp
movq %rbx, %r13
movzbl (%r15,%rbp), %ecx
movl $0x4, %esi
movq %r13, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1060
incq %rbp
addq $0x3, %r13
cmpq %rbp, %r14
jne 0x1341
jmp 0x136d
leaq 0x2d33(%rip), %rbx # 0x40a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/komeilkma[P]curl/tests/libtest/first.c
|
testing::internal::ExitSummary[abi:cxx11](int)
|
static std::string ExitSummary(int exit_code) {
Message m;
#if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_FUCHSIA)
m << "Exited with exit status " << exit_code;
#else
if (WIFEXITED(exit_code)) {
m << "Exited with exit status " << WEXITSTATUS(exit_code);
} else if (WIFSIGNALED(exit_code)) {
m << "Terminated by signal " << WTERMSIG(exit_code);
}
#ifdef WCOREDUMP
if (WCOREDUMP(exit_code)) {
m << " (core dumped)";
}
#endif
#endif // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
return m.GetString();
}
|
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x74060
movl 0x4c(%rsp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x66a81
leaq 0x5d2d3(%rip), %rsi # 0xc3d0a
leaq 0x40(%rsp), %rdi
callq 0x98420
movq %rax, 0x10(%rsp)
jmp 0x66a48
movq 0x10(%rsp), %rdi
movzbl 0x4d(%rsp), %eax
movl %eax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x97500
jmp 0x66a62
jmp 0x66acd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xe940
jmp 0x66b15
movl 0x4c(%rsp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x66acb
leaq 0x5d287(%rip), %rsi # 0xc3d23
leaq 0x40(%rsp), %rdi
callq 0x979b0
movq %rax, 0x8(%rsp)
jmp 0x66aad
movq 0x8(%rsp), %rdi
movl 0x4c(%rsp), %eax
andl $0x7f, %eax
movl %eax, 0x2c(%rsp)
leaq 0x2c(%rsp), %rsi
callq 0x97500
jmp 0x66ac9
jmp 0x66acb
jmp 0x66acd
movl 0x4c(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x66af0
leaq 0x5d257(%rip), %rsi # 0xc3d39
leaq 0x40(%rsp), %rdi
callq 0x982c0
jmp 0x66aee
jmp 0x66af0
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x66b20
jmp 0x66b01
leaq 0x40(%rsp), %rdi
callq 0xe940
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xad30
nop
|
/todo-group[P]lattice/build_O0/_deps/googletest-src/googletest/src/gtest-death-test.cc
|
testing::internal::ForkingDeathTest::Wait()
|
int ForkingDeathTest::Wait() {
if (!spawned()) return 0;
ReadAndInterpretStatusByte();
int status_value;
GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
set_status(status_value);
return status_value;
}
|
subq $0x158, %rsp # imm = 0x158
movq %rdi, 0x148(%rsp)
movq 0x148(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x962d0
testb $0x1, %al
jne 0x66c45
movl $0x0, 0x154(%rsp)
jmp 0x66ed8
movq 0x18(%rsp), %rdi
callq 0x65590
jmp 0x66c51
movq 0x18(%rsp), %rax
movl 0x3c(%rax), %edi
leaq 0x144(%rsp), %rsi
xorl %edx, %edx
callq 0xa540
movl %eax, 0x140(%rsp)
xorl %eax, %eax
cmpl $-0x1, 0x140(%rsp)
movb %al, 0x17(%rsp)
jne 0x66c8e
callq 0xa080
cmpl $0x4, (%rax)
sete %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x66c51
cmpl $-0x1, 0x140(%rsp)
jne 0x66eaa
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xad40
movq 0x8(%rsp), %rdx
leaq 0x5b52c(%rip), %rsi # 0xc21eb
leaq 0x60(%rsp), %rdi
callq 0xaa90
jmp 0x66ccb
leaq 0x5b424(%rip), %rdx # 0xc20f6
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x15260
jmp 0x66ce6
leaq 0x5b512(%rip), %rdx # 0xc21ff
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x15260
jmp 0x66d04
movl $0x43d, 0x24(%rsp) # imm = 0x43D
leaq 0x28(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x961d0
jmp 0x66d1d
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x152b0
jmp 0x66d39
leaq 0x5cb3a(%rip), %rdx # 0xc387a
leaq 0xe0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x15260
jmp 0x66d57
leaq 0x5b633(%rip), %rdx # 0xc2391
leaq 0x100(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x15260
jmp 0x66d75
leaq 0x5b6a0(%rip), %rdx # 0xc241c
leaq 0x120(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x15260
jmp 0x66d93
leaq 0x120(%rsp), %rdi
callq 0x653d0
jmp 0x66da2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x66e9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x66e94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x66e87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x66e7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x66e70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x66e63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x66e56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x66e49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x120(%rsp), %rdi
callq 0xaef8
leaq 0x100(%rsp), %rdi
callq 0xaef8
leaq 0xe0(%rsp), %rdi
callq 0xaef8
leaq 0xc0(%rsp), %rdi
callq 0xaef8
leaq 0x28(%rsp), %rdi
callq 0xaef8
leaq 0xa0(%rsp), %rdi
callq 0xaef8
leaq 0x80(%rsp), %rdi
callq 0xaef8
leaq 0x60(%rsp), %rdi
callq 0xaef8
leaq 0x5f(%rsp), %rdi
callq 0xa760
jmp 0x66ee7
jmp 0x66eac
callq 0x96260
testb $0x1, %al
jne 0x66c4f
movq 0x18(%rsp), %rdi
movl 0x144(%rsp), %esi
callq 0x96720
movl 0x144(%rsp), %eax
movl %eax, 0x154(%rsp)
movl 0x154(%rsp), %eax
addq $0x158, %rsp # imm = 0x158
retq
movq 0x50(%rsp), %rdi
callq 0xad30
nopw %cs:(%rax,%rax)
|
/todo-group[P]lattice/build_O0/_deps/googletest-src/googletest/src/gtest-death-test.cc
|
testing::internal::FormatEpochTimeInMillisAsIso8601[abi:cxx11](long)
|
std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
struct tm time_struct;
if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
return "";
// YYYY-MM-DDThh:mm:ss.sss
return StreamableToString(time_struct.tm_year + 1900) + "-" +
String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
String::FormatIntWidth2(time_struct.tm_mday) + "T" +
String::FormatIntWidth2(time_struct.tm_hour) + ":" +
String::FormatIntWidth2(time_struct.tm_min) + ":" +
String::FormatIntWidth2(time_struct.tm_sec) + "." +
String::FormatIntWidthN(static_cast<int>(ms % 1000), 3);
}
|
subq $0x2c8, %rsp # imm = 0x2C8
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x2c0(%rsp)
movq %rsi, 0x2b8(%rsp)
movq 0x2b8(%rsp), %rax
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rdi
leaq 0x280(%rsp), %rsi
callq 0x80b30
testb $0x1, %al
jne 0x8055c
leaq 0x27f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xad40
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x42fb8(%rip), %rsi # 0xc34d5
callq 0xaa90
jmp 0x80524
leaq 0x27f(%rsp), %rdi
callq 0xa760
jmp 0x80b10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
leaq 0x27f(%rsp), %rdi
callq 0xa760
jmp 0x80b1d
movl 0x294(%rsp), %eax
addl $0x76c, %eax # imm = 0x76C
movl %eax, 0xe4(%rsp)
leaq 0xe8(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0xe4(%rsp), %rsi
callq 0x961d0
movq (%rsp), %rsi
leaq 0x43713(%rip), %rdx # 0xc3ca6
leaq 0x108(%rsp), %rdi
callq 0x15260
jmp 0x805a2
movl 0x290(%rsp), %esi
incl %esi
leaq 0xc0(%rsp), %rdi
callq 0x785c0
jmp 0x805ba
leaq 0x128(%rsp), %rdi
leaq 0x108(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x152b0
jmp 0x805d9
leaq 0x436c6(%rip), %rdx # 0xc3ca6
leaq 0x148(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0x15260
jmp 0x805f7
movl 0x28c(%rsp), %esi
leaq 0xa0(%rsp), %rdi
callq 0x785c0
jmp 0x8060d
leaq 0x168(%rsp), %rdi
leaq 0x148(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
callq 0x152b0
jmp 0x8062c
leaq 0x43aff(%rip), %rdx # 0xc4132
leaq 0x188(%rsp), %rdi
leaq 0x168(%rsp), %rsi
callq 0x15260
jmp 0x8064a
movl 0x288(%rsp), %esi
leaq 0x80(%rsp), %rdi
callq 0x785c0
jmp 0x80660
leaq 0x1a8(%rsp), %rdi
leaq 0x188(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x152b0
jmp 0x8067f
leaq 0x43351(%rip), %rdx # 0xc39d7
leaq 0x1c8(%rsp), %rdi
leaq 0x1a8(%rsp), %rsi
callq 0x15260
jmp 0x8069d
movl 0x284(%rsp), %esi
leaq 0x60(%rsp), %rdi
callq 0x785c0
jmp 0x806b0
leaq 0x1e8(%rsp), %rdi
leaq 0x1c8(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x152b0
jmp 0x806cc
leaq 0x43304(%rip), %rdx # 0xc39d7
leaq 0x208(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
callq 0x15260
jmp 0x806ea
movl 0x280(%rsp), %esi
leaq 0x40(%rsp), %rdi
callq 0x785c0
jmp 0x806fd
leaq 0x228(%rsp), %rdi
leaq 0x208(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x152b0
jmp 0x80719
leaq 0x43157(%rip), %rdx # 0xc3877
leaq 0x248(%rsp), %rdi
leaq 0x228(%rsp), %rsi
callq 0x15260
jmp 0x80737
movq 0x2b8(%rsp), %rcx
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
movq %rax, %rdx
shrq $0x3f, %rdx
shrq $0x7, %rax
addl %edx, %eax
imull $0x3e8, %eax, %eax # imm = 0x3E8
movl %ecx, %esi
subl %eax, %esi
leaq 0x20(%rsp), %rdi
movl $0x3, %edx
callq 0x785f0
jmp 0x8077a
movq 0x10(%rsp), %rdi
leaq 0x248(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x152b0
jmp 0x80793
leaq 0x20(%rsp), %rdi
callq 0xaef8
leaq 0x248(%rsp), %rdi
callq 0xaef8
leaq 0x228(%rsp), %rdi
callq 0xaef8
leaq 0x40(%rsp), %rdi
callq 0xaef8
leaq 0x208(%rsp), %rdi
callq 0xaef8
leaq 0x1e8(%rsp), %rdi
callq 0xaef8
leaq 0x60(%rsp), %rdi
callq 0xaef8
leaq 0x1c8(%rsp), %rdi
callq 0xaef8
leaq 0x1a8(%rsp), %rdi
callq 0xaef8
leaq 0x80(%rsp), %rdi
callq 0xaef8
leaq 0x188(%rsp), %rdi
callq 0xaef8
leaq 0x168(%rsp), %rdi
callq 0xaef8
leaq 0xa0(%rsp), %rdi
callq 0xaef8
leaq 0x148(%rsp), %rdi
callq 0xaef8
leaq 0x128(%rsp), %rdi
callq 0xaef8
leaq 0xc0(%rsp), %rdi
callq 0xaef8
leaq 0x108(%rsp), %rdi
callq 0xaef8
leaq 0xe8(%rsp), %rdi
callq 0xaef8
jmp 0x80b10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80b01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80af4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80ae7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80ada
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80acd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80ac0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80ab3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80aa6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80a99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80a8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80a7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80a75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80a68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80a5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80a51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80a44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
jmp 0x80a37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xaef8
leaq 0x248(%rsp), %rdi
callq 0xaef8
leaq 0x228(%rsp), %rdi
callq 0xaef8
leaq 0x40(%rsp), %rdi
callq 0xaef8
leaq 0x208(%rsp), %rdi
callq 0xaef8
leaq 0x1e8(%rsp), %rdi
callq 0xaef8
leaq 0x60(%rsp), %rdi
callq 0xaef8
leaq 0x1c8(%rsp), %rdi
callq 0xaef8
leaq 0x1a8(%rsp), %rdi
callq 0xaef8
leaq 0x80(%rsp), %rdi
callq 0xaef8
leaq 0x188(%rsp), %rdi
callq 0xaef8
leaq 0x168(%rsp), %rdi
callq 0xaef8
leaq 0xa0(%rsp), %rdi
callq 0xaef8
leaq 0x148(%rsp), %rdi
callq 0xaef8
leaq 0x128(%rsp), %rdi
callq 0xaef8
leaq 0xc0(%rsp), %rdi
callq 0xaef8
leaq 0x108(%rsp), %rdi
callq 0xaef8
leaq 0xe8(%rsp), %rdi
callq 0xaef8
jmp 0x80b1d
movq 0x18(%rsp), %rax
addq $0x2c8, %rsp # imm = 0x2C8
retq
movq 0x270(%rsp), %rdi
callq 0xad30
nopw (%rax,%rax)
|
/todo-group[P]lattice/build_O0/_deps/googletest-src/googletest/src/gtest.cc
|
testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*)
|
void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
const char* data) {
const char* segment = data;
*stream << "<![CDATA[";
for (;;) {
const char* const next_segment = strstr(segment, "]]>");
if (next_segment != nullptr) {
stream->write(segment,
static_cast<std::streamsize>(next_segment - segment));
*stream << "]]>]]><![CDATA[";
segment = next_segment + strlen("]]>");
} else {
*stream << segment;
break;
}
}
*stream << "]]>";
}
|
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x42a6e(%rip), %rsi # 0xc35f2
callq 0xa670
movq 0x10(%rsp), %rdi
leaq 0x42a50(%rip), %rsi # 0xc35e5
callq 0xa130
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x80be4
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
subq %rax, %rdx
callq 0xa9f0
movq 0x20(%rsp), %rdi
leaq 0x42a1a(%rip), %rsi # 0xc35e9
callq 0xa670
movq 0x8(%rsp), %rax
addq $0x3, %rax
movq %rax, 0x10(%rsp)
jmp 0x80bf5
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa670
jmp 0x80bf7
jmp 0x80b89
movq 0x20(%rsp), %rdi
leaq 0x429e2(%rip), %rsi # 0xc35e5
callq 0xa670
addq $0x28, %rsp
retq
nopl (%rax)
|
/todo-group[P]lattice/build_O0/_deps/googletest-src/googletest/src/gtest.cc
|
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::~Matcher()
|
class GTEST_API_ Matcher<std::string>
: public internal::MatcherBase<std::string> {
public:
Matcher() = default;
explicit Matcher(const MatcherInterface<const std::string&>* impl)
: internal::MatcherBase<std::string>(impl) {}
explicit Matcher(const MatcherInterface<std::string>* impl)
: internal::MatcherBase<std::string>(impl) {}
template <typename M, typename = typename std::remove_reference<
M>::type::is_gtest_matcher>
Matcher(M&& m) // NOLINT
: internal::MatcherBase<std::string>(std::forward<M>(m)) {}
// Allows the user to write str instead of Eq(str) sometimes, where
// str is a string object.
Matcher(const std::string& s); // NOLINT
// Allows the user to write "foo" instead of Eq("foo") sometimes.
Matcher(const char* s); // NOLINT
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x974b0
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0xa6b0
addq $0x18, %rsp
retq
nopl (%rax)
|
/todo-group[P]lattice/build_O0/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h
|
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&)
|
void OnTestEnd(const TestInfo& test_info) override {
SendLn("event=TestEnd&passed=" +
FormatBool((test_info.result())->Passed()) + "&elapsed_time=" +
StreamableToString((test_info.result())->elapsed_time()) + "ms");
}
|
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, (%rsp)
movq 0xe8(%rsp), %rdi
callq 0x96820
movq %rax, %rdi
callq 0x9caa0
movq (%rsp), %rsi
movzbl %al, %edx
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xabda0
movq 0x8(%rsp), %rdx
leaq 0x19651(%rip), %rsi # 0xc46cb
leaq 0x68(%rsp), %rdi
callq 0x96a50
jmp 0xab086
leaq 0x19654(%rip), %rdx # 0xc46e1
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x15260
jmp 0xab0a1
movq 0xe8(%rsp), %rdi
callq 0x96820
movq %rax, %rdi
callq 0x9cb70
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x9cae0
jmp 0xab0cc
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x152b0
jmp 0xab0e8
leaq 0x19601(%rip), %rdx # 0xc46f0
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x15260
jmp 0xab106
movq (%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xabba0
jmp 0xab119
leaq 0xc8(%rsp), %rdi
callq 0xaef8
leaq 0xa8(%rsp), %rdi
callq 0xaef8
leaq 0x18(%rsp), %rdi
callq 0xaef8
leaq 0x88(%rsp), %rdi
callq 0xaef8
leaq 0x68(%rsp), %rdi
callq 0xaef8
leaq 0x48(%rsp), %rdi
callq 0xaef8
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xab202
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xab1f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xab1eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xab1e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xab1d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0xaef8
leaq 0xa8(%rsp), %rdi
callq 0xaef8
leaq 0x18(%rsp), %rdi
callq 0xaef8
leaq 0x88(%rsp), %rdi
callq 0xaef8
leaq 0x68(%rsp), %rdi
callq 0xaef8
leaq 0x48(%rsp), %rdi
callq 0xaef8
movq 0x40(%rsp), %rdi
callq 0xad30
nopw %cs:(%rax,%rax)
|
/todo-group[P]lattice/build_O0/_deps/googletest-src/googletest/src/gtest-internal-inl.h
|
container_suite::container_types()
|
void container_types()
{
static_assert(has_value_type<variable>::value, "variable::value_type missing");
static_assert(has_reference<variable>::value, "variable::reference missing");
static_assert(has_const_reference<variable>::value, "variable::const_reference missing");
static_assert(has_iterator<variable>::value, "variable::iterator missing");
static_assert(has_const_iterator<variable>::value, "variable::const_iterator missing");
static_assert(has_difference_type<variable>::value, "variable::difference_type missing");
static_assert(std::is_signed<variable::difference_type>::value, "variable::difference_type must be signed");
static_assert(std::is_same<variable::difference_type, variable::iterator::difference_type>::value, "Container and iterator must have same difference_type");
static_assert(std::is_same<variable::difference_type, variable::const_iterator::difference_type>::value, "Container and const_iterator must have same difference_type");
static_assert(has_size_type<variable>::value, "variable::size_type missing");
static_assert(std::is_unsigned<variable::size_type>::value, "variable::size_type must be unsigned");
static_assert(std::numeric_limits<variable::size_type>::max() >= std::numeric_limits<variable::difference_type>::max(), "size_type can represent any non-negative value of difference_type");
}
|
retq
|
/breese[P]trial/test/dynamic/variable_concept_suite.cpp
|
cnd_broadcast
|
int cnd_broadcast(cnd_t *cond)
{
#if defined(_TTHREAD_WIN32_)
int haveWaiters;
/* Are there any waiters? */
EnterCriticalSection(&cond->mWaitersCountLock);
haveWaiters = (cond->mWaitersCount > 0);
LeaveCriticalSection(&cond->mWaitersCountLock);
/* If we have any waiting threads, send them a signal */
if(haveWaiters)
{
if (SetEvent(cond->mEvents[_CONDITION_EVENT_ALL]) == 0)
{
return thrd_error;
}
}
return thrd_success;
#else
return pthread_cond_signal(cond) == 0 ? thrd_success : thrd_error;
#endif
}
|
pushq %rax
callq 0x11200
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, %eax
popq %rcx
retq
|
/drobilla[P]glfw/deps/tinycthread.c
|
glfwPlatformSetGammaRamp
|
void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
{
XRRCrtcGamma* gamma = XRRAllocGamma(ramp->size);
memcpy(gamma->red, ramp->red, ramp->size * sizeof(unsigned short));
memcpy(gamma->green, ramp->green, ramp->size * sizeof(unsigned short));
memcpy(gamma->blue, ramp->blue, ramp->size * sizeof(unsigned short));
XRRSetCrtcGamma(_glfw.x11.display, monitor->x11.crtc, gamma);
XRRFreeGamma(gamma);
}
else if (_glfw.x11.vidmode.available)
{
XF86VidModeSetGammaRamp(_glfw.x11.display,
_glfw.x11.screen,
ramp->size,
(unsigned short*) ramp->red,
(unsigned short*) ramp->green,
(unsigned short*) ramp->blue);
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x35b5c(%rip), %r12 # 0x53150
cmpl $0x0, 0xbe8(%r12)
je 0x1d67a
cmpl $0x0, 0xbfc(%r12)
jne 0x1d67a
movq %rdi, %r14
movl 0x18(%rbx), %edi
callq 0x11100
movq %rax, %r15
movq 0x8(%rax), %rdi
movq (%rbx), %rsi
movl 0x18(%rbx), %edx
addq %rdx, %rdx
callq 0x11b00
movq 0x10(%r15), %rdi
movq 0x8(%rbx), %rsi
movl 0x18(%rbx), %edx
addq %rdx, %rdx
callq 0x11b00
movq 0x18(%r15), %rdi
movq 0x10(%rbx), %rsi
movl 0x18(%rbx), %edx
addq %rdx, %rdx
callq 0x11b00
movq 0x548(%r12), %rdi
movq 0x88(%r14), %rsi
movq %r15, %rdx
callq 0x11280
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x116d0
cmpl $0x0, 0xc60(%r12)
je 0x1d6b8
movq 0xc88(%r12), %rax
movq 0x548(%r12), %rdi
movl 0x550(%r12), %esi
movl 0x18(%rbx), %edx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
movq 0x10(%rbx), %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/drobilla[P]glfw/src/x11_monitor.c
|
glfwCreateStandardCursor
|
GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape)
{
_GLFWcursor* cursor;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (shape != GLFW_ARROW_CURSOR &&
shape != GLFW_IBEAM_CURSOR &&
shape != GLFW_CROSSHAIR_CURSOR &&
shape != GLFW_HAND_CURSOR &&
shape != GLFW_HRESIZE_CURSOR &&
shape != GLFW_VRESIZE_CURSOR)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid standard cursor 0x%08X", shape);
return NULL;
}
cursor = calloc(1, sizeof(_GLFWcursor));
cursor->next = _glfw.cursorListHead;
_glfw.cursorListHead = cursor;
if (!_glfwPlatformCreateStandardCursor(cursor, shape))
{
glfwDestroyCursor((GLFWcursor*) cursor);
return NULL;
}
return (GLFWcursor*) cursor;
}
|
pushq %r15
pushq %r14
pushq %rbx
leaq 0x61f01(%rip), %r15 # 0x6b1a8
cmpl $0x0, (%r15)
je 0x92d6
movl %edi, %r14d
leal -0x36007(%r14), %eax
cmpl $-0x7, %eax
ja 0x92e8
leaq 0x40ccc(%rip), %rsi # 0x49f8f
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
movl %r14d, %edx
xorl %eax, %eax
callq 0x795b
jmp 0x9324
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x795b
jmp 0x9324
movl $0x1, %edi
movl $0x10, %esi
callq 0x67a0
movq %rax, %rbx
movq 0x3e8(%r15), %rax
movq %rax, (%rbx)
movq %rbx, 0x3e8(%r15)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x13b11
testl %eax, %eax
jne 0x9324
movq %rbx, %rdi
callq 0x9211
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c
|
glfwJoystickPresent
|
GLFWAPI int glfwJoystickPresent(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
return GLFW_FALSE;
}
js = _glfw.joysticks + jid;
if (!js->present)
return GLFW_FALSE;
return _glfwPlatformPollJoystick(js, _GLFW_POLL_PRESENCE);
}
|
pushq %rax
testl %edi, %edi
js 0x9673
cmpl $0x10, %edi
jae 0x9692
leaq 0x61b72(%rip), %rax # 0x6b1a8
cmpl $0x0, (%rax)
je 0x9661
movl %edi, %ecx
imulq $0x2018, %rcx, %rcx # imm = 0x2018
cmpl $0x0, 0x408(%rax,%rcx)
je 0x966f
leaq (%rax,%rcx), %rdi
addq $0x408, %rdi # imm = 0x408
xorl %esi, %esi
popq %rax
jmp 0x17804
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x795b
xorl %eax, %eax
popq %rcx
retq
leaq 0x40b83(%rip), %rdi # 0x4a1fd
leaq 0x406a5(%rip), %rsi # 0x49d26
leaq 0x40b8c(%rip), %rcx # 0x4a214
movl $0x3a0, %edx # imm = 0x3A0
callq 0x61b0
leaq 0x40b98(%rip), %rdi # 0x4a231
leaq 0x40686(%rip), %rsi # 0x49d26
leaq 0x40b6d(%rip), %rcx # 0x4a214
movl $0x3a1, %edx # imm = 0x3A1
callq 0x61b0
|
/apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c
|
glfwGetJoystickAxes
|
GLFWAPI const float* glfwGetJoystickAxes(int jid, int* count)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
return NULL;
}
js = _glfw.joysticks + jid;
if (!js->present)
return NULL;
if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_AXES))
return NULL;
*count = js->axisCount;
return js->axes;
}
|
pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x973e
cmpl $0x10, %edi
jae 0x975d
movq %rsi, %rbx
testq %rsi, %rsi
je 0x977c
movl $0x0, (%rbx)
leaq 0x61ac9(%rip), %rax # 0x6b1a8
cmpl $0x0, (%rax)
je 0x9723
movl %edi, %ecx
imulq $0x2018, %rcx, %rcx # imm = 0x2018
cmpl $0x0, 0x408(%rax,%rcx)
je 0x971f
leaq (%rax,%rcx), %r14
addq $0x408, %r14 # imm = 0x408
movq %r14, %rdi
movl $0x1, %esi
callq 0x17804
testl %eax, %eax
je 0x971f
movl 0x10(%r14), %eax
movl %eax, (%rbx)
movq 0x8(%r14), %rbx
jmp 0x9733
xorl %ebx, %ebx
jmp 0x9733
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x795b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x40ab8(%rip), %rdi # 0x4a1fd
leaq 0x405da(%rip), %rsi # 0x49d26
leaq 0x40af8(%rip), %rcx # 0x4a24b
movl $0x3b6, %edx # imm = 0x3B6
callq 0x61b0
leaq 0x40acd(%rip), %rdi # 0x4a231
leaq 0x405bb(%rip), %rsi # 0x49d26
leaq 0x40ad9(%rip), %rcx # 0x4a24b
movl $0x3b7, %edx # imm = 0x3B7
callq 0x61b0
leaq 0x40af5(%rip), %rdi # 0x4a278
leaq 0x4059c(%rip), %rsi # 0x49d26
leaq 0x40aba(%rip), %rcx # 0x4a24b
movl $0x3b8, %edx # imm = 0x3B8
callq 0x61b0
|
/apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c
|
glfwGetJoystickUserPointer
|
GLFWAPI void* glfwGetJoystickUserPointer(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
js = _glfw.joysticks + jid;
if (!js->present)
return NULL;
return js->userPointer;
}
|
pushq %rbx
testl %edi, %edi
js 0x9bbd
cmpl $0x10, %edi
jae 0x9bdc
leaq 0x6162e(%rip), %rax # 0x6b1a8
cmpl $0x0, (%rax)
je 0x9ba4
movl %edi, %ecx
imulq $0x2018, %rcx, %rcx # imm = 0x2018
cmpl $0x0, 0x408(%rax,%rcx)
je 0x9bb6
addq %rcx, %rax
addq $0x408, %rax # imm = 0x408
movq 0xb8(%rax), %rbx
jmp 0x9bb8
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x795b
jmp 0x9bb8
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
leaq 0x40639(%rip), %rdi # 0x4a1fd
leaq 0x4015b(%rip), %rsi # 0x49d26
leaq 0x40798(%rip), %rcx # 0x4a36a
movl $0x453, %edx # imm = 0x453
callq 0x61b0
leaq 0x4064e(%rip), %rdi # 0x4a231
leaq 0x4013c(%rip), %rsi # 0x49d26
leaq 0x40779(%rip), %rcx # 0x4a36a
movl $0x454, %edx # imm = 0x454
callq 0x61b0
|
/apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c
|
glfwGetGamepadName
|
GLFWAPI const char* glfwGetGamepadName(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
return NULL;
}
js = _glfw.joysticks + jid;
if (!js->present)
return NULL;
if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_PRESENCE))
return NULL;
if (!js->mapping)
return NULL;
return js->mapping->name;
}
|
pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x9f7d
cmpl $0x10, %edi
jae 0x9f9c
leaq 0x61286(%rip), %rax # 0x6b1a8
cmpl $0x0, (%rax)
je 0x9f5e
movl %edi, %ecx
imulq $0x2018, %rcx, %rcx # imm = 0x2018
cmpl $0x0, 0x408(%rax,%rcx)
je 0x9f70
leaq (%rax,%rcx), %r14
addq $0x408, %r14 # imm = 0x408
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x17804
testl %eax, %eax
je 0x9f72
movq 0xe8(%r14), %rbx
jmp 0x9f72
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x795b
jmp 0x9f72
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x40279(%rip), %rdi # 0x4a1fd
leaq 0x3fd9b(%rip), %rsi # 0x49d26
leaq 0x4045b(%rip), %rcx # 0x4a3ed
movl $0x4bf, %edx # imm = 0x4BF
callq 0x61b0
leaq 0x4028e(%rip), %rdi # 0x4a231
leaq 0x3fd7c(%rip), %rsi # 0x49d26
leaq 0x4043c(%rip), %rcx # 0x4a3ed
movl $0x4c0, %edx # imm = 0x4C0
callq 0x61b0
|
/apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c
|
glfwFreeMonitor
|
void _glfwFreeMonitor(_GLFWmonitor* monitor)
{
if (monitor == NULL)
return;
_glfwPlatformFreeMonitor(monitor);
_glfwFreeGammaArrays(&monitor->originalRamp);
_glfwFreeGammaArrays(&monitor->currentRamp);
free(monitor->modes);
free(monitor);
}
|
testq %rdi, %rdi
je 0xa69a
pushq %rbx
movq %rdi, %rbx
callq 0xf5b6
leaq 0xc0(%rbx), %rdi
callq 0xa6dd
leaq 0xe0(%rbx), %rdi
callq 0xa6dd
movq 0x98(%rbx), %rdi
callq 0x63a0
movq %rbx, %rdi
popq %rbx
jmp 0x63a0
retq
|
/apitrace[P]apitrace-tests/thirdparty/glfw/src/monitor.c
|
glfwGetMonitorPos
|
GLFWAPI void glfwGetMonitorPos(GLFWmonitor* handle, int* xpos, int* ypos)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (xpos)
*xpos = 0;
if (ypos)
*ypos = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetMonitorPos(monitor, xpos, ypos);
}
|
testq %rdi, %rdi
je 0xaa3c
testq %rsi, %rsi
je 0xaa12
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0xaa1d
movl $0x0, (%rdx)
leaq 0x60784(%rip), %rax # 0x6b1a8
cmpl $0x0, (%rax)
je 0xaa2e
jmp 0xf5b7
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x795b
pushq %rax
leaq 0x3fb83(%rip), %rdi # 0x4a5c7
leaq 0x3faed(%rip), %rsi # 0x4a538
leaq 0x3fb85(%rip), %rcx # 0x4a5d7
movl $0x145, %edx # imm = 0x145
callq 0x61b0
|
/apitrace[P]apitrace-tests/thirdparty/glfw/src/monitor.c
|
glfwGetVideoModes
|
GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!refreshVideoModes(monitor))
return NULL;
*count = monitor->modeCount;
return monitor->modes;
}
|
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xad09
movq %rsi, %r14
testq %rsi, %rsi
je 0xad28
movl $0x0, (%r14)
leaq 0x604e1(%rip), %rax # 0x6b1a8
cmpl $0x0, (%rax)
je 0xacea
movq %rdi, %rbx
callq 0xa87e
testl %eax, %eax
je 0xacfc
movl 0xa0(%rbx), %eax
movl %eax, (%r14)
movq 0x98(%rbx), %rbx
jmp 0xacfe
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x795b
jmp 0xacfe
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3f8b7(%rip), %rdi # 0x4a5c7
leaq 0x3f821(%rip), %rsi # 0x4a538
leaq 0x3fa45(%rip), %rcx # 0x4a763
movl $0x1ac, %edx # imm = 0x1AC
callq 0x61b0
leaq 0x3f549(%rip), %rdi # 0x4a278
leaq 0x3f802(%rip), %rsi # 0x4a538
leaq 0x3fa26(%rip), %rcx # 0x4a763
movl $0x1ad, %edx # imm = 0x1AD
callq 0x61b0
|
/apitrace[P]apitrace-tests/thirdparty/glfw/src/monitor.c
|
glfwSetGammaRamp
|
GLFWAPI void glfwSetGammaRamp(GLFWmonitor* handle, const GLFWgammaramp* ramp)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
assert(ramp != NULL);
assert(ramp->size > 0);
assert(ramp->red != NULL);
assert(ramp->green != NULL);
assert(ramp->blue != NULL);
if (ramp->size <= 0)
{
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid gamma ramp size %i",
ramp->size);
return;
}
_GLFW_REQUIRE_INIT();
if (!monitor->originalRamp.size)
{
if (!_glfwPlatformGetGammaRamp(monitor, &monitor->originalRamp))
return;
}
_glfwPlatformSetGammaRamp(monitor, ramp);
}
|
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb069
movq %rsi, %rbx
testq %rsi, %rsi
je 0xb088
cmpl $0x0, 0x18(%rbx)
je 0xb0a7
cmpq $0x0, (%rbx)
je 0xb0c6
cmpq $0x0, 0x8(%rbx)
je 0xb0e5
cmpq $0x0, 0x10(%rbx)
je 0xb104
leaq 0x60192(%rip), %rax # 0x6b1a8
cmpl $0x0, (%rax)
je 0xb04c
movq %rdi, %r14
cmpl $0x0, 0xd8(%rdi)
jne 0xb03a
leaq 0xc0(%r14), %rsi
movq %r14, %rdi
callq 0xfb01
testl %eax, %eax
je 0xb061
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfc38
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x795b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3f557(%rip), %rdi # 0x4a5c7
leaq 0x3f4c1(%rip), %rsi # 0x4a538
leaq 0x3f7f3(%rip), %rcx # 0x4a871
movl $0x205, %edx # imm = 0x205
callq 0x61b0
leaq 0x3f81e(%rip), %rdi # 0x4a8ad
leaq 0x3f4a2(%rip), %rsi # 0x4a538
leaq 0x3f7d4(%rip), %rcx # 0x4a871
movl $0x206, %edx # imm = 0x206
callq 0x61b0
leaq 0x3f80c(%rip), %rdi # 0x4a8ba
leaq 0x3f483(%rip), %rsi # 0x4a538
leaq 0x3f7b5(%rip), %rcx # 0x4a871
movl $0x207, %edx # imm = 0x207
callq 0x61b0
leaq 0x3f7fc(%rip), %rdi # 0x4a8c9
leaq 0x3f464(%rip), %rsi # 0x4a538
leaq 0x3f796(%rip), %rcx # 0x4a871
movl $0x208, %edx # imm = 0x208
callq 0x61b0
leaq 0x3f7ef(%rip), %rdi # 0x4a8db
leaq 0x3f445(%rip), %rsi # 0x4a538
leaq 0x3f777(%rip), %rcx # 0x4a871
movl $0x209, %edx # imm = 0x209
callq 0x61b0
leaq 0x3f7e4(%rip), %rdi # 0x4a8ef
leaq 0x3f426(%rip), %rsi # 0x4a538
leaq 0x3f758(%rip), %rcx # 0x4a871
movl $0x20a, %edx # imm = 0x20A
callq 0x61b0
nop
|
/apitrace[P]apitrace-tests/thirdparty/glfw/src/monitor.c
|
glfwGetVulkanResultString
|
const char* _glfwGetVulkanResultString(VkResult result)
{
switch (result)
{
case VK_SUCCESS:
return "Success";
case VK_NOT_READY:
return "A fence or query has not yet completed";
case VK_TIMEOUT:
return "A wait operation has not completed in the specified time";
case VK_EVENT_SET:
return "An event is signaled";
case VK_EVENT_RESET:
return "An event is unsignaled";
case VK_INCOMPLETE:
return "A return array was too small for the result";
case VK_ERROR_OUT_OF_HOST_MEMORY:
return "A host memory allocation has failed";
case VK_ERROR_OUT_OF_DEVICE_MEMORY:
return "A device memory allocation has failed";
case VK_ERROR_INITIALIZATION_FAILED:
return "Initialization of an object could not be completed for implementation-specific reasons";
case VK_ERROR_DEVICE_LOST:
return "The logical or physical device has been lost";
case VK_ERROR_MEMORY_MAP_FAILED:
return "Mapping of a memory object has failed";
case VK_ERROR_LAYER_NOT_PRESENT:
return "A requested layer is not present or could not be loaded";
case VK_ERROR_EXTENSION_NOT_PRESENT:
return "A requested extension is not supported";
case VK_ERROR_FEATURE_NOT_PRESENT:
return "A requested feature is not supported";
case VK_ERROR_INCOMPATIBLE_DRIVER:
return "The requested version of Vulkan is not supported by the driver or is otherwise incompatible";
case VK_ERROR_TOO_MANY_OBJECTS:
return "Too many objects of the type have already been created";
case VK_ERROR_FORMAT_NOT_SUPPORTED:
return "A requested format is not supported on this device";
case VK_ERROR_SURFACE_LOST_KHR:
return "A surface is no longer available";
case VK_SUBOPTIMAL_KHR:
return "A swapchain no longer matches the surface properties exactly, but can still be used";
case VK_ERROR_OUT_OF_DATE_KHR:
return "A surface has changed in such a way that it is no longer compatible with the swapchain";
case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
return "The display used by a swapchain does not use the same presentable image layout";
case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
return "The requested window is already connected to a VkSurfaceKHR, or to some other non-Vulkan API";
case VK_ERROR_VALIDATION_FAILED_EXT:
return "A validation layer found an error";
default:
return "ERROR: UNKNOWN VULKAN ERROR";
}
}
|
cmpl $0xc46535ff, %edi # imm = 0xC46535FF
jle 0xb388
leal 0xb(%rdi), %eax
cmpl $0x10, %eax
ja 0xb3c0
leaq 0x3f58d(%rip), %rcx # 0x4a904
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3f9c6(%rip), %rax # 0x4ad4d
retq
cmpl $0xc4653213, %edi # imm = 0xC4653213
jg 0xb3a8
cmpl $0xc4650b07, %edi # imm = 0xC4650B07
je 0xb3d8
cmpl $0xc4652a47, %edi # imm = 0xC4652A47
jne 0xb3e8
leaq 0x3faa5(%rip), %rax # 0x4ae4c
retq
cmpl $0xc4653214, %edi # imm = 0xC4653214
je 0xb3e0
cmpl $0xc46535ff, %edi # imm = 0xC46535FF
jne 0xb3e8
leaq 0x3fadc(%rip), %rax # 0x4ae9b
retq
cmpl $0xc4653600, %edi # imm = 0xC4653600
je 0xb418
cmpl $0x3b9acdeb, %edi # imm = 0x3B9ACDEB
jne 0xb3e8
leaq 0x3f9ca(%rip), %rax # 0x4ada1
retq
leaq 0x3fb19(%rip), %rax # 0x4aef8
retq
leaq 0x3fa0e(%rip), %rax # 0x4adf5
retq
leaq 0x3fb2b(%rip), %rax # 0x4af1a
retq
leaq 0x3f71f(%rip), %rax # 0x4ab16
retq
leaq 0x3f6eb(%rip), %rax # 0x4aaea
retq
leaq 0x3f67b(%rip), %rax # 0x4aa82
retq
leaq 0x3f85f(%rip), %rax # 0x4ac6e
retq
leaq 0x3f673(%rip), %rax # 0x4aa8a
retq
leaq 0x3f961(%rip), %rax # 0x4ad80
retq
leaq 0x3f73f(%rip), %rax # 0x4ab66
retq
leaq 0x3f88b(%rip), %rax # 0x4acba
retq
leaq 0x3f6c8(%rip), %rax # 0x4aaff
retq
leaq 0x3f856(%rip), %rax # 0x4ac95
retq
leaq 0x3f79c(%rip), %rax # 0x4abe3
retq
leaq 0x3f8c7(%rip), %rax # 0x4ad16
retq
leaq 0x3f7df(%rip), %rax # 0x4ac36
retq
leaq 0x3f652(%rip), %rax # 0x4aab1
retq
leaq 0x3f7a9(%rip), %rax # 0x4ac10
retq
leaq 0x3f6d3(%rip), %rax # 0x4ab42
retq
leaq 0x3f715(%rip), %rax # 0x4ab8c
retq
|
/apitrace[P]apitrace-tests/thirdparty/glfw/src/vulkan.c
|
glfwGetPhysicalDevicePresentationSupport
|
GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance,
VkPhysicalDevice device,
uint32_t queuefamily)
{
assert(instance != VK_NULL_HANDLE);
assert(device != VK_NULL_HANDLE);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
return GLFW_FALSE;
if (!_glfw.vk.extensions[0])
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Window surface creation extensions not found");
return GLFW_FALSE;
}
return _glfwPlatformGetPhysicalDevicePresentationSupport(instance,
device,
queuefamily);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb641
movq %rsi, %r14
testq %rsi, %rsi
je 0xb660
leaq 0x5fbce(%rip), %r12 # 0x6b1a8
cmpl $0x0, (%r12)
je 0xb617
movl %edx, %ebx
movq %rdi, %r15
movl $0x2, %edi
callq 0xb124
testl %eax, %eax
je 0xb633
cmpq $0x0, 0x20600(%r12)
je 0xb620
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x13f92
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
jmp 0xb62c
leaq 0x3fa7c(%rip), %rsi # 0x4b0a3
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x795b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3f9d2(%rip), %rdi # 0x4b01a
leaq 0x3f8e7(%rip), %rsi # 0x4af36
leaq 0x3f9df(%rip), %rcx # 0x4b035
movl $0x119, %edx # imm = 0x119
callq 0x61b0
leaq 0x3fa23(%rip), %rdi # 0x4b08a
leaq 0x3f8c8(%rip), %rsi # 0x4af36
leaq 0x3f9c0(%rip), %rcx # 0x4b035
movl $0x11a, %edx # imm = 0x11A
callq 0x61b0
|
/apitrace[P]apitrace-tests/thirdparty/glfw/src/vulkan.c
|
LoadParameters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
|
void LoadParameters(std::string file_name) {
cv::FileStorage fs(file_name, cv::FileStorage::READ);
if (!fs.isOpened()) {
std::cout << "Failed to open ini parameters" << std::endl;
exit(-1);
}
cv::Size cap_size;
fs["cam_model"] >> cam_model;
fs["cap_size" ] >> cap_size;
fs["Kl" ] >> Kl;
fs["Dl" ] >> Dl;
fs["xil" ] >> xil;
Rl = cv::Mat::eye(3, 3, CV_64F);
if (cam_model == "stereo") {
fs["Rl" ] >> Rl;
fs["Kr" ] >> Kr;
fs["Dr" ] >> Dr;
fs["xir" ] >> xir;
fs["Rr" ] >> Rr;
fs["T" ] >> Translation;
}
fs.release();
img_width = cap_size.width;
cap_cols = cap_size.width;
cap_rows = cap_size.height;
if (cam_model == "stereo")
img_width = cap_size.width / 2;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, %rsi
leaq 0x70(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rcx
xorl %edx, %edx
callq 0x40b0
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x48df
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x20(%rsp), %rdi
callq 0x41d0
testb %al, %al
je 0x4cc3
leaq 0x3766(%rip), %rdx # 0x805e
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x43e0
leaq 0x60(%rsp), %rdx
movq %r14, (%rdx)
movq $0x0, 0x8(%rdx)
movb $0x0, 0x10(%rdx)
leaq 0x6f10(%rip), %rsi # 0xb830
movq %rsp, %rdi
callq 0x43d0
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x493f
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x3722(%rip), %rdx # 0x8068
leaq 0x1c8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x43e0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x60(%rsp), %rbx
leaq 0x1c8(%rsp), %rsi
movq %rbx, %rdi
callq 0x42a0
leaq 0x1c0(%rsp), %rdi
movq %rbx, (%rdi)
movq %rsp, %rsi
movl $0x7fffffff, %edx # imm = 0x7FFFFFFF
callq 0x6f0a
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
cmpq $0x8, %rax
jne 0x49ae
movl (%rdi), %ebx
movl 0x4(%rdi), %ebp
jmp 0x49c0
xorl %ebp, %ebp
movl $0x0, %ebx
movl $0x0, %r14d
testq %rdi, %rdi
je 0x49d0
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42d0
movl %ebx, %r14d
leaq 0x369a(%rip), %rdx # 0x8071
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x43e0
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x4080
leaq 0x6958(%rip), %rsi # 0xb350
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4200
leaq 0x60(%rsp), %rdi
callq 0x44e0
leaq 0x3660(%rip), %rdx # 0x8074
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x43e0
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x4080
leaq 0x69db(%rip), %rsi # 0xb410
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4200
leaq 0x60(%rsp), %rdi
callq 0x44e0
leaq 0x3626(%rip), %rdx # 0x8077
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x43e0
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x4080
leaq 0x6a5e(%rip), %rsi # 0xb4d0
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4200
leaq 0x60(%rsp), %rdi
callq 0x44e0
leaq 0x60(%rsp), %rdi
movl $0x3, %esi
movl $0x3, %edx
movl $0x6, %ecx
callq 0x41a0
leaq 0x60(%rsp), %rsi
movq (%rsi), %rdi
movq (%rdi), %rax
leaq 0x6ade(%rip), %rdx # 0xb590
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq *0x18(%rax)
leaq 0x130(%rsp), %rdi
callq 0x44e0
leaq 0xd0(%rsp), %rdi
callq 0x44e0
leaq 0x70(%rsp), %rdi
callq 0x44e0
leaq 0x6d4b(%rip), %rdi # 0xb830
leaq 0x358f(%rip), %rsi # 0x807b
callq 0x4450
testl %eax, %eax
jne 0x4c67
leaq 0x3582(%rip), %rdx # 0x8082
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x43e0
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x4080
leaq 0x6a6f(%rip), %rsi # 0xb590
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4200
leaq 0x60(%rsp), %rdi
callq 0x44e0
leaq 0x3548(%rip), %rdx # 0x8085
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x43e0
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x4080
leaq 0x6852(%rip), %rsi # 0xb3b0
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4200
leaq 0x60(%rsp), %rdi
callq 0x44e0
leaq 0x350e(%rip), %rdx # 0x8088
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x43e0
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x4080
leaq 0x68d5(%rip), %rsi # 0xb470
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4200
leaq 0x60(%rsp), %rdi
callq 0x44e0
leaq 0x34d4(%rip), %rdx # 0x808b
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x43e0
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x4080
leaq 0x6958(%rip), %rsi # 0xb530
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4200
leaq 0x60(%rsp), %rdi
callq 0x44e0
leaq 0x349b(%rip), %rdx # 0x808f
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x43e0
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x4080
leaq 0x69db(%rip), %rsi # 0xb5f0
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4200
leaq 0x60(%rsp), %rdi
callq 0x44e0
leaq 0x3461(%rip), %rdx # 0x8092
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x43e0
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x4080
leaq 0x669e(%rip), %rsi # 0xb2f0
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4200
leaq 0x60(%rsp), %rdi
callq 0x44e0
leaq 0x20(%rsp), %rdi
callq 0x44a0
movl %r14d, 0x6670(%rip) # 0xb2e8
movl %r14d, 0x6661(%rip) # 0xb2e0
movl %ebp, 0x665f(%rip) # 0xb2e4
leaq 0x6ba4(%rip), %rdi # 0xb830
leaq 0x33e8(%rip), %rsi # 0x807b
callq 0x4450
testl %eax, %eax
jne 0x4cad
movl %r14d, %eax
shrl $0x1f, %eax
addl %r14d, %eax
sarl %eax
movl %eax, 0x663b(%rip) # 0xb2e8
leaq 0x20(%rsp), %rdi
callq 0x41e0
addq $0x1e0, %rsp # imm = 0x1E0
popq %rbx
popq %r14
popq %rbp
retq
movq 0x62fe(%rip), %rdi # 0xafc8
leaq 0x336f(%rip), %rsi # 0x8040
movl $0x1d, %edx
callq 0x4160
movq 0x62e6(%rip), %rdi # 0xafc8
callq 0x4170
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0x4410
jmp 0x4d24
jmp 0x4d6c
jmp 0x4d24
jmp 0x4d6c
jmp 0x4d24
jmp 0x4d6c
jmp 0x4d24
jmp 0x4d6c
jmp 0x4d24
jmp 0x4d6c
jmp 0x4d24
jmp 0x4d6c
jmp 0x4d6c
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x6d0a
jmp 0x4d6f
jmp 0x4d6c
jmp 0x4d24
jmp 0x4d6c
jmp 0x4d24
jmp 0x4d6c
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x44e0
jmp 0x4d6f
jmp 0x4d6c
jmp 0x4d6c
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x4d6f
movq 0x70(%rsp), %rsi
incq %rsi
jmp 0x4d95
jmp 0x4d6c
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x4d79
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x4d79
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x41e0
movq %rbx, %rdi
callq 0x4330
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4d6f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42d0
jmp 0x4d6f
|
/astar-ai[P]calicam/calicam.cpp
|
InitUndistortRectifyMap(cv::Mat, cv::Mat, cv::Mat, cv::Mat, cv::Mat, cv::Size_<int>, cv::Mat&, cv::Mat&)
|
void InitUndistortRectifyMap(cv::Mat K, cv::Mat D, cv::Mat xi, cv::Mat R,
cv::Mat P, cv::Size size,
cv::Mat& map1, cv::Mat& map2) {
map1 = cv::Mat(size, CV_32F);
map2 = cv::Mat(size, CV_32F);
double fx = K.at<double>(0,0);
double fy = K.at<double>(1,1);
double cx = K.at<double>(0,2);
double cy = K.at<double>(1,2);
double s = K.at<double>(0,1);
double xid = xi.at<double>(0,0);
double k1 = D.at<double>(0,0);
double k2 = D.at<double>(0,1);
double p1 = D.at<double>(0,2);
double p2 = D.at<double>(0,3);
cv::Mat KRi = (P * R).inv();
for (int r = 0; r < size.height; ++r) {
for (int c = 0; c < size.width; ++c) {
double xc = MatRowMul(KRi, c, r, 1., 0);
double yc = MatRowMul(KRi, c, r, 1., 1);
double zc = MatRowMul(KRi, c, r, 1., 2);
double rr = sqrt(xc * xc + yc * yc + zc * zc);
double xs = xc / rr;
double ys = yc / rr;
double zs = zc / rr;
double xu = xs / (zs + xid);
double yu = ys / (zs + xid);
double r2 = xu * xu + yu * yu;
double r4 = r2 * r2;
double xd = (1+k1*r2+k2*r4)*xu + 2*p1*xu*yu + p2*(r2+2*xu*xu);
double yd = (1+k1*r2+k2*r4)*yu + 2*p2*xu*yu + p1*(r2+2*yu*yu);
double u = fx * xd + s * yd + cx;
double v = fy * yd + cy;
map1.at<float>(r,c) = (float) u;
map2.at<float>(r,c) = (float) v;
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x508, %rsp # imm = 0x508
movq %r9, %rbx
movq %r8, (%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r14
movq 0x540(%rsp), %r12
movq (%r9), %rax
leaq 0xc0(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x1e8(%rsp), %r15
movq %r15, %rdi
movl $0x5, %edx
callq 0x4420
movq %r12, %rdi
movq %r15, %rsi
callq 0x4090
movq 0x548(%rsp), %r15
leaq 0x1e8(%rsp), %rdi
callq 0x44e0
movq (%rbx), %rax
leaq 0xb8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x1e8(%rsp), %r12
movq %r12, %rdi
movl $0x5, %edx
callq 0x4420
movq %r15, %rdi
movq %r12, %rsi
callq 0x4090
movq %rbx, %r15
leaq 0x1e8(%rsp), %rdi
callq 0x44e0
movq 0x10(%r14), %rax
movq 0x48(%r14), %rcx
movsd (%rax), %xmm0
movsd %xmm0, 0x88(%rsp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x80(%rsp)
movq (%rcx), %rcx
movsd 0x8(%rax,%rcx), %xmm0
movsd %xmm0, 0x78(%rsp)
movsd 0x10(%rax,%rcx), %xmm0
movsd %xmm0, 0x70(%rsp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x68(%rsp)
movq 0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x60(%rsp)
movq 0x10(%r13), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
leaq 0x3a8(%rsp), %r13
movq %r13, %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x4150
leaq 0x1e8(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4270
leaq 0xc8(%rsp), %r12
movq %r12, %rdi
callq 0x4080
leaq 0x1e8(%rsp), %r14
movq (%r14), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %r12, %rdx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq *0x18(%rax)
movl $0xd0, %ebx
addq %rbx, %r14
movq %r14, %rdi
callq 0x44e0
leaq 0x258(%rsp), %rdi
callq 0x44e0
leaq 0x1f8(%rsp), %rdi
callq 0x44e0
addq %rbx, %r13
movq %r13, %rdi
callq 0x44e0
leaq 0x418(%rsp), %rdi
callq 0x44e0
leaq 0x3b8(%rsp), %rdi
callq 0x44e0
movl 0x4(%r15), %eax
testl %eax, %eax
jle 0x5288
movsd 0x30(%rsp), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x28(%rsp), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movl (%r15), %ecx
xorl %ebx, %ebx
leaq 0x348(%rsp), %rbp
leaq 0xc8(%rsp), %r13
testl %ecx, %ecx
jle 0x5279
movq %r15, %r12
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movsd %xmm0, 0x38(%rsp)
xorl %r15d, %r15d
movq %rbp, %rdi
movq %r13, %rsi
callq 0x42b0
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
movq 0x358(%rsp), %rax
movsd 0x8(%rax), %xmm0
mulsd 0x38(%rsp), %xmm0
movsd (%rax), %xmm2
movapd %xmm1, 0x10(%rsp)
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
addsd 0x10(%rax), %xmm2
movapd %xmm2, 0xa0(%rsp)
movq %rbp, %r14
movq %rbp, %rdi
callq 0x44e0
leaq 0x188(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x42b0
movq 0x198(%rsp), %rax
movq 0x1d0(%rsp), %rcx
movq (%rcx), %rcx
movsd (%rax,%rcx), %xmm0
movsd %xmm0, 0x98(%rsp)
movsd 0x8(%rax,%rcx), %xmm0
movsd %xmm0, 0x90(%rsp)
movsd 0x10(%rax,%rcx), %xmm0
movapd %xmm0, (%rsp)
movq %rbp, %rdi
callq 0x44e0
leaq 0x128(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x42b0
movsd 0x38(%rsp), %xmm1
movsd 0x90(%rsp), %xmm3
mulsd %xmm1, %xmm3
movapd 0x10(%rsp), %xmm2
movsd 0x98(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
movapd (%rsp), %xmm3
addsd %xmm0, %xmm3
movapd %xmm3, (%rsp)
movq 0x138(%rsp), %rax
movq 0x170(%rsp), %rcx
movq (%rcx), %rcx
movsd 0x8(%rax,%rcx,2), %xmm0
mulsd (%rax,%rcx,2), %xmm2
mulsd %xmm1, %xmm0
addsd %xmm0, %xmm2
addsd 0x10(%rax,%rcx,2), %xmm2
movapd %xmm2, 0x10(%rsp)
movq %rbp, %rdi
callq 0x44e0
movapd (%rsp), %xmm6
movapd %xmm6, %xmm0
mulsd %xmm6, %xmm0
movapd 0xa0(%rsp), %xmm1
unpcklpd %xmm1, %xmm6 # xmm6 = xmm6[0],xmm1[0]
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movapd 0x10(%rsp), %xmm2
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
divsd %xmm0, %xmm2
addsd 0x60(%rsp), %xmm2
unpcklpd %xmm0, %xmm0 # xmm0 = xmm0[0,0]
divpd %xmm0, %xmm6
unpcklpd %xmm2, %xmm2 # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm6
movapd %xmm6, %xmm1
mulsd %xmm6, %xmm1
movapd %xmm6, %xmm0
unpckhpd %xmm6, %xmm0 # xmm0 = xmm0[1],xmm6[1]
movapd %xmm0, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
movsd 0x58(%rsp), %xmm1
mulsd %xmm3, %xmm1
movapd %xmm0, %xmm2
addsd %xmm0, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
movapd %xmm6, %xmm4
addsd %xmm6, %xmm4
mulsd %xmm6, %xmm4
addsd %xmm3, %xmm4
mulsd %xmm3, %xmm3
mulsd 0x50(%rsp), %xmm3
addsd 0x2e5f(%rip), %xmm1 # 0x8008
addsd %xmm3, %xmm1
movsd 0x48(%rsp), %xmm3
mulsd %xmm0, %xmm3
mulsd %xmm6, %xmm3
movapd %xmm1, %xmm5
mulsd %xmm0, %xmm5
addsd %xmm3, %xmm5
mulsd 0x28(%rsp), %xmm2
addsd %xmm5, %xmm2
mulsd 0x40(%rsp), %xmm0
mulsd %xmm6, %xmm0
mulsd %xmm6, %xmm1
addsd %xmm0, %xmm1
mulsd 0x88(%rsp), %xmm2
mulsd 0x30(%rsp), %xmm4
addsd %xmm1, %xmm4
movsd 0x80(%rsp), %xmm0
mulsd %xmm4, %xmm0
addsd %xmm2, %xmm0
addsd 0x68(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x540(%rsp), %rcx
movq 0x48(%rcx), %rax
movq (%rax), %rax
imulq %rbx, %rax
addq 0x10(%rcx), %rax
movss %xmm0, (%rax,%r15,4)
mulsd 0x78(%rsp), %xmm4
addsd 0x70(%rsp), %xmm4
xorps %xmm0, %xmm0
cvtsd2ss %xmm4, %xmm0
movq 0x548(%rsp), %rcx
movq 0x48(%rcx), %rax
movq (%rax), %rax
imulq %rbx, %rax
addq 0x10(%rcx), %rax
movss %xmm0, (%rax,%r15,4)
incq %r15
movslq (%r12), %rcx
cmpq %rcx, %r15
movq %r14, %rbp
jl 0x4fd3
movq %r12, %r15
movl 0x4(%r12), %eax
incq %rbx
movslq %eax, %rdx
cmpq %rdx, %rbx
jl 0x4fb8
leaq 0xc8(%rsp), %rdi
callq 0x44e0
addq $0x508, %rsp # imm = 0x508
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x44e0
leaq 0x1e8(%rsp), %rdi
callq 0x6d0a
jmp 0x52c9
movq %rax, %rbx
leaq 0x3a8(%rsp), %rdi
callq 0x6d0a
jmp 0x52fb
jmp 0x52da
movq %rax, %rbx
leaq 0x1e8(%rsp), %rdi
jmp 0x52f6
jmp 0x52eb
jmp 0x52eb
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x44e0
movq %rbx, %rdi
callq 0x4330
|
/astar-ai[P]calicam/calicam.cpp
|
InitRectifyMap()
|
void InitRectifyMap() {
double vfov_rad = vfov_now * CV_PI / 180.;
double focal = height_now / 2. / tan(vfov_rad / 2.);
Knew = (cv::Mat_<double>(3, 3) << focal, 0., width_now / 2. - 0.5,
0., focal, height_now / 2. - 0.5,
0., 0., 1.);
cv::Size img_size(width_now, height_now);
InitUndistortRectifyMap(Kl, Dl, xil, Rl, Knew,
img_size, smap[0][0], smap[0][1]);
std::cout << "Width: " << width_now << "\t"
<< "Height: " << height_now << "\t"
<< "V.Fov: " << vfov_now << "\n";
std::cout << "K Matrix: \n" << Knew << std::endl;
if (cam_model == "stereo") {
InitUndistortRectifyMap(Kr, Dr, xir, Rr, Knew,
img_size, smap[1][0], smap[1][1]);
std::cout << "Ndisp: " << ndisp_now << "\t"
<< "Wsize: " << wsize_now << "\n";
}
std::cout << std::endl;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4f0, %rsp # imm = 0x4F0
cvtsi2sdl 0x5f72(%rip), %xmm0 # 0xb28c
mulsd 0x2cee(%rip), %xmm0 # 0x8010
divsd 0x2cee(%rip), %xmm0 # 0x8018
cvtsi2sdl 0x5f62(%rip), %xmm1 # 0xb294
movsd %xmm1, 0x28(%rsp)
mulsd 0x2ce0(%rip), %xmm0 # 0x8020
callq 0x4400
movsd %xmm0, 0x58(%rsp)
leaq 0xd0(%rsp), %rbx
movq %rbx, %rdi
movl $0x3, %esi
movl $0x3, %edx
movl $0x6, %ecx
callq 0x4120
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x7180
movsd 0x28(%rsp), %xmm0
mulsd 0x2c9b(%rip), %xmm0 # 0x8020
divsd 0x58(%rsp), %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, 0x28(%rsp)
movsd %xmm0, (%rax)
movq 0x30(%rsp), %rbx
testq %rbx, %rbx
je 0x53d0
addq 0x38(%rsp), %rax
cmpq 0x50(%rsp), %rax
jb 0x53d2
leaq 0x30(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x4320
movq 0x30(%rsp), %rbx
movq 0x40(%rsp), %rax
jmp 0x53d2
xorl %ebx, %ebx
movq %rbx, (%rsp)
movq 0x38(%rsp), %rcx
movq 0x48(%rsp), %rdx
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x50(%rsp), %rdx
movq %rdx, 0x20(%rsp)
movq $0x0, (%rax)
testq %rbx, %rbx
je 0x542e
addq %rax, %rcx
cmpq %rdx, %rcx
jae 0x544f
xorps %xmm0, %xmm0
cvtsi2sdl 0x5e78(%rip), %xmm0 # 0xb290
mulsd 0x2c00(%rip), %xmm0 # 0x8020
addsd 0x2c00(%rip), %xmm0 # 0x8028
movsd %xmm0, (%rcx)
jmp 0x5495
xorps %xmm0, %xmm0
cvtsi2sdl 0x5e57(%rip), %xmm0 # 0xb290
mulsd 0x2bdf(%rip), %xmm0 # 0x8020
addsd 0x2bdf(%rip), %xmm0 # 0x8028
movsd %xmm0, (%rax)
jmp 0x54b4
movq %rsp, %rdi
movq %rax, 0x10(%rdi)
movl $0x1, %esi
movl $0x1, %edx
callq 0x4320
movq (%rsp), %rbx
xorps %xmm0, %xmm0
cvtsi2sdl 0x5e1c(%rip), %xmm0 # 0xb290
mulsd 0x2ba4(%rip), %xmm0 # 0x8020
addsd 0x2ba4(%rip), %xmm0 # 0x8028
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq %rax, %rcx
testq %rbx, %rbx
je 0x54b4
movq 0x8(%rsp), %rax
addq %rcx, %rax
cmpq 0x20(%rsp), %rax
jae 0x597d
movq $0x0, (%rax)
jmp 0x59ac
movq $0x0, (%rax)
xorps %xmm0, %xmm0
cvtsi2sdl 0x5dce(%rip), %xmm0 # 0xb294
mulsd 0x2b52(%rip), %xmm0 # 0x8020
addsd 0x2b52(%rip), %xmm0 # 0x8028
movsd %xmm0, (%rax)
movq $0x0, (%rax)
movq $0x0, (%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
xorl %ebx, %ebx
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x4370
movl $0xfffff000, %eax # imm = 0xFFFFF000
andl (%r14), %eax
orl $0x6, %eax
movl %eax, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x725e
leaq 0x62ac(%rip), %rdi # 0xb7d0
leaq 0x70(%rsp), %rsi
callq 0x4090
leaq 0x70(%rsp), %rdi
callq 0x4260
leaq 0xd0(%rsp), %rdi
callq 0x4260
movl 0x5d45(%rip), %ebp # 0xb290
movl 0x5d42(%rip), %r12d # 0xb294
leaq 0x5df7(%rip), %rsi # 0xb350
leaq 0x490(%rsp), %rdi
callq 0x42b0
leaq 0x5ea3(%rip), %rsi # 0xb410
leaq 0x430(%rsp), %rdi
callq 0x42b0
leaq 0x5f4f(%rip), %rsi # 0xb4d0
leaq 0x3d0(%rsp), %rdi
callq 0x42b0
leaq 0x5ffb(%rip), %rsi # 0xb590
leaq 0x370(%rsp), %rdi
callq 0x42b0
leaq 0x6227(%rip), %rsi # 0xb7d0
leaq 0x310(%rsp), %rdi
callq 0x42b0
leaq 0x68(%rsp), %r9
movl %ebp, (%r9)
movl %r12d, 0x4(%r9)
leaq 0x60e7(%rip), %rax # 0xb6b0
leaq 0x6080(%rip), %r10 # 0xb650
leaq 0x490(%rsp), %rdi
leaq 0x430(%rsp), %rsi
leaq 0x3d0(%rsp), %rdx
leaq 0x370(%rsp), %rcx
leaq 0x310(%rsp), %r8
pushq %rax
pushq %r10
callq 0x4d9c
addq $0x10, %rsp
leaq 0x310(%rsp), %rdi
callq 0x44e0
leaq 0x370(%rsp), %rdi
callq 0x44e0
leaq 0x3d0(%rsp), %rdi
callq 0x44e0
leaq 0x430(%rsp), %rdi
callq 0x44e0
leaq 0x490(%rsp), %rdi
callq 0x44e0
movq 0x597c(%rip), %rbx # 0xafc8
leaq 0x2a41(%rip), %rsi # 0x8094
movl $0x7, %edx
movq %rbx, %rdi
callq 0x4160
movl 0x5c2a(%rip), %esi # 0xb290
movq %rbx, %rdi
callq 0x41f0
movq %rax, %r14
leaq 0x2a24(%rip), %r15 # 0x809c
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4160
leaq 0x2a0f(%rip), %rsi # 0x809e
movl $0x8, %edx
movq %r14, %rdi
callq 0x4160
movl 0x5bf2(%rip), %esi # 0xb294
movq %r14, %rdi
callq 0x41f0
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4160
leaq 0x29e3(%rip), %rsi # 0x80a7
movl $0x7, %edx
movq %r14, %rdi
callq 0x4160
movl 0x5bb5(%rip), %esi # 0xb28c
movq %r14, %rdi
callq 0x41f0
leaq 0x29d3(%rip), %rsi # 0x80b9
movl $0x1, %edx
movq %rax, %rdi
callq 0x4160
leaq 0x29b5(%rip), %rsi # 0x80af
movl $0xb, %edx
movq %rbx, %rdi
callq 0x4160
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x4460
movq (%r14), %rsi
movq (%rsi), %rax
leaq 0x60aa(%rip), %rdx # 0xb7d0
leaq 0x70(%rsp), %rdi
callq *0x10(%rax)
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r15
testq %rax, %rax
je 0x577a
movq 0x5876(%rip), %r14 # 0xafc8
movq %r15, %rdi
callq 0x42f0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x4160
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r15
testq %rax, %rax
jne 0x5752
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x5789
callq 0x6d6e
movq 0xd8(%rsp), %rdi
testq %rdi, %rdi
je 0x579b
callq 0x6d6e
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4230
movq %rax, %rdi
callq 0x4220
leaq 0x6067(%rip), %rdi # 0xb830
leaq 0x28ab(%rip), %rsi # 0x807b
callq 0x4450
testl %eax, %eax
jne 0x5946
leaq 0x5bcc(%rip), %rsi # 0xb3b0
leaq 0x2b0(%rsp), %rdi
callq 0x42b0
leaq 0x5c78(%rip), %rsi # 0xb470
leaq 0x250(%rsp), %rdi
callq 0x42b0
leaq 0x5d24(%rip), %rsi # 0xb530
leaq 0x1f0(%rsp), %rdi
callq 0x42b0
leaq 0x5dd0(%rip), %rsi # 0xb5f0
leaq 0x190(%rsp), %rdi
callq 0x42b0
leaq 0x5f9c(%rip), %rsi # 0xb7d0
leaq 0x130(%rsp), %rdi
callq 0x42b0
leaq 0x60(%rsp), %r9
movl %ebp, (%r9)
movl %r12d, 0x4(%r9)
leaq 0x5f1c(%rip), %rax # 0xb770
leaq 0x5eb5(%rip), %r10 # 0xb710
leaq 0x2b0(%rsp), %rdi
leaq 0x250(%rsp), %rsi
leaq 0x1f0(%rsp), %rdx
leaq 0x190(%rsp), %rcx
leaq 0x130(%rsp), %r8
pushq %rax
pushq %r10
callq 0x4d9c
addq $0x10, %rsp
leaq 0x130(%rsp), %rdi
callq 0x44e0
leaq 0x190(%rsp), %rdi
callq 0x44e0
leaq 0x1f0(%rsp), %rdi
callq 0x44e0
leaq 0x250(%rsp), %rdi
callq 0x44e0
leaq 0x2b0(%rsp), %rdi
callq 0x44e0
movq 0x56f1(%rip), %r14 # 0xafc8
leaq 0x27dd(%rip), %rsi # 0x80bb
movl $0x7, %edx
movq %r14, %rdi
callq 0x4160
movl 0x59b7(%rip), %esi # 0xb2a8
movq %r14, %rdi
callq 0x41f0
movq %rax, %r14
leaq 0x2799(%rip), %rsi # 0x809c
movl $0x1, %edx
movq %rax, %rdi
callq 0x4160
leaq 0x27ac(%rip), %rsi # 0x80c3
movl $0x7, %edx
movq %r14, %rdi
callq 0x4160
movl 0x5982(%rip), %esi # 0xb2ac
movq %r14, %rdi
callq 0x41f0
leaq 0x2780(%rip), %rsi # 0x80b9
movl $0x1, %edx
movq %rax, %rdi
callq 0x4160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4230
movq %rax, %rdi
callq 0x4220
addq $0x4f0, %rsp # imm = 0x4F0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %rdi
movq %rcx, 0x10(%rdi)
movl $0x1, %esi
movl $0x1, %edx
callq 0x4320
movq (%rsp), %rbx
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
testq %rbx, %rbx
je 0x54bb
movq 0x8(%rsp), %rcx
addq %rax, %rcx
cmpq 0x20(%rsp), %rcx
jae 0x59c7
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rcx)
jmp 0x59fc
movq %rsp, %rdi
movq %rax, 0x10(%rdi)
movl $0x1, %esi
movl $0x1, %edx
callq 0x4320
movq (%rsp), %rbx
movq 0x10(%rsp), %rcx
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rcx)
movq %rcx, %rax
testq %rbx, %rbx
je 0x54bb
movq 0x8(%rsp), %rax
addq %rcx, %rax
cmpq 0x20(%rsp), %rax
jae 0x5a2c
xorps %xmm0, %xmm0
cvtsi2sdl 0x587e(%rip), %xmm0 # 0xb294
mulsd 0x2602(%rip), %xmm0 # 0x8020
addsd 0x2602(%rip), %xmm0 # 0x8028
movsd %xmm0, (%rax)
jmp 0x5a73
movq %rsp, %rdi
movq %rcx, 0x10(%rdi)
movl $0x1, %esi
movl $0x1, %edx
callq 0x4320
movq (%rsp), %rbx
movq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
cvtsi2sdl 0x583e(%rip), %xmm0 # 0xb294
mulsd 0x25c2(%rip), %xmm0 # 0x8020
addsd 0x25c2(%rip), %xmm0 # 0x8028
movsd %xmm0, (%rax)
testq %rbx, %rbx
je 0x54da
movq 0x8(%rsp), %rcx
addq %rax, %rcx
cmpq 0x20(%rsp), %rcx
jae 0x5a8b
movq $0x0, (%rcx)
jmp 0x5abd
movq %rsp, %rdi
movq %rax, 0x10(%rdi)
movl $0x1, %esi
movl $0x1, %edx
callq 0x4320
movq (%rsp), %rbx
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq %rax, %rcx
testq %rbx, %rbx
je 0x54e1
movq 0x8(%rsp), %rax
addq %rcx, %rax
cmpq 0x20(%rsp), %rax
jae 0x5ad5
movq $0x0, (%rax)
jmp 0x5b04
movq %rsp, %rdi
movq %rcx, 0x10(%rdi)
movl $0x1, %esi
movl $0x1, %edx
callq 0x4320
movq (%rsp), %rbx
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
testq %rbx, %rbx
je 0x54e8
movq 0x8(%rsp), %rcx
addq %rax, %rcx
cmpq 0x20(%rsp), %rcx
jae 0x5b22
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rcx)
jmp 0x5b57
movq %rsp, %rdi
movq %rax, 0x10(%rdi)
movl $0x1, %esi
movl $0x1, %edx
callq 0x4320
movq (%rsp), %rbx
movq 0x10(%rsp), %rcx
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rcx)
testq %rbx, %rbx
je 0x54f5
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x10(%rsp)
cmpq 0x20(%rsp), %rax
jb 0x54f7
movq %rsp, %rdi
movq %rcx, 0x10(%rdi)
movl $0x1, %esi
movl $0x1, %edx
callq 0x4320
movq (%rsp), %rbx
jmp 0x54f7
movq %rax, %rbx
leaq 0x130(%rsp), %rdi
callq 0x44e0
jmp 0x5ba3
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
callq 0x44e0
jmp 0x5bb5
movq %rax, %rbx
leaq 0x1f0(%rsp), %rdi
callq 0x44e0
jmp 0x5bc7
movq %rax, %rbx
leaq 0x250(%rsp), %rdi
callq 0x44e0
jmp 0x5bd9
movq %rax, %rbx
leaq 0x2b0(%rsp), %rdi
jmp 0x5c3e
movq %rax, %rbx
jmp 0x5c7c
movq %rax, %rbx
leaq 0x310(%rsp), %rdi
callq 0x44e0
jmp 0x5c00
movq %rax, %rbx
leaq 0x370(%rsp), %rdi
callq 0x44e0
jmp 0x5c12
movq %rax, %rbx
leaq 0x3d0(%rsp), %rdi
callq 0x44e0
jmp 0x5c24
movq %rax, %rbx
leaq 0x430(%rsp), %rdi
callq 0x44e0
jmp 0x5c36
movq %rax, %rbx
leaq 0x490(%rsp), %rdi
callq 0x44e0
jmp 0x5c8e
jmp 0x5c47
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x4260
jmp 0x5c5b
jmp 0x5c6a
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x4260
jmp 0x5c8e
movq %rax, %rbx
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x5c7c
callq 0x6d6e
movq 0xd8(%rsp), %rdi
testq %rdi, %rdi
je 0x5c8e
callq 0x6d6e
movq %rbx, %rdi
callq 0x4330
|
/astar-ai[P]calicam/calicam.cpp
|
main
|
int main(int argc, char** argv) {
std::string file_name = argc == 2 ? argv[1] : "../astar_calicam.yml";
LoadParameters(file_name);
InitRectifyMap();
cv::Mat raw_img;
cv::VideoCapture vcapture;
if (live) {
vcapture.open(0);
if (!vcapture.isOpened()) {
std::cout << "Camera doesn't work" << std::endl;
exit(-1);
}
vcapture.set(cv::CAP_PROP_FRAME_WIDTH, cap_cols);
vcapture.set(cv::CAP_PROP_FRAME_HEIGHT, cap_rows);
vcapture.set(cv::CAP_PROP_FPS, 30);
} else {
raw_img = cv::imread("../dasl_wood_shop.jpg", cv::IMREAD_COLOR);
}
char win_name[256];
sprintf(win_name, "Raw Image: %d x %d", img_width, cap_rows);
std::string param_win_name(win_name);
cv::namedWindow(param_win_name);
cv::createTrackbar("V. FoV: 60 +", param_win_name, nullptr, vfov_max, OnTrackAngle);
cv::createTrackbar("Width: 480 +", param_win_name, nullptr, width_max, OnTrackWidth);
cv::createTrackbar("Height: 360 +", param_win_name, nullptr, height_max, OnTrackHeight);
std::string disp_win_name = "Disparity Image";
if (cam_model == "stereo") {
cv::namedWindow(disp_win_name);
cv::createTrackbar("Num Disp: 16 + 16 *", disp_win_name, nullptr, ndisp_max, OnTrackNdisp);
cv::setTrackbarPos("Num Disp: 16 + 16 *", disp_win_name, ndisp_bar);
cv::createTrackbar("Blk Size : 3 + 2 *", disp_win_name, nullptr, wsize_max, OnTrackWsize);
cv::setTrackbarPos("Blk Size : 3 + 2 *", disp_win_name, wsize_bar);
}
cv::Mat raw_imgl, raw_imgr, rect_imgl, rect_imgr;
while (1) {
if (changed) {
InitRectifyMap();
changed = false;
}
if (live)
vcapture >> raw_img;
if (raw_img.total() == 0) {
std::cout << "Image capture error" << std::endl;
exit(-1);
}
if (cam_model == "stereo") {
raw_img(cv::Rect( 0, 0, img_width, cap_rows)).copyTo(raw_imgl);
raw_img(cv::Rect(img_width, 0, img_width, cap_rows)).copyTo(raw_imgr);
cv::remap(raw_imgl, rect_imgl, smap[0][0], smap[0][1], 1, 0);
cv::remap(raw_imgr, rect_imgr, smap[1][0], smap[1][1], 1, 0);
} else {
raw_imgl = raw_img;
cv::remap(raw_img, rect_imgl, smap[0][0], smap[0][1], 1, 0);
}
cv::Mat small_img;
cv::resize(raw_imgl, small_img, cv::Size(), 0.5, 0.5);
imshow(param_win_name, small_img);
imshow("Rectified Image", rect_imgl);
if (cam_model == "stereo") {
cv::Mat disp_img;
DisparityImage(rect_imgl, rect_imgr, disp_img);
imshow(disp_win_name, disp_img);
}
char key = cv::waitKey(1);
if (key == 'q' || key == 'Q' || key == 27)
break;
}
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4b8, %rsp # imm = 0x4B8
cmpl $0x2, %edi
jne 0x6027
movq 0x8(%rsi), %rsi
jmp 0x602e
leaq 0x209d(%rip), %rsi # 0x80cb
leaq 0x1b0(%rsp), %rbx
leaq 0x3b0(%rsp), %rdx
movq %rbx, %rdi
callq 0x6d30
leaq 0x170(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x160(%rsp), %rdi
callq 0x6dde
leaq 0x160(%rsp), %rdi
callq 0x4894
movq 0x160(%rsp), %rdi
cmpq %r14, %rdi
je 0x6093
movq 0x170(%rsp), %rsi
incq %rsi
callq 0x42d0
callq 0x5303
leaq 0x230(%rsp), %rdi
callq 0x4080
leaq 0x180(%rsp), %rdi
callq 0x42c0
cmpb $0x1, 0x5218(%rip) # 0xb2d1
jne 0x6134
leaq 0x180(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x44d0
leaq 0x180(%rsp), %rdi
callq 0x4130
testb %al, %al
je 0x6ad8
cvtsi2sdl 0x51f7(%rip), %xmm0 # 0xb2e0
leaq 0x180(%rsp), %rdi
movl $0x3, %esi
callq 0x4060
xorps %xmm0, %xmm0
cvtsi2sdl 0x51de(%rip), %xmm0 # 0xb2e4
leaq 0x180(%rsp), %rdi
movl $0x4, %esi
callq 0x4060
leaq 0x180(%rsp), %rdi
movsd 0x1f10(%rip), %xmm0 # 0x8038
movl $0x5, %esi
callq 0x4060
jmp 0x61a5
leaq 0x78(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1fb0(%rip), %rsi # 0x80f4
leaq 0x1fbe(%rip), %rdx # 0x8109
leaq 0x68(%rsp), %rdi
callq 0x6e74
leaq 0x3b0(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movl $0x1, %edx
callq 0x44c0
leaq 0x230(%rsp), %rdi
leaq 0x3b0(%rsp), %rsi
callq 0x4090
leaq 0x3b0(%rsp), %rdi
callq 0x44e0
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x61a5
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42d0
movl 0x513d(%rip), %edx # 0xb2e8
movl 0x5133(%rip), %ecx # 0xb2e4
leaq 0x1f52(%rip), %rsi # 0x810a
leaq 0x3b0(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4190
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rbx, %rdi
callq 0x42f0
leaq (%rsp,%rax), %rdx
addq $0x3b0, %rdx # imm = 0x3B0
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x6e74
leaq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0x4280
leaq 0x78(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1f0b(%rip), %rsi # 0x811d
leaq 0x1f14(%rip), %rdx # 0x812d
leaq 0x68(%rsp), %rdi
callq 0x6e74
movl 0x5057(%rip), %ecx # 0xb280
leaq -0x1a44(%rip), %r8 # 0x47ec
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x41c0
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x625b
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x68(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x1ec4(%rip), %rsi # 0x812e
leaq 0x1eca(%rip), %rdx # 0x813b
callq 0x6e74
movl 0x5008(%rip), %ecx # 0xb284
leaq -0x1a80(%rip), %r8 # 0x4803
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x41c0
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x62ae
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x68(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x1e7f(%rip), %rsi # 0x813c
leaq 0x1e85(%rip), %rdx # 0x8149
callq 0x6e74
movl 0x4fb9(%rip), %ecx # 0xb288
leaq -0x1aa5(%rip), %r8 # 0x4831
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x41c0
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x6301
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1e39(%rip), %rsi # 0x814a
leaq 0x1e41(%rip), %rdx # 0x8159
leaq 0x28(%rsp), %rdi
callq 0x6e74
leaq 0x5507(%rip), %rdi # 0xb830
leaq 0x1d4b(%rip), %rsi # 0x807b
callq 0x4450
testl %eax, %eax
jne 0x6480
leaq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x4280
leaq 0x68(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x1dff(%rip), %rsi # 0x815a
leaq 0x1e0c(%rip), %rdx # 0x816e
callq 0x6e74
movl 0x4f33(%rip), %ecx # 0xb2a0
leaq -0x1b15(%rip), %r8 # 0x485f
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x41c0
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x639f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x68(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x1dac(%rip), %rsi # 0x815a
leaq 0x1db9(%rip), %rdx # 0x816e
callq 0x6e74
movl 0x4ed8(%rip), %edx # 0xb298
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4350
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x63e6
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x68(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x1d7a(%rip), %rsi # 0x816f
leaq 0x1d8d(%rip), %rdx # 0x8189
callq 0x6e74
movl 0x4e9d(%rip), %ecx # 0xb2a4
leaq -0x1b95(%rip), %r8 # 0x4879
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x41c0
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x6439
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x68(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x1d27(%rip), %rsi # 0x816f
leaq 0x1d3a(%rip), %rdx # 0x8189
callq 0x6e74
movl 0x4e42(%rip), %edx # 0xb29c
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4350
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x6480
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x68(%rsp), %rdi
callq 0x4080
leaq 0x350(%rsp), %rdi
callq 0x4080
leaq 0x290(%rsp), %rdi
callq 0x4080
leaq 0x2f0(%rsp), %rdi
callq 0x4080
leaq 0x1d0(%rsp), %r13
leaq 0xf8(%rsp), %r15
xorl %r14d, %r14d
leaq 0xc8(%rsp), %rbx
cmpb $0x1, 0x4e19(%rip) # 0xb2ec
jne 0x64e1
callq 0x5303
movb $0x0, 0x4e0b(%rip) # 0xb2ec
cmpb $0x1, 0x4de9(%rip) # 0xb2d1
jne 0x64ff
leaq 0x180(%rsp), %rdi
leaq 0x230(%rsp), %rsi
callq 0x40d0
leaq 0x230(%rsp), %rdi
callq 0x4440
testq %rax, %rax
je 0x6aaa
leaq 0x5314(%rip), %rdi # 0xb830
leaq 0x1b58(%rip), %rsi # 0x807b
callq 0x4450
testl %eax, %eax
je 0x65fc
leaq 0x68(%rsp), %rdi
leaq 0x230(%rsp), %rsi
callq 0x4180
movq %r14, 0x108(%rsp)
movl $0x1010000, %ecx # imm = 0x1010000
movl %ecx, 0xf8(%rsp)
leaq 0x230(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %r14, 0x20(%rsp)
movl $0x2010000, 0x10(%rsp) # imm = 0x2010000
leaq 0x290(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %r14, 0xf0(%rsp)
movl %ecx, 0xe0(%rsp)
leaq 0x50ba(%rip), %rax # 0xb650
movq %rax, 0xe8(%rsp)
movq %r14, 0xd8(%rsp)
movl %ecx, 0xc8(%rsp)
leaq 0x50fc(%rip), %rax # 0xb6b0
movq %rax, 0xd0(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x1e0(%rsp)
movapd %xmm0, 0x1d0(%rsp)
movq %r13, (%rsp)
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
leaq 0xe0(%rsp), %rdx
movq %rbx, %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x4070
jmp 0x6855
movl 0x4ce6(%rip), %eax # 0xb2e8
movl 0x4cdc(%rip), %ecx # 0xb2e4
movq $0x0, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r13, %rdi
leaq 0x230(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x4040
movq $0x0, 0x108(%rsp)
movl $0x2010000, 0xf8(%rsp) # imm = 0x2010000
leaq 0x68(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x43f0
movq %r13, %rdi
callq 0x44e0
movl 0x4c7d(%rip), %eax # 0xb2e8
movl 0x4c73(%rip), %ecx # 0xb2e4
movl %eax, 0x10(%rsp)
movl $0x0, 0x14(%rsp)
movl %eax, 0x18(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r13, %rdi
leaq 0x230(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x4040
movq $0x0, 0x108(%rsp)
movl $0x2010000, 0xf8(%rsp) # imm = 0x2010000
leaq 0x350(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x43f0
movq %r13, %rdi
callq 0x44e0
xorl %r14d, %r14d
movq %r14, 0x108(%rsp)
movl $0x1010000, %r12d # imm = 0x1010000
movl %r12d, 0xf8(%rsp)
leaq 0x68(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %r14, 0x20(%rsp)
movl $0x2010000, 0x10(%rsp) # imm = 0x2010000
leaq 0x290(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %r14, 0xf0(%rsp)
movl %r12d, 0xe0(%rsp)
leaq 0x4f25(%rip), %rax # 0xb650
movq %rax, 0xe8(%rsp)
movq %r14, 0xd8(%rsp)
movl %r12d, 0xc8(%rsp)
leaq 0x4f66(%rip), %rax # 0xb6b0
movq %rax, 0xd0(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x1e0(%rsp)
movapd %xmm0, 0x1d0(%rsp)
movq %r13, (%rsp)
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
leaq 0xe0(%rsp), %rbp
movq %rbp, %rdx
leaq 0xc8(%rsp), %rbx
movq %rbx, %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x4070
movq %r14, 0x108(%rsp)
movl %r12d, 0xf8(%rsp)
leaq 0x350(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %r14, 0x20(%rsp)
movl $0x2010000, 0x10(%rsp) # imm = 0x2010000
leaq 0x2f0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %r14, 0xf0(%rsp)
movl %r12d, 0xe0(%rsp)
leaq 0x4f27(%rip), %rax # 0xb710
movq %rax, 0xe8(%rsp)
movq %r14, 0xd8(%rsp)
movl %r12d, 0xc8(%rsp)
leaq 0x4f68(%rip), %rax # 0xb770
movq %rax, 0xd0(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x1e0(%rsp)
movapd %xmm0, 0x1d0(%rsp)
movq %r13, %r14
movq %r13, (%rsp)
movq %r15, %r12
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x4070
movq %r14, %r13
movq %r12, %r15
xorl %r14d, %r14d
movq %r13, %rdi
callq 0x4080
movq %r14, 0x108(%rsp)
movl $0x1010000, 0xf8(%rsp) # imm = 0x1010000
leaq 0x68(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %r14, 0x20(%rsp)
movl $0x2010000, 0x10(%rsp) # imm = 0x2010000
movq %r13, 0x18(%rsp)
movq %r14, 0x158(%rsp)
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
leaq 0x158(%rsp), %rdx
movsd 0x1771(%rip), %xmm0 # 0x8020
movapd %xmm0, %xmm1
movl $0x1, %ecx
callq 0x4480
movq $0x0, 0x108(%rsp)
movl $0x1010000, 0xf8(%rsp) # imm = 0x1010000
movq %r13, 0x100(%rsp)
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x4030
leaq 0x108(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq %r15, %rdi
leaq 0x189b(%rip), %rsi # 0x819e
leaq 0x18a3(%rip), %rdx # 0x81ad
callq 0x6e74
movq $0x0, 0x20(%rsp)
movl $0x1010000, 0x10(%rsp) # imm = 0x1010000
leaq 0x290(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x4030
movq 0xf8(%rsp), %rdi
leaq 0x108(%rsp), %rax
cmpq %rax, %rdi
je 0x695f
movq 0x108(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x4eca(%rip), %rdi # 0xb830
leaq 0x170e(%rip), %rsi # 0x807b
callq 0x4450
testl %eax, %eax
jne 0x69c3
movq %r15, %rdi
callq 0x4080
leaq 0x290(%rsp), %rdi
leaq 0x2f0(%rsp), %rsi
movq %r15, %rdx
callq 0x5c96
movq $0x0, 0x20(%rsp)
movl $0x1010000, 0x10(%rsp) # imm = 0x1010000
movq %r15, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4030
movq %r15, %rdi
callq 0x44e0
movl $0x1, %edi
callq 0x4430
movl %eax, %r12d
movl %eax, %ebp
andl $0xdf, %ebp
movq %r13, %rdi
callq 0x44e0
cmpl $0x51, %ebp
je 0x69f2
movzbl %r12b, %eax
cmpl $0x1b, %eax
jne 0x64cc
leaq 0x2f0(%rsp), %rdi
callq 0x44e0
leaq 0x290(%rsp), %rdi
callq 0x44e0
leaq 0x350(%rsp), %rdi
callq 0x44e0
leaq 0x68(%rsp), %rdi
callq 0x44e0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x6a3f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42d0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x6a5b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x180(%rsp), %rdi
callq 0x4250
leaq 0x230(%rsp), %rdi
callq 0x44e0
leaq 0x1c0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6a96
movq 0x1c0(%rsp), %rsi
incq %rsi
callq 0x42d0
xorl %eax, %eax
addq $0x4b8, %rsp # imm = 0x4B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4517(%rip), %rdi # 0xafc8
leaq 0x16d2(%rip), %rsi # 0x818a
movl $0x13, %edx
callq 0x4160
movq 0x44ff(%rip), %rdi # 0xafc8
callq 0x4170
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0x4410
movq 0x44e9(%rip), %rdi # 0xafc8
leaq 0x15fa(%rip), %rsi # 0x80e0
movl $0x13, %edx
callq 0x4160
movq 0x44d1(%rip), %rdi # 0xafc8
callq 0x4170
jmp 0x6ace
jmp 0x6b0a
jmp 0x6b28
jmp 0x6b0a
jmp 0x6b28
jmp 0x6b0a
jmp 0x6b28
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x6b2b
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x6b2b
jmp 0x6b28
movq %rax, %rbx
leaq 0x58(%rsp), %r15
leaq 0x38(%rsp), %r14
jmp 0x6c99
movq %rax, %rbx
leaq 0x3b0(%rsp), %rdi
callq 0x44e0
jmp 0x6b4f
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x6cc7
movq 0x78(%rsp), %rsi
jmp 0x6cbf
jmp 0x6bd3
jmp 0x6b90
jmp 0x6b73
jmp 0x6b90
jmp 0x6b73
jmp 0x6b90
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x6cb0
movq 0x78(%rsp), %rsi
jmp 0x6ca8
jmp 0x6b90
movq %rax, %rbx
jmp 0x6cb0
jmp 0x6bd3
movq %rax, %rbx
jmp 0x6cd4
movq %rax, %rbx
movq 0x160(%rsp), %rdi
cmpq %r14, %rdi
je 0x6ce1
movq 0x170(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x6ce1
movq %rax, %rbx
jmp 0x6ce1
movq %rax, %rbx
jmp 0x6cc7
jmp 0x6be3
jmp 0x6bf9
jmp 0x6c5b
jmp 0x6c5b
movq %rax, %rbx
leaq 0x1d0(%rsp), %rdi
callq 0x44e0
jmp 0x6c5e
jmp 0x6c5b
jmp 0x6c5b
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0x44e0
jmp 0x6c42
jmp 0x6c5b
jmp 0x6c5b
jmp 0x6c3f
jmp 0x6c3f
jmp 0x6c3f
movq %rax, %rbx
movq 0xf8(%rsp), %rdi
leaq 0x108(%rsp), %rax
cmpq %rax, %rdi
je 0x6c42
movq 0x108(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x6c42
movq %rax, %rbx
leaq 0x58(%rsp), %r15
leaq 0x38(%rsp), %r14
leaq 0x1d0(%rsp), %rdi
callq 0x44e0
jmp 0x6c68
movq %rax, %rbx
leaq 0x58(%rsp), %r15
leaq 0x38(%rsp), %r14
leaq 0x2f0(%rsp), %rdi
callq 0x44e0
leaq 0x290(%rsp), %rdi
callq 0x44e0
leaq 0x350(%rsp), %rdi
callq 0x44e0
leaq 0x68(%rsp), %rdi
callq 0x44e0
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x6cb0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42d0
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x6cc7
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x180(%rsp), %rdi
callq 0x4250
leaq 0x230(%rsp), %rdi
callq 0x44e0
leaq 0x1c0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d02
movq 0x1c0(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4330
|
/astar-ai[P]calicam/calicam.cpp
|
deleteBg(cv::Mat, cv::Mat&, cv::Ptr<cv::BackgroundSubtractor>, bool, int)
|
Mat deleteBg(Mat img, Mat &out, Ptr<BackgroundSubtractor> bgs, bool learn, int thresh_sens_val) {
Mat fgMask, grayscale, threshDiff;
bgs->apply(img, fgMask, learn);
threshold(fgMask, threshDiff, thresh_sens_val, 255, THRESH_BINARY);
mask_morph(threshDiff);
Mat res;
img.copyTo(res, threshDiff);
out = res;
return threshDiff;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rcx, -0x208(%rbp)
movq %rsi, -0x200(%rbp)
movq %rdi, -0x210(%rbp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, -0x218(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movl %r9d, -0x28(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3060
leaq -0xe8(%rbp), %rdi
callq 0x3060
movq -0x210(%rbp), %rdi
movb $0x0, -0xe9(%rbp)
callq 0x3060
movq -0x208(%rbp), %rdi
callq 0x97d0
movq -0x200(%rbp), %rsi
movq %rax, -0x1f8(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x4400
jmp 0x94a9
leaq -0x130(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x4440
jmp 0x94be
movq -0x1f8(%rbp), %rdi
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movq (%rdi), %rax
movq 0x40(%rax), %rax
leaq -0x108(%rbp), %rsi
leaq -0x130(%rbp), %rdx
callq *%rax
jmp 0x94ea
leaq -0x130(%rbp), %rdi
callq 0x4480
leaq -0x108(%rbp), %rdi
callq 0x44a0
leaq -0x148(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x4400
jmp 0x9517
movq -0x210(%rbp), %rsi
leaq -0x160(%rbp), %rdi
callq 0x4440
jmp 0x952c
cvtsi2sdl -0x28(%rbp), %xmm0
leaq -0x148(%rbp), %rdi
leaq -0x160(%rbp), %rsi
movsd 0x16ad1(%rip), %xmm1 # 0x20018
xorl %edx, %edx
callq 0x3490
jmp 0x9550
leaq -0x160(%rbp), %rdi
callq 0x4480
leaq -0x148(%rbp), %rdi
callq 0x44a0
movq -0x210(%rbp), %rdi
callq 0x8e70
jmp 0x9576
leaq -0x1c0(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x3060
movq -0x220(%rbp), %rsi
leaq -0x1d8(%rbp), %rdi
callq 0x4440
jmp 0x959e
movq -0x210(%rbp), %rsi
leaq -0x1f0(%rbp), %rdi
callq 0x4400
jmp 0x95b3
movq -0x200(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
leaq -0x1f0(%rbp), %rdx
callq 0x3230
jmp 0x95cf
leaq -0x1f0(%rbp), %rdi
callq 0x44a0
leaq -0x1d8(%rbp), %rdi
callq 0x4480
movq -0x18(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x3150
jmp 0x95f9
movb $0x1, -0xe9(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3080
testb $0x1, -0xe9(%rbp)
jne 0x9727
jmp 0x971b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x974f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x9667
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x4480
leaq -0x108(%rbp), %rdi
callq 0x44a0
jmp 0x974f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x96aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x4480
leaq -0x148(%rbp), %rdi
callq 0x44a0
jmp 0x974f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x970d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x9701
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x44a0
leaq -0x1d8(%rbp), %rdi
callq 0x4480
leaq -0x1c0(%rbp), %rdi
callq 0x3080
jmp 0x974f
movq -0x210(%rbp), %rdi
callq 0x3080
leaq -0xe8(%rbp), %rdi
callq 0x3080
leaq -0x88(%rbp), %rdi
callq 0x3080
movq -0x218(%rbp), %rax
addq $0x220, %rsp # imm = 0x220
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x3080
leaq -0xe8(%rbp), %rdi
callq 0x3080
leaq -0x88(%rbp), %rdi
callq 0x3080
movq -0x110(%rbp), %rdi
callq 0x3390
nop
|
/prostoiChelovek[P]handDetector/utils.cpp
|
Hand::Hand(std::vector<cv::Point_<int>, std::allocator<cv::Point_<int>>>, bool, bool, bool, int, bool)
|
Hand::Hand(vector<Point> contour, bool shouldCheckSize, bool shouldCheckAngles,
bool shouldGetLast, int maxAngle, bool shouldCheckDists)
: contour(contour), shouldCheckSize(shouldCheckSize), shouldCheckAngles(shouldCheckAngles),
shouldGetLast(shouldGetLast), maxAngle(maxAngle), shouldCheckDists(shouldCheckDists) {
moment = moments(contour);
area = moment.m00;
border = boundingRect(contour);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movl %r8d, -0x168(%rbp)
movl %ecx, %eax
movl -0x168(%rbp), %ecx
movl %eax, -0x164(%rbp)
movl %edx, %eax
movl -0x164(%rbp), %edx
movq %rsi, -0x160(%rbp)
movq %rdi, %r8
movb %al, %dil
movb 0x10(%rbp), %al
movq %r8, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dil
movb %dil, -0x11(%rbp)
andb $0x1, %dl
movb %dl, -0x12(%rbp)
andb $0x1, %cl
movb %cl, -0x13(%rbp)
movl %r9d, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x138(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
callq 0x7690
movq -0x138(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x150(%rbp)
callq 0xe9f0
movq -0x138(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x148(%rbp)
callq 0xea10
movq -0x138(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x140(%rbp)
callq 0xea30
movq -0x138(%rbp), %rdi
addq $0x60, %rdi
callq 0x7600
jmp 0x9b2e
movq -0x158(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x170(%rbp)
callq 0xea50
movq -0x158(%rbp), %rdi
addq $0x88, %rdi
callq 0x3450
jmp 0x9b5a
movq -0x158(%rbp), %rdi
addq $0x148, %rdi # imm = 0x148
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl %edx, %esi
callq 0x7c70
jmp 0x9b76
movq -0x158(%rbp), %rdi
addq $0x158, %rdi # imm = 0x158
movl $0x9c4, %esi # imm = 0x9C4
movl $0x9c400, %edx # imm = 0x9C400
callq 0x45e0
jmp 0x9b95
movq -0x158(%rbp), %rdi
movl $0x5, 0x160(%rdi)
movl $0x4, 0x164(%rdi)
movl -0x18(%rbp), %eax
movl %eax, 0x168(%rdi)
movl $0xa, 0x16c(%rdi)
addq $0x170, %rdi # imm = 0x170
callq 0x68d0
jmp 0x9bd1
movq -0x158(%rbp), %rdi
addq $0x1b0, %rdi # imm = 0x1B0
callq 0x68d0
jmp 0x9be6
movq -0x160(%rbp), %rsi
movq -0x158(%rbp), %rax
movb $0x0, 0x1f0(%rax)
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x1f1(%rax)
movb -0x12(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x1f2(%rax)
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x1f3(%rax)
movb -0x13(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x1f4(%rax)
movl $0xffffffff, 0x1f8(%rax) # imm = 0xFFFFFFFF
leaq -0x108(%rbp), %rdi
callq 0xea70
jmp 0x9c43
leaq -0xf0(%rbp), %rdi
leaq -0x108(%rbp), %rsi
xorl %edx, %edx
callq 0x3370
jmp 0x9c5a
movq -0x158(%rbp), %rdi
addq $0x88, %rdi
leaq -0xf0(%rbp), %rsi
movl $0xc0, %edx
callq 0x3400
leaq -0x108(%rbp), %rdi
callq 0x44a0
movq -0x158(%rbp), %rax
movq -0x160(%rbp), %rsi
movsd 0x88(%rax), %xmm0
movsd %xmm0, 0x150(%rax)
leaq -0x130(%rbp), %rdi
callq 0xea70
jmp 0x9cb1
leaq -0x118(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x3320
jmp 0x9cc6
movq -0x158(%rbp), %rdi
addq $0x60, %rdi
leaq -0x118(%rbp), %rsi
callq 0xeab0
leaq -0x130(%rbp), %rdi
callq 0x44a0
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x9d4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x9d40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x44a0
jmp 0x9d40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x44a0
movq -0x170(%rbp), %rdi
callq 0x4fa0
movq -0x140(%rbp), %rdi
callq 0x5000
movq -0x148(%rbp), %rdi
callq 0x5060
movq -0x150(%rbp), %rdi
callq 0x4b30
movq -0x138(%rbp), %rdi
callq 0x4b30
movq -0x28(%rbp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
|
/prostoiChelovek[P]handDetector/Hand.cpp
|
Hand::getFingers(std::vector<ShortFinger, std::allocator<ShortFinger>> const&)
|
void Hand::getFingers(const vector<ShortFinger> &lastFingers) {
if (contour.empty()) {
ok = false;
return;
}
convexHull(contour, hull, false);
convexHull(contour, hullI, false);
convexityDefects(contour, hullI, defects);
for (const Vec4i &v : defects) {
Finger f(v, contour, border, maxAngle, shouldCheckAngles);
if (f.ok)
fingers.push_back(f);
}
sort(fingers.begin(), fingers.end(), [](const Finger &a, const Finger &b) {
return a.ptStart.y < b.ptStart.y;
});
removeCloseFingertips();
getCenter();
getFingersIndexes(lastFingers);
if (maxFingers != -1 && fingers.size() > maxFingers)
fingers.resize(maxFingers);
if (shouldGetLast) {
if (maxFingers != -1 && fingers.size() < maxFingers) {
for (const Finger &f : fingers) {
if (maxFingers != -1 && fingers.size() >= maxFingers)
break;
auto fnd = find_if(fingers.begin(), fingers.end(), [f](const Finger &b) {
return getDist(f.ptEnd, b.ptStart) <= 50;
});
if (fnd != fingers.end())
continue;
Finger nf = f;
nf.ptStart = f.ptEnd;
nf.ptEnd = f.ptStart;
nf.index = -1;
fingers.emplace_back(nf);
}
}
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0xec50
testb $0x1, %al
jne 0xa059
jmp 0xa06c
movq -0x208(%rbp), %rax
movb $0x0, 0x1f0(%rax)
jmp 0xa5d8
movq -0x208(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xea70
movq -0x208(%rbp), %rsi
addq $0x18, %rsi
leaq -0x40(%rbp), %rdi
callq 0xec90
jmp 0xa092
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x3130
jmp 0xa0a8
leaq -0x40(%rbp), %rdi
callq 0x4480
leaq -0x28(%rbp), %rdi
callq 0x44a0
movq -0x208(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xea70
movq -0x208(%rbp), %rsi
addq $0x30, %rsi
leaq -0x80(%rbp), %rdi
callq 0xecd0
jmp 0xa0e0
leaq -0x68(%rbp), %rdi
leaq -0x80(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x3130
jmp 0xa0f6
leaq -0x80(%rbp), %rdi
callq 0x4480
leaq -0x68(%rbp), %rdi
callq 0x44a0
movq -0x208(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0xea70
movq -0x208(%rbp), %rsi
addq $0x30, %rsi
leaq -0xb0(%rbp), %rdi
callq 0xed10
jmp 0xa134
movq -0x208(%rbp), %rsi
addq $0x48, %rsi
leaq -0xc8(%rbp), %rdi
callq 0xed50
jmp 0xa14d
leaq -0x98(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x3350
jmp 0xa169
leaq -0xc8(%rbp), %rdi
callq 0x4480
leaq -0xb0(%rbp), %rdi
callq 0x44a0
leaq -0x98(%rbp), %rdi
callq 0x44a0
movq -0x208(%rbp), %rax
addq $0x48, %rax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rdi
callq 0xed90
movq %rax, -0xd8(%rbp)
movq -0xd0(%rbp), %rdi
callq 0xedc0
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0xedf0
testb $0x1, %al
jne 0xa1e1
jmp 0xa326
leaq -0xd8(%rbp), %rdi
callq 0xee30
movq -0x208(%rbp), %rdx
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rsi
movq %rdx, %rcx
addq $0x60, %rcx
movl 0x168(%rdx), %r8d
movb 0x1f2(%rdx), %al
leaq -0x128(%rbp), %rdi
andb $0x1, %al
movzbl %al, %r9d
movl $0x1, (%rsp)
movl $0xffffffff, 0x8(%rsp) # imm = 0xFFFFFFFF
callq 0x6950
testb $0x1, -0x104(%rbp)
je 0xa313
movq -0x208(%rbp), %rdi
addq $0x70, %rdi
leaq -0x128(%rbp), %rsi
callq 0xee50
jmp 0xa313
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xa283
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4480
leaq -0x28(%rbp), %rdi
callq 0x44a0
jmp 0xa5e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xa2b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x4480
leaq -0x68(%rbp), %rdi
callq 0x44a0
jmp 0xa5e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xa302
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xa2f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x4480
leaq -0xb0(%rbp), %rdi
callq 0x44a0
leaq -0x98(%rbp), %rdi
callq 0x44a0
jmp 0xa5e1
jmp 0xa315
leaq -0xd8(%rbp), %rdi
callq 0xeec0
jmp 0xa1c5
movq -0x208(%rbp), %rdi
addq $0x70, %rdi
callq 0xeba0
movq -0x208(%rbp), %rdi
movq %rax, -0x130(%rbp)
addq $0x70, %rdi
callq 0xeee0
movq %rax, -0x138(%rbp)
movq -0x130(%rbp), %rdi
movq -0x138(%rbp), %rsi
callq 0xa5f0
movq -0x208(%rbp), %rdi
callq 0x9e70
movq -0x208(%rbp), %rdi
callq 0x9fd0
movq -0x208(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa630
movq -0x208(%rbp), %rax
cmpl $-0x1, 0x160(%rax)
je 0xa3dc
movq -0x208(%rbp), %rdi
addq $0x70, %rdi
callq 0xeaf0
movq -0x208(%rbp), %rcx
movslq 0x160(%rcx), %rcx
cmpq %rcx, %rax
jbe 0xa3dc
movq -0x208(%rbp), %rax
movq %rax, %rdi
addq $0x70, %rdi
movslq 0x160(%rax), %rsi
callq 0xef10
movq -0x208(%rbp), %rax
testb $0x1, 0x1f4(%rax)
je 0xa5d8
movq -0x208(%rbp), %rax
cmpl $-0x1, 0x160(%rax)
je 0xa5d6
movq -0x208(%rbp), %rdi
addq $0x70, %rdi
callq 0xeaf0
movq -0x208(%rbp), %rcx
movslq 0x160(%rcx), %rcx
cmpq %rcx, %rax
jae 0xa5d6
movq -0x208(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x148(%rbp)
movq -0x148(%rbp), %rdi
callq 0xeba0
movq %rax, -0x150(%rbp)
movq -0x148(%rbp), %rdi
callq 0xeee0
movq %rax, -0x158(%rbp)
leaq -0x150(%rbp), %rdi
leaq -0x158(%rbp), %rsi
callq 0xefa0
testb $0x1, %al
jne 0xa47f
jmp 0xa5d4
leaq -0x150(%rbp), %rdi
callq 0xefe0
movq %rax, %rcx
movq -0x208(%rbp), %rax
movq %rcx, -0x160(%rbp)
cmpl $-0x1, 0x160(%rax)
je 0xa4cd
movq -0x208(%rbp), %rdi
addq $0x70, %rdi
callq 0xeaf0
movq -0x208(%rbp), %rcx
movslq 0x160(%rcx), %rcx
cmpq %rcx, %rax
jb 0xa4cd
jmp 0xa5d4
movq -0x208(%rbp), %rdi
addq $0x70, %rdi
callq 0xeba0
movq -0x208(%rbp), %rdi
movq %rax, -0x170(%rbp)
addq $0x70, %rdi
callq 0xeee0
movq %rax, -0x178(%rbp)
leaq -0x1b8(%rbp), %rdi
movq -0x160(%rbp), %rsi
callq 0xf000
movq -0x170(%rbp), %rdi
movq -0x178(%rbp), %rsi
leaq -0x1b8(%rbp), %rdx
callq 0xabe0
movq -0x208(%rbp), %rdi
movq %rax, -0x168(%rbp)
addq $0x70, %rdi
callq 0xeee0
movq %rax, -0x1c0(%rbp)
leaq -0x168(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xefa0
testb $0x1, %al
jne 0xa55f
jmp 0xa561
jmp 0xa5c3
movq -0x160(%rbp), %rsi
leaq -0x200(%rbp), %rdi
callq 0xf000
movq -0x160(%rbp), %rsi
addq $0x8, %rsi
leaq -0x200(%rbp), %rdi
callq 0x7c90
movq -0x160(%rbp), %rsi
leaq -0x200(%rbp), %rdi
addq $0x8, %rdi
callq 0x7c90
movq -0x208(%rbp), %rdi
movl $0xffffffff, -0x1d8(%rbp) # imm = 0xFFFFFFFF
addq $0x70, %rdi
leaq -0x200(%rbp), %rsi
callq 0xf090
leaq -0x150(%rbp), %rdi
callq 0xf100
jmp 0xa463
jmp 0xa5d6
jmp 0xa5d8
addq $0x220, %rsp # imm = 0x220
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3390
nopw (%rax,%rax)
|
/prostoiChelovek[P]handDetector/Hand.cpp
|
Hand::getHigherFinger()
|
void Hand::getHigherFinger() {
int maxY = -1;
Finger hf;
for (Finger &f : fingers) {
if (maxY == -1 || f.ptStart.y < maxY) {
maxY = f.ptStart.y;
hf = f;
}
}
higherFinger = hf;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
leaq -0x4c(%rbp), %rdi
callq 0x68d0
movq -0x78(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0xeba0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0xeee0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xefa0
testb $0x1, %al
jne 0xad40
jmp 0xad83
leaq -0x60(%rbp), %rdi
callq 0xefe0
movq %rax, -0x70(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0xad5f
movq -0x70(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0xad76
movq -0x70(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x70(%rbp), %rsi
leaq -0x4c(%rbp), %rdi
callq 0xf520
jmp 0xad78
leaq -0x60(%rbp), %rdi
callq 0xf100
jmp 0xad2d
movq -0x78(%rbp), %rdi
addq $0x170, %rdi # imm = 0x170
leaq -0x4c(%rbp), %rsi
callq 0xf520
addq $0x80, %rsp
popq %rbp
retq
|
/prostoiChelovek[P]handDetector/Hand.cpp
|
Hand::getFarthestFinger()
|
void Hand::getFarthestFinger() {
double farthest = -1;
double dist;
Finger ff;
for (Finger &f : fingers) {
dist = getDist(f.ptStart, f.ptFar);
if (dist > farthest) {
farthest = dist;
ff = f;
}
}
farthestFinger = ff;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movsd 0x15436(%rip), %xmm0 # 0x201f8
movsd %xmm0, -0x10(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x68d0
movq -0x90(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0xeba0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0xeee0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xefa0
testb $0x1, %al
jne 0xae0c
jmp 0xae82
leaq -0x68(%rbp), %rdi
callq 0xefe0
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x75a0
movq -0x78(%rbp), %rsi
addq $0x10, %rsi
leaq -0x88(%rbp), %rdi
callq 0x75a0
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x8d10
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0xae72
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xf520
jmp 0xae74
leaq -0x68(%rbp), %rdi
callq 0xf100
jmp 0xadf9
movq -0x90(%rbp), %rdi
addq $0x1b0, %rdi # imm = 0x1B0
leaq -0x58(%rbp), %rsi
callq 0xf520
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/prostoiChelovek[P]handDetector/Hand.cpp
|
HandDetector::checkHands()
|
void HandDetector::checkHands() {
int i = 0;
for (Hand &h : hands) {
if (!h.checkSize() || h.fingers.empty())
hands.erase(hands.begin() + i);
i++;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0xc(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15b30
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15b60
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x15b90
testb $0x1, %al
jne 0x142af
jmp 0x14331
leaq -0x20(%rbp), %rdi
callq 0x15bd0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x9d90
testb $0x1, %al
jne 0x142cb
jmp 0x142de
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
callq 0x15c10
testb $0x1, %al
jne 0x142de
jmp 0x1431a
movq -0x58(%rbp), %rdi
callq 0x15b30
movq %rax, -0x48(%rbp)
movslq -0xc(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x15cc0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x15d00
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x15c50
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15bf0
jmp 0x14299
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/prostoiChelovek[P]handDetector/HandDetector.cpp
|
estl::weak_ptr<MyClass>::decrease_control_block_counter()
|
void decrease_control_block_counter()
{
if (!control_block_ptr_) {
return;
}
std::cerr << "control decrease "; control_block_ptr_->dbg();
if (--(control_block_ptr_->control_block_count_) == 0) {
delete control_block_ptr_;
control_block_ptr_ = nullptr;
}
}
|
cmpq $0x0, 0x8(%rdi)
je 0x2456
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2beb(%rip), %rdi # 0x4ff0
leaq 0x1010(%rip), %rsi # 0x341c
movl $0x11, %edx
callq 0x10d0
movq 0x8(%rbx), %rdi
callq 0x21b6
movq 0x8(%rbx), %rax
lock
decl 0x4(%rax)
jne 0x244f
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x243a
movq %r14, %rdi
callq 0x2366
movl $0x8, %esi
movq %r14, %rdi
callq 0x10c0
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/mlutken[P]nestle/estl/memory/shared_ptr.hpp
|
DetectorManager::createDetector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
std::shared_ptr<Detector> DetectorManager::createDetector(const std::string& detectorName)
{
auto it = m_detectors.find(detectorName);
if (m_detectors.end() == it)
{
return nullptr;
}
auto& detectorLauncher = it->second;
if (!detectorLauncher)
{
return nullptr;
}
auto detector = std::shared_ptr<Detector>(detectorLauncher->create());
if (!detector)
{
return nullptr;
}
return detector;
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x22064
addq $0x8, %r14
cmpq %rax, %r14
je 0x217f6
movq 0x40(%rax), %rdi
testq %rdi, %rdi
je 0x217f6
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x220da
movq (%r14), %rax
testq %rax, %rax
je 0x217fe
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
andq $0x0, 0x10(%rsp)
movq %rax, 0x8(%rbx)
andq $0x0, 0x8(%rsp)
jmp 0x21804
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x2180e
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x10(%rsp), %rdi
callq 0x21bce
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/Oreobird[P]effect3d/src/DetectorManager.cpp
|
LREffect::draw(cv::Mat&, std::vector<Object, std::allocator<Object>> const&)
|
int LREffect::draw(cv::Mat& image, const std::vector<Object>& objects)
{
std::cout << "----Left to right effect----" << std::endl;
int left_x = image.cols/3;
int right_x = image.cols/3*2;
bool has_major_obj = false;
for (size_t i = 0; i < objects.size(); i++)
{
const Object& obj = objects[i];
// float ratio = obj.rect.area() / (image.rows * image.cols);
std::cout << "obj.prob " << obj.prob << std::endl;
if (obj.prob < 0.5 )
{
continue;
}
has_major_obj = true;
// draw white line
// left line
std::vector<cv::Point> points;
points.emplace_back(cv::Point(left_x, 1));
bool is_mask = false;
for (int y = 0; y < image.rows; y++)
{
const uchar* mp = obj.mask.ptr(y);
if (mp[left_x] == 255 && !is_mask)
{
is_mask = true;
points.emplace_back(cv::Point(left_x, y));
}
else if (mp[left_x] == 0 && is_mask)
{
is_mask = false;
points.emplace_back(cv::Point(left_x, y));
}
}
points.emplace_back(cv::Point(left_x, image.rows - 1));
for (int j = 0; j < (int)points.size(); j += 2)
{
cv::line(image, points[j], points[j + 1], cv::Scalar(255, 255, 255), 4, -1);
}
// right line
cv::line(image, cv::Point(right_x, 1), cv::Point(right_x, image.rows - 1), cv::Scalar(255,255,255), 4, -1);
}
if (!has_major_obj)
{
cv::line(image, cv::Point(left_x, 1), cv::Point(left_x, image.rows - 1),
cv::Scalar(255,255,255), 4, -1);
cv::line(image, cv::Point(right_x, 1), cv::Point(right_x, image.rows - 1),
cv::Scalar(255,255,255), 4, -1);
}
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, 0x90(%rsp)
movq %rsi, %rbx
movq 0x75e21(%rip), %rdi # 0x97fc0
leaq 0x51036(%rip), %rsi # 0x731dc
callq 0x21420
movq %rax, %rdi
callq 0x21100
movl 0xc(%rbx), %eax
pushq $0x3
popq %rcx
cltd
idivl %ecx
movslq %eax, %r13
movl %eax, 0x8(%rsp)
addl %eax, %eax
movl %eax, 0xc(%rsp)
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq $0x0, 0x38(%rsp)
movq 0x90(%rsp), %rax
movq (%rax), %r12
movq 0x8(%rax), %rax
subq %r12, %rax
cqto
movl $0x90, %esi
idivq %rsi
cmpq %rax, %r14
jae 0x22440
imulq $0x90, %r14, %rbp
movq 0x75db3(%rip), %rdi # 0x97fc0
leaq 0x50fe5(%rip), %rsi # 0x731f9
callq 0x21420
movss 0x14(%r12,%rbp), %xmm0
movq %rax, %rdi
callq 0x21130
movq %rax, %rdi
callq 0x21100
movss 0x50fa0(%rip), %xmm0 # 0x731d8
ucomiss 0x14(%r12,%rbp), %xmm0
ja 0x22438
movq %r14, 0x88(%rsp)
andq $0x0, 0x60(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x10(%rsp)
movl $0x1, 0x14(%rsp)
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x229ba
addq %rbp, %r12
xorl %ebp, %ebp
xorl %eax, %eax
movslq 0x8(%rbx), %rcx
cmpq %rcx, %rbp
jge 0x222ee
movq 0x78(%r12), %rcx
movq (%rcx), %rcx
imulq %rbp, %rcx
addq 0x40(%r12), %rcx
movzbl (%r13,%rcx), %ecx
testl %ecx, %ecx
je 0x222cc
cmpl $0xff, %ecx
jne 0x222e9
testb $0x1, %al
jne 0x222e9
movl 0x8(%rsp), %eax
movl %eax, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x229ba
movb $0x1, %al
jmp 0x222e9
testb $0x1, %al
je 0x222e9
movl 0x8(%rsp), %eax
movl %eax, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x229ba
xorl %eax, %eax
incq %rbp
jmp 0x22281
decl %ecx
movl 0x8(%rsp), %eax
movl %eax, 0x10(%rsp)
movl %ecx, 0x14(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x229ba
xorl %r12d, %r12d
leaq 0x70(%rsp), %rbp
movq 0x50(%rsp), %rax
movq 0x58(%rsp), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jge 0x223ac
andq $0x0, 0x80(%rsp)
movl $0x3010000, 0x70(%rsp) # imm = 0x3010000
movq %rbx, 0x78(%rsp)
movq (%rax,%r12,8), %rcx
movq %rcx, 0xa0(%rsp)
movq 0x8(%rax,%r12,8), %rax
movq %rax, 0x98(%rsp)
movq %r15, %rdi
callq 0x22b90
movaps 0x50e46(%rip), %xmm0 # 0x731b0
movaps %xmm0, 0x10(%rsp)
movsd 0x50e59(%rip), %xmm0 # 0x731d0
movaps %xmm0, 0x20(%rsp)
andl $0x0, (%rsp)
movq %rbp, %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x98(%rsp), %rdx
movq %r15, %rcx
pushq $0x4
popq %r8
pushq $-0x1
popq %r9
callq 0x21030
addq $0x2, %r12
jmp 0x2230f
andq $0x0, 0x80(%rsp)
movl $0x3010000, 0x70(%rsp) # imm = 0x3010000
movq %rbx, 0x78(%rsp)
movl 0xc(%rsp), %ecx
movl %ecx, 0x48(%rsp)
movl $0x1, 0x4c(%rsp)
movl 0x8(%rbx), %eax
decl %eax
movl %ecx, 0x40(%rsp)
movl %eax, 0x44(%rsp)
movq %r15, %rdi
callq 0x22b90
movaps 0x50dc2(%rip), %xmm0 # 0x731b0
movaps %xmm0, 0x10(%rsp)
movsd 0x50dd5(%rip), %xmm0 # 0x731d0
movaps %xmm0, 0x20(%rsp)
andl $0x0, (%rsp)
movq %rbp, %rdi
leaq 0x48(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %r15, %rcx
pushq $0x4
popq %r8
pushq $-0x1
popq %r9
callq 0x21030
movq %r14, %rdi
callq 0x22a00
movb $0x1, %al
movq %rax, 0x38(%rsp)
movq 0x88(%rsp), %r14
incq %r14
jmp 0x221da
testb $0x1, 0x38(%rsp)
jne 0x2254e
leaq 0x50(%rsp), %r14
andq $0x0, 0x10(%r14)
movl $0x3010000, %eax # imm = 0x3010000
movl %eax, (%r14)
movq %rbx, 0x8(%r14)
leaq 0xc0(%rsp), %r12
movl 0x8(%rsp), %ecx
movl %ecx, (%r12)
pushq $0x1
popq %rbp
movl %ebp, 0x4(%r12)
movl 0x8(%rbx), %eax
decl %eax
leaq 0xb8(%rsp), %r13
movl %ecx, (%r13)
movl %eax, 0x4(%r13)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x22b90
movaps 0x50d0e(%rip), %xmm0 # 0x731b0
movaps %xmm0, (%r15)
movsd 0x50d22(%rip), %xmm0 # 0x731d0
movaps %xmm0, 0x10(%r15)
andl $0x0, (%rsp)
pushq $0x4
popq %r8
pushq $-0x1
popq %r9
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
movl %r8d, %r12d
movl %r9d, %r13d
callq 0x21030
andq $0x0, 0x10(%r14)
movl $0x3010000, %eax # imm = 0x3010000
movl %eax, (%r14)
movq %rbx, 0x8(%r14)
leaq 0xb0(%rsp), %r14
movl 0xc(%rsp), %ecx
movl %ecx, (%r14)
movl %ebp, 0x4(%r14)
movl 0x8(%rbx), %eax
decl %eax
leaq 0xa8(%rsp), %rbx
movl %ecx, (%rbx)
movl %eax, 0x4(%rbx)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x22b90
movaps 0x50c90(%rip), %xmm0 # 0x731b0
movaps %xmm0, (%r15)
movsd 0x50ca4(%rip), %xmm0 # 0x731d0
movaps %xmm0, 0x10(%r15)
andl $0x0, (%rsp)
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movl %r12d, %r8d
movl %r13d, %r9d
callq 0x21030
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2256c
jmp 0x2256c
jmp 0x2256c
jmp 0x2256c
jmp 0x2256c
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x22a00
movq %rbx, %rdi
callq 0x21330
nop
|
/Oreobird[P]effect3d/src/Effect3d.cpp
|
EffectManager::create()
|
std::unique_ptr<EffectManager> EffectManager::create()
{
EffectMap_t effects =
{
{"lr", std::make_shared<EffectLauncher<LREffect>>()},
{"rl", std::make_shared<EffectLauncher<RLEffect>>()},
{"nf", std::make_shared<EffectLauncher<NFEffect>>()},
{"fn", std::make_shared<EffectLauncher<FNEffect>>()},
};
auto mgt = new EffectManager(effects);
if (!mgt)
{
return nullptr;
}
return std::unique_ptr<EffectManager>(std::move(mgt));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x140, %rsp # imm = 0x140
movq %rdi, %r15
leaq 0x40(%rsp), %rdi
callq 0x22e47
leaq 0x506d3(%rip), %rsi # 0x732a0
leaq 0x80(%rsp), %r14
leaq 0x40(%rsp), %rdx
movq %r14, %rdi
callq 0x22e62
leaq 0xb0(%rsp), %rbx
leaq 0x30(%rsp), %rdi
callq 0x22e94
leaq 0x506a8(%rip), %rsi # 0x732a3
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x22eb0
leaq 0xe0(%rsp), %rbx
leaq 0x20(%rsp), %rdi
callq 0x22ee2
leaq 0x50685(%rip), %rsi # 0x732a6
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x22efe
leaq 0x110(%rsp), %rbx
leaq 0x10(%rsp), %rdi
callq 0x22f30
leaq 0x50662(%rip), %rsi # 0x732a9
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x22f4c
leaq 0x50(%rsp), %rdi
leaq 0x80(%rsp), %rsi
pushq $0x4
popq %rdx
leaq 0xf(%rsp), %rcx
leaq 0xe(%rsp), %r8
callq 0x22f7e
movl $0x90, %ebx
leaq (%rsp,%rbx), %rdi
addq $0x80, %rdi
callq 0x22fc6
addq $-0x30, %rbx
cmpq $-0x30, %rbx
jne 0x22c78
leaq 0x18(%rsp), %rdi
callq 0x21bce
leaq 0x28(%rsp), %rdi
callq 0x21bce
leaq 0x38(%rsp), %rdi
callq 0x21bce
leaq 0x48(%rsp), %rdi
callq 0x21bce
pushq $0x30
popq %rdi
callq 0x213c0
movq %rax, %rbx
leaq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x22fdc
movq %rbx, (%r15)
leaq 0x50(%rsp), %rdi
callq 0x2329e
movq %r15, %rax
addq $0x140, %rsp # imm = 0x140
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x212a0
jmp 0x22d05
movq %rax, %r15
leaq 0x50(%rsp), %rdi
callq 0x2329e
jmp 0x22db9
movq %rax, %r15
movl $0x90, %r12d
leaq (%rsp,%r12), %rdi
addq $0x80, %rdi
callq 0x22fc6
addq $-0x30, %r12
cmpq $-0x30, %r12
jne 0x22d1d
movb $0x1, %bpl
jmp 0x22d41
movq %rax, %r15
xorl %ebp, %ebp
leaq 0x18(%rsp), %rdi
callq 0x21bce
jmp 0x22d54
jmp 0x22d4f
movq %rax, %r15
xorl %ebp, %ebp
leaq 0x28(%rsp), %rdi
callq 0x21bce
jmp 0x22d67
jmp 0x22d62
movq %rax, %r15
xorl %ebp, %ebp
leaq 0x38(%rsp), %rdi
callq 0x21bce
leaq 0x48(%rsp), %rdi
callq 0x21bce
cmpq %rbx, %r14
sete %al
testb %bpl, %bpl
jne 0x22db9
testb %al, %al
jne 0x22db9
leaq 0x80(%rsp), %r14
addq $-0x30, %rbx
movq %rbx, %rdi
callq 0x22fc6
cmpq %r14, %rbx
jne 0x22d92
jmp 0x22db9
movq %rax, %r15
xorl %ebp, %ebp
jmp 0x22d71
movq %rax, %r15
xorl %ebp, %ebp
movq %r14, %rbx
jmp 0x22d71
movq %rax, %r15
movq %r15, %rdi
callq 0x21330
nop
|
/Oreobird[P]effect3d/src/EffectManager.cpp
|
ImageHandler::doTask()
|
int ImageHandler::doTask()
{
std::vector<Object> objects;
int ret = m_detector->detect(m_img, objects, m_targetName);
if (ret != 0)
{
return -1;
}
//ret = m_detector->draw(m_img, objects);
ret = m_effect->draw(m_img, objects);
if (ret != 0)
{
return -1;
}
return 0;
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
movq 0x18(%rdi), %rdi
leaq 0x38(%r14), %rbx
leaq 0x98(%r14), %rcx
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
testl %eax, %eax
je 0x23ced
pushq $-0x1
popq %rbx
jmp 0x23d03
movq 0x28(%r14), %rdi
movq (%rdi), %rax
movq %rsp, %rdx
movq %rbx, %rsi
callq *0x10(%rax)
xorl %ebx, %ebx
negl %eax
sbbl %ebx, %ebx
movq %rsp, %rdi
callq 0x23de6
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x23de6
movq %rbx, %rdi
callq 0x21330
|
/Oreobird[P]effect3d/src/ImageHandler.cpp
|
VideoHandler::preProcess(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&)
|
int VideoHandler::preProcess(const std::string &videoInFile, const std::string &targetName)
{
m_cap = std::make_shared<cv::VideoCapture>(videoInFile.c_str());
if (!m_cap || !m_cap->isOpened())
{
std::cout << "Error open video file" << std::endl;
return -1;
}
m_targetName = targetName;
return 0;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x244f9
leaq 0x38(%r14), %rdi
movq %r15, %rsi
callq 0x247bc
leaq 0x18(%rsp), %rdi
callq 0x21bce
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x241f7
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x241f7
addq $0x70, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21150
xorl %eax, %eax
jmp 0x24215
movq 0x73dc2(%rip), %rdi # 0x97fc0
leaq 0x4f3b3(%rip), %rsi # 0x735b8
callq 0x21420
movq %rax, %rdi
callq 0x21100
pushq $-0x1
popq %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/Oreobird[P]effect3d/src/VideoHandler.cpp
|
main
|
int main(int argc, char** argv)
{
opt_t opt;
processCommandLine(argc, argv, opt);
if (!opt.video.empty() && !opt.image.empty())
{
return -1;
}
if (!opt.video.empty())
{
auto videoHandler = std::make_shared<VideoHandler>(opt.detector, opt.effect);
videoHandler->preProcess(opt.filePath, opt.target);
videoHandler->doTask();
videoHandler->postProcess(opt.video);
}
else if (!opt.image.empty())
{
auto imgHandler = std::make_shared<ImageHandler>(opt.detector, opt.effect);
imgHandler->preProcess(opt.filePath, opt.target);
imgHandler->doTask();
imgHandler->postProcess(opt.image);
}
return 0;
}
|
pushq %r14
pushq %rbx
subq $0xd8, %rsp
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x88(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0xa8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0xc8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x18(%rsp), %rdx
callq 0x26dac
leaq 0x58(%rsp), %rsi
leaq 0x78(%rsp), %rdx
leaq 0xb8(%rsp), %r14
cmpq $0x0, -0x78(%r14)
movq -0x18(%r14), %rax
je 0x26fcc
testq %rax, %rax
je 0x2701d
pushq $-0x1
popq %rbx
jmp 0x27060
xorl %ebx, %ebx
testq %rax, %rax
je 0x27060
leaq 0x8(%rsp), %rdi
callq 0x270c2
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x18(%rsp), %rsi
movq %r14, %rdx
callq *(%rax)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x98(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x10(%rsp), %rdi
callq 0x21bce
jmp 0x27060
leaq 0x8(%rsp), %rdi
callq 0x270a1
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x18(%rsp), %rsi
movq %r14, %rdx
callq *(%rax)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x10(%rsp), %rdi
callq 0x21bce
xorl %ebx, %ebx
leaq 0x18(%rsp), %rdi
callq 0x270e4
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
jmp 0x2708c
jmp 0x2708c
jmp 0x2707d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x21bce
jmp 0x2708f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x270e4
movq %rbx, %rdi
callq 0x21330
|
/Oreobird[P]effect3d/src/main.cpp
|
ncnn::Mat::substract_mean_normalize(float const*, float const*)
|
void Mat::substract_mean_normalize(const float* mean_vals, const float* norm_vals)
{
Layer* op;
if (mean_vals && !norm_vals)
{
// substract mean only
op = create_layer(LayerType::Bias);
ParamDict pd;
pd.set(0, c);
op->load_param(pd);
Mat weights[1];
weights[0] = Mat(c);
for (int q=0; q<c; q++)
{
weights[0][q] = -mean_vals[q];
}
op->load_model(ModelBinFromMatArray(weights));
}
else if (!mean_vals && norm_vals)
{
// normalize only
op = create_layer(LayerType::Scale);
ParamDict pd;
pd.set(0, c);
op->load_param(pd);
Mat weights[1];
weights[0] = Mat(c);
for (int q=0; q<c; q++)
{
weights[0][q] = norm_vals[q];
}
op->load_model(ModelBinFromMatArray(weights));
}
else if (mean_vals && norm_vals)
{
// substract mean and normalize
op = create_layer(LayerType::Scale);
ParamDict pd;
pd.set(0, c);
pd.set(1, 1);
op->load_param(pd);
Mat weights[2];
weights[0] = Mat(c);
weights[1] = Mat(c);
for (int q=0; q<c; q++)
{
weights[0][q] = norm_vals[q];
weights[1][q] = - mean_vals[q] * norm_vals[q];
}
op->load_model(ModelBinFromMatArray(weights));
}
else // if (!mean_vals && !norm_vals)
{
return;
}
Option opt;
opt.num_threads = 1;// TODO
op->create_pipeline(opt);
op->forward_inplace(*this, opt);
op->destroy_pipeline(opt);
delete op;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x9c0, %rsp # imm = 0x9C0
movq %rsi, %r15
movq %rdi, %rbx
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
setne %cl
orb %al, %cl
je 0x27586
movq %rdx, %r12
testq %rdx, %rdx
sete %al
testq %r15, %r15
setne %cl
orb %al, %cl
jne 0x27647
pushq $0x1d
popq %rdi
callq 0x323eb
movq %rax, %r14
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
callq 0x30860
movl 0x34(%rbx), %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x30986
movq (%r14), %rax
leaq 0xc0(%rsp), %rsi
movq %r14, %rdi
callq *0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4c(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x70(%rsp)
movl 0x34(%rbx), %esi
movq %rsp, %rdi
pushq $0x4
popq %rdx
xorl %ecx, %ecx
callq 0x286ca
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x286e2
movq %rsp, %rdi
callq 0x26144
movl 0x34(%rbx), %eax
movq 0x40(%rsp), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x27773
movss (%r12,%rdx,4), %xmm0
movss %xmm0, (%rcx,%rdx,4)
incq %rdx
jmp 0x2756d
pushq $0x3
popq %rdi
callq 0x323eb
movq %rax, %r14
leaq 0xc0(%rsp), %r12
movq %r12, %rdi
callq 0x30860
movl 0x34(%rbx), %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x30986
movq (%r14), %rax
leaq 0xc0(%rsp), %rsi
movq %r14, %rdi
callq *0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4c(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x70(%rsp)
movl 0x34(%rbx), %esi
movq %rsp, %rdi
pushq $0x4
popq %rdx
xorl %ecx, %ecx
callq 0x286ca
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x286e2
movq %rsp, %rdi
callq 0x26144
movl 0x34(%rbx), %eax
movq 0x40(%rsp), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movaps 0x4c67f(%rip), %xmm0 # 0x73c90
cmpq %rdx, %rax
je 0x27629
movss (%r15,%rdx,4), %xmm1
xorps %xmm0, %xmm1
movss %xmm1, (%rcx,%rdx,4)
incq %rdx
jmp 0x27611
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x2cada
movq (%r14), %rax
movq %rsp, %rsi
movq %r14, %rdi
callq *0x18(%rax)
jmp 0x2778c
testq %r12, %r12
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x277f3
pushq $0x1d
popq %rdi
callq 0x323eb
movq %rax, %r14
leaq 0xc0(%rsp), %r13
movq %r13, %rdi
callq 0x30860
movl 0x34(%rbx), %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x30986
leaq 0xc0(%rsp), %rdi
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0x30986
movq (%r14), %rax
leaq 0xc0(%rsp), %rsi
movq %r14, %rdi
callq *0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4c(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x80(%rsp)
movups %xmm0, 0x8c(%rsp)
movl 0x34(%rbx), %esi
movq %rsp, %rdi
pushq $0x4
popq %rdx
xorl %ecx, %ecx
callq 0x286ca
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x286e2
movq %rsp, %rdi
callq 0x26144
movl 0x34(%rbx), %esi
movq %rsp, %rdi
pushq $0x4
popq %rdx
xorl %ecx, %ecx
callq 0x286ca
leaq 0x80(%rsp), %rdi
movq %rsp, %rsi
callq 0x286e2
movq %rsp, %rdi
callq 0x26144
movl 0x34(%rbx), %eax
movq 0x40(%rsp), %rcx
movq 0x80(%rsp), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
movaps 0x4c548(%rip), %xmm0 # 0x73c90
cmpq %rsi, %rax
je 0x27804
movss (%r12,%rsi,4), %xmm1
movss %xmm1, (%rcx,%rsi,4)
movss (%r15,%rsi,4), %xmm2
xorps %xmm0, %xmm2
mulss %xmm1, %xmm2
movss %xmm2, (%rdx,%rsi,4)
incq %rsi
jmp 0x27748
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x2cada
movq (%r14), %rax
movq %rsp, %rsi
movq %r14, %rdi
callq *0x18(%rax)
movq %rsp, %rdi
callq 0x2cb2a
leaq 0x40(%rsp), %rdi
callq 0x26144
leaq 0xc0(%rsp), %rdi
callq 0x28740
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
callq 0x3082c
movl $0x1, 0x4(%r15)
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *0x48(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x28(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x9c0, %rsp # imm = 0x9C0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x2cada
movq (%r14), %rax
movq %rsp, %rsi
movq %r14, %rdi
callq *0x18(%rax)
movq %rsp, %rdi
callq 0x2cb2a
pushq $0x40
popq %r15
leaq (%rsp,%r15), %rdi
addq $0x40, %rdi
callq 0x26144
addq $-0x40, %r15
cmpq $-0x40, %r15
jne 0x27829
jmp 0x2779e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2cb2a
jmp 0x27868
jmp 0x27865
jmp 0x27858
jmp 0x27865
movq %rax, %rbx
movq %rsp, %rdi
callq 0x26144
jmp 0x27868
movq %rax, %rbx
pushq $0x40
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x40, %rdi
callq 0x26144
addq $-0x40, %r14
cmpq $-0x40, %r14
jne 0x2786c
jmp 0x278bf
jmp 0x2788f
jmp 0x278ab
jmp 0x2789e
jmp 0x278ab
jmp 0x278bc
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2cb2a
jmp 0x278ae
jmp 0x278ab
movq %rax, %rbx
movq %rsp, %rdi
callq 0x26144
jmp 0x278ae
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x26144
jmp 0x278bf
jmp 0x278bc
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x28740
movq %rbx, %rdi
callq 0x21330
|
/Oreobird[P]effect3d/3rdparty/ncnn/src/mat.cpp
|
ncnn::resize_bilinear(ncnn::Mat const&, ncnn::Mat&, int, int, ncnn::Option const&)
|
void resize_bilinear(const Mat& src, Mat& dst, int w, int h, const Option& opt)
{
Layer* interp = create_layer(LayerType::Interp);
ParamDict pd;
pd.set(0, 2);
pd.set(3, h);
pd.set(4, w);
interp->load_param(pd);
interp->create_pipeline(opt);
interp->forward(src, dst, opt);
interp->destroy_pipeline(opt);
delete interp;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x908, %rsp # imm = 0x908
movq %r8, %rbx
movl %ecx, %r13d
movl %edx, %ebp
movq %rsi, (%rsp)
movq %rdi, %r12
pushq $0x32
popq %rdi
callq 0x323eb
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x30860
pushq $0x2
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x30986
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
movl %r13d, %edx
callq 0x30986
leaq 0x8(%rsp), %rdi
pushq $0x4
popq %rsi
movl %ebp, %edx
callq 0x30986
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
movq %rbx, %rcx
callq *0x38(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x28(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x28740
addq $0x908, %rsp # imm = 0x908
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x28740
movq %rbx, %rdi
callq 0x21330
|
/Oreobird[P]effect3d/3rdparty/ncnn/src/mat.cpp
|
main
|
int main(int argc, char* argv[])
{
// auto increment_by5 = Increment{5};
// auto increment_by10 = Increment{10};
//// increment.operator()();
// auto i = 100;
// for(int k=0; k<3; ++k)
// increment_by5(i);
// cout << i << endl;
auto v = vector<float>{10.1, 20.2, 30.3};
print(v);
// by_what = 3;
transform(v, Increment<float>{3.5f});
print(v);
// transform(v, Square{});
auto square = [](auto& item) { item = item*item; };
transform(v, square);
print(v);
return 0;
}
|
pushq %rbx
subq $0x30, %rsp
movsd 0xdb7(%rip), %xmm0 # 0x2010
leaq 0x20(%rsp), %rsi
movsd %xmm0, (%rsi)
movl $0x41f26666, 0x8(%rsi) # imm = 0x41F26666
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x3, %edx
movq %rbx, %rdi
callq 0x132c
movq %rbx, %rdi
callq 0x1371
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq %rcx, %rax
je 0x12b4
movss 0xd81(%rip), %xmm0 # 0x2020
movss (%rax), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rax)
addq $0x4, %rax
cmpq %rcx, %rax
jne 0x129f
leaq 0x8(%rsp), %rdi
callq 0x1371
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq %rcx, %rax
je 0x12df
movss (%rax), %xmm0
mulss %xmm0, %xmm0
movss %xmm0, (%rax)
addq $0x4, %rax
jmp 0x12c8
leaq 0x8(%rsp), %rdi
callq 0x1371
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1300
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x10b0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
retq
jmp 0x130a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1324
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x10b0
movq %rbx, %rdi
callq 0x1100
|
/furkankirac[P]cs321-2020-21-fall/week5-app3.cpp
|
Basic_Longer_Test::TestBody()
|
TEST(Basic, Longer)
{
std::string numStr_1, numStr_2 = "-", numStr_3, numStr_4 = "-";
for (int i = 1; i <= 65536; i++)
{
numStr_1 += (i % 9) + '0';
numStr_2 += (i % 7) + '0';
numStr_3 += (i % 5) + '0';
numStr_4 += (i % 3) + '0';
}
BigNumber num_1 = numStr_1;
BigNumber num_2 = numStr_2;
BigNumber num_3 = numStr_3;
BigNumber num_4 = numStr_4;
EXPECT_EQ(numStr_1, num_1.toString());
EXPECT_EQ(numStr_2, num_2.toString());
EXPECT_EQ(numStr_3, num_3.toString());
EXPECT_EQ(numStr_4, num_4.toString());
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x90(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x27635f(%rip), %rsi # 0x2808b7
leaq 0x276359(%rip), %rdx # 0x2808b8
leaq -0xa0(%rbp), %rdi
callq 0xc2f88
leaq -0xb0(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x70(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x276327(%rip), %rsi # 0x2808b7
leaq 0x276321(%rip), %rdx # 0x2808b8
leaq -0x80(%rbp), %rdi
callq 0xc2f88
movl $0x1, %r13d
movl $0x10000, %ebx # imm = 0x10000
movb $0x31, %r14b
leaq -0x80(%rbp), %r12
movl %r13d, %r15d
imulq $0x38e38e39, %r15, %rax # imm = 0x38E38E39
shrq $0x21, %rax
leal (%rax,%rax,8), %eax
movl %r14d, %ecx
subb %al, %cl
movsbl %cl, %esi
leaq -0xe0(%rbp), %rdi
callq 0x83e0
imulq $0x24924925, %r15, %rax # imm = 0x24924925
shrq $0x20, %rax
movl %r13d, %ecx
subl %eax, %ecx
shrl %ecx
addl %eax, %ecx
shrl $0x2, %ecx
leal (,%rcx,8), %eax
subl %ecx, %eax
movl %r14d, %ecx
subb %al, %cl
movsbl %cl, %esi
leaq -0xa0(%rbp), %rdi
callq 0x83e0
movq %r15, %rax
movl $0xcccccccd, %ecx # imm = 0xCCCCCCCD
imulq %rcx, %rax
shrq $0x22, %rax
leal (%rax,%rax,4), %eax
movl %r14d, %ecx
subb %al, %cl
movsbl %cl, %esi
leaq -0xc0(%rbp), %rdi
callq 0x83e0
movl $0xaaaaaaab, %eax # imm = 0xAAAAAAAB
imulq %rax, %r15
shrq $0x21, %r15
leal (%r15,%r15,2), %eax
movl %r14d, %ecx
subb %al, %cl
movsbl %cl, %esi
movq %r12, %rdi
callq 0x83e0
incl %r13d
incb %r14b
decl %ebx
jne 0xa5b2
leaq -0x180(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0xecc98
leaq -0x158(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xecc98
leaq -0x130(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xecc98
leaq -0x108(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xecc98
leaq -0x60(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0xecf94
leaq 0x10cb56(%rip), %rsi # 0x117217
leaq 0x10caeb(%rip), %rdx # 0x1171b3
leaq -0x40(%rbp), %rdi
leaq -0xe0(%rbp), %rcx
leaq -0x60(%rbp), %r8
callq 0xc3520
leaq -0x50(%rbp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0xa6ee
callq 0x8430
cmpb $0x0, -0x40(%rbp)
jne 0xa766
leaq -0x60(%rbp), %rdi
callq 0xf1bf2
movq -0x38(%rbp), %rax
testq %rax, %rax
je 0xa70b
movq (%rax), %r8
jmp 0xa712
leaq 0x275c58(%rip), %r8 # 0x28036a
leaq 0x10ca09(%rip), %rdx # 0x117122
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movl $0x23, %ecx
callq 0xef910
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xef9ac
leaq -0x30(%rbp), %rdi
callq 0xef97c
cmpq $0x0, -0x60(%rbp)
je 0xa766
movl $0x1, %edi
callq 0xef90d
testb %al, %al
je 0xa766
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0xa766
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0xc2a3e
leaq -0x60(%rbp), %rdi
leaq -0x158(%rbp), %rsi
callq 0xecf94
leaq 0x10ca98(%rip), %rsi # 0x117220
leaq 0x10ca3b(%rip), %rdx # 0x1171ca
leaq -0x40(%rbp), %rdi
leaq -0xa0(%rbp), %rcx
leaq -0x60(%rbp), %r8
callq 0xc3520
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0xa7b1
callq 0x8430
cmpb $0x0, -0x40(%rbp)
jne 0xa829
leaq -0x60(%rbp), %rdi
callq 0xf1bf2
movq -0x38(%rbp), %rax
testq %rax, %rax
je 0xa7ce
movq (%rax), %r8
jmp 0xa7d5
leaq 0x275b95(%rip), %r8 # 0x28036a
leaq 0x10c946(%rip), %rdx # 0x117122
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movl $0x24, %ecx
callq 0xef910
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xef9ac
leaq -0x30(%rbp), %rdi
callq 0xef97c
cmpq $0x0, -0x60(%rbp)
je 0xa829
movl $0x1, %edi
callq 0xef90d
testb %al, %al
je 0xa829
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0xa829
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0xc2a3e
leaq -0x60(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0xecf94
leaq 0x10c9de(%rip), %rsi # 0x117229
leaq 0x10c990(%rip), %rdx # 0x1171e2
leaq -0x40(%rbp), %rdi
leaq -0xc0(%rbp), %rcx
leaq -0x60(%rbp), %r8
callq 0xc3520
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0xa874
callq 0x8430
cmpb $0x0, -0x40(%rbp)
jne 0xa8ec
leaq -0x60(%rbp), %rdi
callq 0xf1bf2
movq -0x38(%rbp), %rax
testq %rax, %rax
je 0xa891
movq (%rax), %r8
jmp 0xa898
leaq 0x275ad2(%rip), %r8 # 0x28036a
leaq 0x10c883(%rip), %rdx # 0x117122
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movl $0x25, %ecx
callq 0xef910
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xef9ac
leaq -0x30(%rbp), %rdi
callq 0xef97c
cmpq $0x0, -0x60(%rbp)
je 0xa8ec
movl $0x1, %edi
callq 0xef90d
testb %al, %al
je 0xa8ec
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0xa8ec
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0xc2a3e
leaq -0x60(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0xecf94
leaq 0x10c924(%rip), %rsi # 0x117232
leaq 0x10c8e5(%rip), %rdx # 0x1171fa
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rcx
leaq -0x60(%rbp), %r8
callq 0xc3520
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0xa934
callq 0x8430
cmpb $0x0, -0x40(%rbp)
jne 0xa9ac
leaq -0x60(%rbp), %rdi
callq 0xf1bf2
movq -0x38(%rbp), %rax
testq %rax, %rax
je 0xa951
movq (%rax), %r8
jmp 0xa958
leaq 0x275a12(%rip), %r8 # 0x28036a
leaq 0x10c7c3(%rip), %rdx # 0x117122
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movl $0x26, %ecx
callq 0xef910
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xef9ac
leaq -0x30(%rbp), %rdi
callq 0xef97c
cmpq $0x0, -0x60(%rbp)
je 0xa9ac
movl $0x1, %edi
callq 0xef90d
testb %al, %al
je 0xa9ac
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0xa9ac
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0xc2a3e
leaq -0x108(%rbp), %rdi
callq 0xecf44
leaq -0x130(%rbp), %rdi
callq 0xecf44
leaq -0x158(%rbp), %rdi
callq 0xecf44
leaq -0x180(%rbp), %rdi
callq 0xecf44
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0xa9f9
callq 0x8430
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rax
cmpq %rax, %rdi
je 0xaa11
callq 0x8430
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rax
cmpq %rax, %rdi
je 0xaa29
callq 0x8430
movq -0xe0(%rbp), %rdi
leaq -0xd0(%rbp), %rax
cmpq %rax, %rdi
je 0xaa41
callq 0x8430
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaab5
jmp 0xaab5
jmp 0xaab5
jmp 0xaab5
jmp 0xaa6d
jmp 0xaa7b
jmp 0xaa89
jmp 0xaa6d
jmp 0xaa7b
jmp 0xaa89
jmp 0xaa6d
jmp 0xaa7b
jmp 0xaa89
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xef97c
jmp 0xaa7e
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xc2750
jmp 0xaa8c
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xc2766
jmp 0xaad7
jmp 0xaab5
jmp 0xaaa5
jmp 0xaad4
jmp 0xaab5
jmp 0xaaa5
jmp 0xaad4
jmp 0xaab5
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
jne 0xaacd
jmp 0xaad7
jmp 0xaad4
movq %rax, %rdi
callq 0xc29ae
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaad7
callq 0x8430
jmp 0xaad7
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0xecf44
leaq -0x130(%rbp), %rdi
callq 0xecf44
leaq -0x158(%rbp), %rdi
callq 0xecf44
leaq -0x180(%rbp), %rdi
callq 0xecf44
jmp 0xab27
movq %rax, %rbx
jmp 0xaae3
movq %rax, %rbx
jmp 0xaaef
movq %rax, %rbx
jmp 0xaafb
jmp 0xab24
movq %rax, %rbx
jmp 0xab39
movq %rax, %rbx
jmp 0xab69
movq %rax, %rbx
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0xab39
callq 0x8430
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rax
cmpq %rax, %rdi
je 0xab51
callq 0x8430
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rax
cmpq %rax, %rdi
je 0xab69
callq 0x8430
movq -0xe0(%rbp), %rdi
leaq -0xd0(%rbp), %rax
cmpq %rax, %rdi
je 0xab81
callq 0x8430
movq %rbx, %rdi
callq 0x8930
nop
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/test/basic.h
|
Subtraction_PlusPlus_Test::TestBody()
|
TEST(Subtraction, PlusPlus)
{
BigNumber num_1("1234");
EXPECT_EQ("1234", num_1--.toString());
EXPECT_EQ("1233", num_1.toString());
EXPECT_EQ("1233", num_1--.toString());
EXPECT_EQ("1231", (--num_1).toString());
EXPECT_EQ("1230", (--num_1).toString());
EXPECT_EQ("1230", num_1.toString());
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xe7392(%rip), %rsi # 0x1172db
leaq 0xe738f(%rip), %rdx # 0x1172df
leaq -0x50(%rbp), %rdi
callq 0xc2f88
leaq -0x98(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xecc98
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x2ff77
callq 0x8430
leaq -0x50(%rbp), %rdi
leaq -0x98(%rbp), %rsi
xorl %edx, %edx
callq 0xede06
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xecf94
leaq 0xe7343(%rip), %rsi # 0x1172e0
leaq 0x13d49b(%rip), %rdx # 0x16d43f
leaq 0xe7330(%rip), %rcx # 0x1172db
leaq -0x28(%rbp), %rdi
leaq -0x70(%rbp), %r8
callq 0xc340f
leaq -0x60(%rbp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x2ffca
callq 0x8430
leaq -0x50(%rbp), %rdi
callq 0xecf44
cmpb $0x0, -0x28(%rbp)
jne 0x3004b
leaq -0x50(%rbp), %rdi
callq 0xf1bf2
movq -0x20(%rbp), %rax
testq %rax, %rax
je 0x2fff0
movq (%rax), %r8
jmp 0x2fff7
leaq 0x250373(%rip), %r8 # 0x28036a
leaq 0x13d3b1(%rip), %rdx # 0x16d3af
leaq -0x70(%rbp), %rdi
movl $0x1, %esi
movl $0x18, %ecx
callq 0xef910
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xef9ac
leaq -0x70(%rbp), %rdi
callq 0xef97c
cmpq $0x0, -0x50(%rbp)
je 0x3004b
movl $0x1, %edi
callq 0xef90d
testb %al, %al
je 0x3004b
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3004b
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xc2a3e
leaq -0x50(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xecf94
leaq 0x13d3e5(%rip), %rsi # 0x16d452
leaq 0xe713f(%rip), %rdx # 0x1171b3
leaq 0x13d3de(%rip), %rcx # 0x16d459
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %r8
callq 0xc340f
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x30096
callq 0x8430
cmpb $0x0, -0x70(%rbp)
jne 0x3010e
leaq -0x50(%rbp), %rdi
callq 0xf1bf2
movq -0x68(%rbp), %rax
testq %rax, %rax
je 0x300b3
movq (%rax), %r8
jmp 0x300ba
leaq 0x2502b0(%rip), %r8 # 0x28036a
leaq 0x13d2ee(%rip), %rdx # 0x16d3af
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
movl $0x19, %ecx
callq 0xef910
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xef9ac
leaq -0x28(%rbp), %rdi
callq 0xef97c
cmpq $0x0, -0x50(%rbp)
je 0x3010e
movl $0x1, %edi
callq 0xef90d
testb %al, %al
je 0x3010e
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3010e
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0xc2a3e
leaq -0x50(%rbp), %rdi
leaq -0x98(%rbp), %rsi
xorl %edx, %edx
callq 0xede06
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xecf94
leaq 0x13d313(%rip), %rsi # 0x16d452
leaq 0x13d2f9(%rip), %rdx # 0x16d43f
leaq 0x13d30c(%rip), %rcx # 0x16d459
leaq -0x28(%rbp), %rdi
leaq -0x70(%rbp), %r8
callq 0xc340f
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x30168
callq 0x8430
leaq -0x50(%rbp), %rdi
callq 0xecf44
cmpb $0x0, -0x28(%rbp)
jne 0x301e9
leaq -0x50(%rbp), %rdi
callq 0xf1bf2
movq -0x20(%rbp), %rax
testq %rax, %rax
je 0x3018e
movq (%rax), %r8
jmp 0x30195
leaq 0x2501d5(%rip), %r8 # 0x28036a
leaq 0x13d213(%rip), %rdx # 0x16d3af
leaq -0x70(%rbp), %rdi
movl $0x1, %esi
movl $0x1a, %ecx
callq 0xef910
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xef9ac
leaq -0x70(%rbp), %rdi
callq 0xef97c
cmpq $0x0, -0x50(%rbp)
je 0x301e9
movl $0x1, %edi
callq 0xef90d
testb %al, %al
je 0x301e9
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x301e9
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xc2a3e
leaq -0x98(%rbp), %rdi
callq 0xedd0a
leaq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xecf94
leaq 0x13d24b(%rip), %rsi # 0x16d45e
leaq 0x13d24b(%rip), %rdx # 0x16d465
leaq 0x13d259(%rip), %rcx # 0x16d47a
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %r8
callq 0xc340f
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x3023c
callq 0x8430
cmpb $0x0, -0x70(%rbp)
jne 0x302b4
leaq -0x50(%rbp), %rdi
callq 0xf1bf2
movq -0x68(%rbp), %rax
testq %rax, %rax
je 0x30259
movq (%rax), %r8
jmp 0x30260
leaq 0x25010a(%rip), %r8 # 0x28036a
leaq 0x13d148(%rip), %rdx # 0x16d3af
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
movl $0x1b, %ecx
callq 0xef910
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xef9ac
leaq -0x28(%rbp), %rdi
callq 0xef97c
cmpq $0x0, -0x50(%rbp)
je 0x302b4
movl $0x1, %edi
callq 0xef90d
testb %al, %al
je 0x302b4
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x302b4
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0xc2a3e
leaq -0x98(%rbp), %rdi
callq 0xedd0a
leaq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xecf94
leaq 0x13d1a1(%rip), %rsi # 0x16d47f
leaq 0x13d180(%rip), %rdx # 0x16d465
leaq 0x13d19a(%rip), %rcx # 0x16d486
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %r8
callq 0xc340f
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x30307
callq 0x8430
cmpb $0x0, -0x70(%rbp)
jne 0x3037f
leaq -0x50(%rbp), %rdi
callq 0xf1bf2
movq -0x68(%rbp), %rax
testq %rax, %rax
je 0x30324
movq (%rax), %r8
jmp 0x3032b
leaq 0x25003f(%rip), %r8 # 0x28036a
leaq 0x13d07d(%rip), %rdx # 0x16d3af
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
movl $0x1c, %ecx
callq 0xef910
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xef9ac
leaq -0x28(%rbp), %rdi
callq 0xef97c
cmpq $0x0, -0x50(%rbp)
je 0x3037f
movl $0x1, %edi
callq 0xef90d
testb %al, %al
je 0x3037f
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3037f
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0xc2a3e
leaq -0x50(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xecf94
leaq 0x13d0de(%rip), %rsi # 0x16d47f
leaq 0xe6e0b(%rip), %rdx # 0x1171b3
leaq 0x13d0d7(%rip), %rcx # 0x16d486
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %r8
callq 0xc340f
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x303ca
callq 0x8430
cmpb $0x0, -0x70(%rbp)
jne 0x30442
leaq -0x50(%rbp), %rdi
callq 0xf1bf2
movq -0x68(%rbp), %rax
testq %rax, %rax
je 0x303e7
movq (%rax), %r8
jmp 0x303ee
leaq 0x24ff7c(%rip), %r8 # 0x28036a
leaq 0x13cfba(%rip), %rdx # 0x16d3af
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
movl $0x1d, %ecx
callq 0xef910
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xef9ac
leaq -0x28(%rbp), %rdi
callq 0xef97c
cmpq $0x0, -0x50(%rbp)
je 0x30442
movl $0x1, %edi
callq 0xef90d
testb %al, %al
je 0x30442
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x30442
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0xc2a3e
leaq -0x98(%rbp), %rdi
callq 0xecf44
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30528
jmp 0x30528
jmp 0x30528
jmp 0x30528
jmp 0x30528
jmp 0x30528
jmp 0x3049d
jmp 0x304ab
jmp 0x304b9
jmp 0x3049d
jmp 0x304ab
jmp 0x304b9
jmp 0x3049d
jmp 0x304ab
jmp 0x304b9
jmp 0x304c2
jmp 0x304d0
jmp 0x304de
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xef97c
jmp 0x304ae
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xc2750
jmp 0x304bc
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x304e5
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0xef97c
jmp 0x304d3
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xc2750
jmp 0x304e1
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xc2766
jmp 0x30574
jmp 0x30528
jmp 0x30513
jmp 0x30571
jmp 0x30528
jmp 0x30513
jmp 0x30528
jmp 0x30513
jmp 0x30528
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
jne 0x30540
jmp 0x3054a
jmp 0x30547
jmp 0x30571
jmp 0x30528
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x30574
callq 0x8430
jmp 0x30574
jmp 0x30571
movq %rax, %rdi
callq 0xc29ae
movq %rax, %rbx
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3054a
callq 0x8430
jmp 0x3054a
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xecf44
jmp 0x30574
jmp 0x30571
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x30580
callq 0x8430
jmp 0x30580
movq %rax, %rbx
jmp 0x30580
jmp 0x30571
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0xecf44
movq %rbx, %rdi
callq 0x8930
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/test/subtraction.h
|
testing::Message::~Message()
|
class GTEST_API_ Message {
private:
// The type of basic IO manipulators (endl, ends, and flush) for
// narrow streams.
typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
public:
// Constructs an empty Message.
Message();
// Copy constructor.
Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT
*ss_ << msg.GetString();
}
// Constructs a Message from a C-string.
explicit Message(const char* str) : ss_(new ::std::stringstream) {
*ss_ << str;
}
#if GTEST_OS_SYMBIAN
// Streams a value (either a pointer or not) to this object.
template <typename T>
inline Message& operator <<(const T& value) {
StreamHelper(typename internal::is_pointer<T>::type(), value);
return *this;
}
#else
// Streams a non-pointer value to this object.
template <typename T>
inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the global
// namespace, but not other namespaces, including the testing
// namespace which Google Test's Message class is in.
//
// To allow STL containers (and other types that has a << operator
// defined in the global namespace) to be used in Google Test
// assertions, testing::Message must access the custom << operator
// from the global namespace. With this using declaration,
// overloads of << defined in the global namespace and those
// visible via Koenig lookup are both exposed in this function.
using ::operator <<;
*ss_ << val;
return *this;
}
// Streams a pointer value to this object.
//
// This function is an overload of the previous one. When you
// stream a pointer to a Message, this definition will be used as it
// is more specialized. (The C++ Standard, section
// [temp.func.order].) If you stream a non-pointer, then the
// previous definition will be used.
//
// The reason for this overload is that streaming a NULL pointer to
// ostream is undefined behavior. Depending on the compiler, you
// may get "0", "(nil)", "(null)", or an access violation. To
// ensure consistent result across compilers, we always treat NULL
// as "(null)".
template <typename T>
inline Message& operator <<(T* const& pointer) { // NOLINT
if (pointer == NULL) {
*ss_ << "(null)";
} else {
*ss_ << pointer;
}
return *this;
}
#endif // GTEST_OS_SYMBIAN
// Since the basic IO manipulators are overloaded for both narrow
// and wide streams, we have to provide this specialized definition
// of operator <<, even though its body is the same as the
// templatized version above. Without this definition, streaming
// endl or other basic IO manipulators to Message will confuse the
// compiler.
Message& operator <<(BasicNarrowIoManip val) {
*ss_ << val;
return *this;
}
// Instead of 1/0, we want to see true/false for bool values.
Message& operator <<(bool b) {
return *this << (b ? "true" : "false");
}
// These two overloads allow streaming a wide C string to a Message
// using the UTF-8 encoding.
Message& operator <<(const wchar_t* wide_c_str);
Message& operator <<(wchar_t* wide_c_str);
#if GTEST_HAS_STD_WSTRING
// Converts the given wide string to a narrow string using the UTF-8
// encoding, and streams the result to this Message object.
Message& operator <<(const ::std::wstring& wstr);
#endif // GTEST_HAS_STD_WSTRING
#if GTEST_HAS_GLOBAL_WSTRING
// Converts the given wide string to a narrow string using the UTF-8
// encoding, and streams the result to this Message object.
Message& operator <<(const ::wstring& wstr);
#endif // GTEST_HAS_GLOBAL_WSTRING
// Gets the text streamed to this object so far as an std::string.
// Each '\0' character in the buffer is replaced with "\\0".
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
std::string GetString() const;
private:
#if GTEST_OS_SYMBIAN
// These are needed as the Nokia Symbian Compiler cannot decide between
// const T& and const T* in a function template. The Nokia compiler _can_
// decide between class template specializations for T and T*, so a
// tr1::type_traits-like is_pointer works, and we can overload on that.
template <typename T>
inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
if (pointer == NULL) {
*ss_ << "(null)";
} else {
*ss_ << pointer;
}
}
template <typename T>
inline void StreamHelper(internal::false_type /*is_pointer*/,
const T& value) {
// See the comments in Message& operator <<(const T&) above for why
// we need this using statement.
using ::operator <<;
*ss_ << value;
}
#endif // GTEST_OS_SYMBIAN
// We'll hold the text streamed to this object here.
const internal::scoped_ptr< ::std::stringstream> ss_;
// We declare (but don't implement) this to prevent the compiler
// from implementing the assignment operator.
void operator=(const Message&);
}
|
pushq %rbp
movq %rsp, %rbp
xorl %esi, %esi
callq 0xc2a08
popq %rbp
retq
movq %rax, %rdi
callq 0xc29ae
nop
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest-message.h
|
Basic_Simple_Test::~Basic_Simple_Test()
|
TEST(Basic, Simple)
{
BigNumber num_1;
BigNumber num_2("123");
BigNumber num_3("-456");
BigNumber num_4("-0789");
EXPECT_EQ("0", num_1.toString());
EXPECT_EQ("123", num_2.toString());
EXPECT_EQ("-456", num_3.toString());
EXPECT_EQ("-789", num_4.toString());
}
|
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf5b1c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8430
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/test/basic.h
|
Multiple_Zero_Test::~Multiple_Zero_Test()
|
TEST(Multiple, Zero)
{
BigNumber num_1 = BigNumber("0") * BigNumber("0");
BigNumber num_2 = BigNumber("0") * BigNumber("1");
BigNumber num_3 = BigNumber("-1") * BigNumber("0");
EXPECT_EQ("0", num_1.toString());
EXPECT_EQ("0", num_2.toString());
EXPECT_EQ("0", num_3.toString());
}
|
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf5b1c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8430
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/test/multiple.h
|
Division_Zero_Test::~Division_Zero_Test()
|
TEST(Division, Zero)
{
BigNumber num_1 = BigNumber("0") / BigNumber("1");
BigNumber num_2 = BigNumber("0") / BigNumber("-1");
BigNumber num_3 = BigNumber("0") % BigNumber("1");
BigNumber num_4 = BigNumber("0") % BigNumber("-1");
EXPECT_EQ("0", num_1.toString());
EXPECT_EQ("0", num_2.toString());
EXPECT_EQ("0", num_3.toString());
EXPECT_EQ("0", num_4.toString());
}
|
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf5b1c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8430
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/test/division.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc3068
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc307f
jmp 0xc306d
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x40(%rbp), %rsi
movq %rcx, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc3137
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0xc3268
leaq -0x60(%rbp), %rcx
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf2d7a
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc36fa
callq 0x8430
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc370c
callq 0x8430
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc3736
callq 0x8430
jmp 0xc3736
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc3748
callq 0x8430
movq %rbx, %rdi
callq 0x8930
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [249], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [249], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc38a3
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc38ba
jmp 0xc38a8
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [232], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [232], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x40(%rbp), %rsi
movq %rcx, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc3137
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0xc3268
leaq -0x60(%rbp), %rcx
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf2d7a
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc3c4f
callq 0x8430
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc3c61
callq 0x8430
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc3c8b
callq 0x8430
jmp 0xc3c8b
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc3c9d
callq 0x8430
movq %rbx, %rdi
callq 0x8930
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [332], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [332], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc401a
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc4031
jmp 0xc401f
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [408], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [408], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc434d
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc4364
jmp 0xc4352
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [497], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [497], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc4791
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc47a8
jmp 0xc4796
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [321], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [321], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc4bd5
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc4bec
jmp 0xc4bda
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [484], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [484], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc4ce6
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc4cfd
jmp 0xc4ceb
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [440], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [440], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc4df7
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc4e0e
jmp 0xc4dfc
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [382], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [382], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc4f08
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc4f1f
jmp 0xc4f0d
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [293], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [293], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc5019
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc5030
jmp 0xc501e
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [490], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [490], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc512a
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc5141
jmp 0xc512f
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [416], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [416], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc523b
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc5252
jmp 0xc5240
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [304], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [304], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc534c
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc5363
jmp 0xc5351
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [310], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [310], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x40(%rbp), %rsi
movq %rcx, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc3137
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0xc3268
leaq -0x60(%rbp), %rcx
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf2d7a
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc54d6
callq 0x8430
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc54e8
callq 0x8430
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5512
callq 0x8430
jmp 0xc5512
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5524
callq 0x8430
movq %rbx, %rdi
callq 0x8930
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [180], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [180], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x40(%rbp), %rsi
movq %rcx, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc3137
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0xc3268
leaq -0x60(%rbp), %rcx
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf2d7a
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc55e7
callq 0x8430
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc55f9
callq 0x8430
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5623
callq 0x8430
jmp 0xc5623
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5635
callq 0x8430
movq %rbx, %rdi
callq 0x8930
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [193], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [193], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x40(%rbp), %rsi
movq %rcx, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc3137
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0xc3268
leaq -0x60(%rbp), %rcx
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf2d7a
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5809
callq 0x8430
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc581b
callq 0x8430
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5845
callq 0x8430
jmp 0xc5845
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5857
callq 0x8430
movq %rbx, %rdi
callq 0x8930
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [328], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [328], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x40(%rbp), %rsi
movq %rcx, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc3137
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0xc3268
leaq -0x60(%rbp), %rcx
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf2d7a
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc591a
callq 0x8430
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc592c
callq 0x8430
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5956
callq 0x8430
jmp 0xc5956
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5968
callq 0x8430
movq %rbx, %rdi
callq 0x8930
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [504], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [504], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x40(%rbp), %rsi
movq %rcx, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc3137
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0xc3268
leaq -0x60(%rbp), %rcx
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf2d7a
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5b3c
callq 0x8430
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5b4e
callq 0x8430
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5b78
callq 0x8430
jmp 0xc5b78
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5b8a
callq 0x8430
movq %rbx, %rdi
callq 0x8930
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQ<char [250], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [250], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
if (lhs == rhs) {
return AssertionSuccess();
}
GTEST_DISABLE_MSC_WARNINGS_POP_()
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x8140
movq %rbx, %rdi
testl %eax, %eax
je 0xc5df6
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc5e0d
jmp 0xc5dfb
callq 0xf13a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [103], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [103], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x40(%rbp), %rsi
movq %rcx, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0xc3137
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0xc3268
leaq -0x60(%rbp), %rcx
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf2d7a
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc63c4
callq 0x8430
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc63d6
callq 0x8430
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc6400
callq 0x8430
jmp 0xc6400
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc6412
callq 0x8430
movq %rbx, %rdi
callq 0x8930
|
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.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.