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;
... | 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... | /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.... | 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
a... | /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 ... | 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(%... | /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>, (ano... | 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;
Modu... | 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, (%ra... | /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(%r... | /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... | /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<c... | 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 ... | /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... | /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(%r1... | /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, ... | /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), %... | /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, ... | /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... | /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
tes... | /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... | /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), %r... | /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 (%rc... | /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_... | 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 0x1441a... | /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 %... | /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 ... | /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(%r... | /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 $0... | /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)
mo... | /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::... | 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, %... | /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, %... | /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 += " ";
... | 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 $... | /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
r... | /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 {
... | 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 0x325... | /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();
ret... | 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 %ra... | /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... | 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), %... | /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 << "... | 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)... | /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
c... | /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... | 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 0x2... | /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) {
... | 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... | /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... | 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
l... | /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<va... | 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... | 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, r... | 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, %... | /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 &&
... | 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 ... | /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);
... | 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 %... | /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)
{
_glfwInputEr... | 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 ... | /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 0x9... | /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);
... | 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
... | /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 ... | /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 = m... | 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
xor... | /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 (... | 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, ... | /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 specif... | 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, ... | /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_RE... | 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 ... | /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... | 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
... | /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);... | 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 %... | /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::... | 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
cal... | /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... | 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... | /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);... | 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(%rb... | /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), shouldCheckD... | 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)
and... | /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, conto... | 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
cal... | /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)
mov... | /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... | /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), %rs... | /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_ = nullp... | 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
... | /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<Detect... | 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 (%... | /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 = ob... | 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
m... | /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 ... | 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... | /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;
}
... | 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 0x... | /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 = target... | 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... | /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... | 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(%rs... | /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];
... | 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 %r... | /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... | 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 ... | /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);
// ... | 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... | /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;
BigNu... | 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), %r... | /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), %r... | /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::strin... | 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());... | 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();... | 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, %... | /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,... | 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... | /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();... | 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, %... | /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,... | 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... | /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();... | 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, %... | /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();... | 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, %... | /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();... | 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, %... | /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();... | 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, %... | /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();... | 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, %... | /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();... | 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, %... | /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();... | 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, %... | /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();... | 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, %... | /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();... | 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, %... | /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();... | 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, %... | /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();... | 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, %... | /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,... | 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... | /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,... | 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... | /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,... | 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... | /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,... | 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... | /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,... | 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... | /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();... | 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, %... | /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,... | 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... | /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.