name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
OpenMD::DataStorage::reserve(unsigned long) | void DataStorage::reserve(std::size_t size) {
if (storageLayout_ & dslPosition) { position.reserve(size); }
if (storageLayout_ & dslVelocity) { velocity.reserve(size); }
if (storageLayout_ & dslForce) { force.reserve(size); }
if (storageLayout_ & dslAmat) { aMat.reserve(size); }
if (storageLayout_ & dslAngularMomentum) { angularMomentum.reserve(size); }
if (storageLayout_ & dslTorque) { torque.reserve(size); }
if (storageLayout_ & dslParticlePot) { particlePot.reserve(size); }
if (storageLayout_ & dslDensity) { density.reserve(size); }
if (storageLayout_ & dslFunctional) { functional.reserve(size); }
if (storageLayout_ & dslFunctionalDerivative) {
functionalDerivative.reserve(size);
}
if (storageLayout_ & dslDipole) { dipole.reserve(size); }
if (storageLayout_ & dslQuadrupole) { quadrupole.reserve(size); }
if (storageLayout_ & dslElectricField) { electricField.reserve(size); }
if (storageLayout_ & dslSkippedCharge) { skippedCharge.reserve(size); }
if (storageLayout_ & dslFlucQPosition) { flucQPos.reserve(size); }
if (storageLayout_ & dslFlucQVelocity) { flucQVel.reserve(size); }
if (storageLayout_ & dslFlucQForce) { flucQFrc.reserve(size); }
if (storageLayout_ & dslSitePotential) { sitePotential.reserve(size); }
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x1b8(%rdi), %eax
testb $0x1, %al
je 0xbfa06
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc02c6
movl 0x1b8(%r14), %eax
testb $0x2, %al
je 0xbfa1d
leaq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0xc02c6
movl 0x1b8(%r14), %eax
testb $0x4, %al
je 0xbfa34
leaq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0xc02c6
movl 0x1b8(%r14), %eax
testb $0x8, %al
je 0xbfa4b
leaq 0x48(%r14), %rdi
movq %rbx, %rsi
callq 0xc035c
movl 0x1b8(%r14), %eax
testb $0x10, %al
je 0xbfa62
leaq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0xc02c6
movl 0x1b8(%r14), %eax
testb $0x20, %al
je 0xbfa79
leaq 0x78(%r14), %rdi
movq %rbx, %rsi
callq 0xc02c6
movl 0x1b8(%r14), %eax
testb $0x40, %al
je 0xbfa93
leaq 0x90(%r14), %rdi
movq %rbx, %rsi
callq 0xb872a
movl 0x1b8(%r14), %eax
testb %al, %al
jns 0xbfaad
leaq 0xa8(%r14), %rdi
movq %rbx, %rsi
callq 0xb872a
movl 0x1b8(%r14), %eax
btl $0x8, %eax
jae 0xbfac9
leaq 0xc0(%r14), %rdi
movq %rbx, %rsi
callq 0xb872a
movl 0x1b8(%r14), %eax
btl $0x9, %eax
jae 0xbfae5
leaq 0xd8(%r14), %rdi
movq %rbx, %rsi
callq 0xb872a
movl 0x1b8(%r14), %eax
btl $0xa, %eax
jae 0xbfb01
leaq 0xf0(%r14), %rdi
movq %rbx, %rsi
callq 0xc02c6
movl 0x1b8(%r14), %eax
btl $0xb, %eax
jae 0xbfb1d
leaq 0x108(%r14), %rdi
movq %rbx, %rsi
callq 0xc035c
movl 0x1b8(%r14), %eax
btl $0xc, %eax
jae 0xbfb39
leaq 0x120(%r14), %rdi
movq %rbx, %rsi
callq 0xc02c6
movl 0x1b8(%r14), %eax
btl $0xd, %eax
jae 0xbfb55
leaq 0x138(%r14), %rdi
movq %rbx, %rsi
callq 0xb872a
movl 0x1b8(%r14), %eax
btl $0xe, %eax
jae 0xbfb71
leaq 0x150(%r14), %rdi
movq %rbx, %rsi
callq 0xb872a
movl 0x1b8(%r14), %eax
testw %ax, %ax
jns 0xbfb8c
leaq 0x168(%r14), %rdi
movq %rbx, %rsi
callq 0xb872a
movl 0x1b8(%r14), %eax
btl $0x10, %eax
jae 0xbfba8
leaq 0x180(%r14), %rdi
movq %rbx, %rsi
callq 0xb872a
movl 0x1b8(%r14), %eax
btl $0x11, %eax
jb 0xbfbb6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x198, %r14 # imm = 0x198
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb872a
nop
| /OpenMD[P]OpenMD/src/brains/DataStorage.cpp |
OpenMD::SectionParser::isEndSection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool SectionParser::isEndSection(const std::string& line) {
StringTokenizer tokenizer(line);
if (tokenizer.countTokens() >= 2) {
std::string keyword = tokenizer.nextToken();
if (keyword != "end") { return false; }
std::string section = tokenizer.nextToken();
if (section == sectionName_) {
return true;
} else {
return false;
}
} else {
return false;
}
} | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x332e(%rip), %rsi # 0xc5085
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x1a8b4
leaq 0x40(%rsp), %rdi
movq %rsp, %rdx
movq %r14, %rsi
callq 0xb9030
movq %rsp, %rdi
callq 0x13a98
leaq 0x40(%rsp), %rdi
callq 0xb912e
cmpl $0x2, %eax
jl 0xc1daf
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0xb91ec
leaq 0x5ce4(%rip), %rsi # 0xc7a83
movq %rsp, %rdi
callq 0xc1f37
testb %al, %al
je 0xc1db3
xorl %ebx, %ebx
jmp 0xc1de0
xorl %ebx, %ebx
jmp 0xc1de8
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xb91ec
addq $0x8, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51c3c
movl %eax, %ebx
movq %r14, %rdi
callq 0x13a98
movq %rsp, %rdi
callq 0x13a98
leaq 0x40(%rsp), %rdi
callq 0x1a91c
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
jmp 0xc1e01
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13a98
jmp 0xc1e13
jmp 0xc1e10
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x1a91c
jmp 0xc1e2f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13a98
jmp 0xc1e2f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x13960
nop
| /OpenMD[P]OpenMD/src/io/SectionParser.cpp |
OpenMD::SectionParser::stripComments(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SectionParser::stripComments(const std::string& line) {
unsigned int n = line.length();
std::string res;
// Flags to indicate that single line and multpile line comments
// have started or not.
bool s_cmt = false;
bool m_cmt = false;
// Traverse the line
for (unsigned int i = 0; i < n; i++) {
// If single line comment flag is on, then check for end of it
if (s_cmt == true && line[i] == '\n') s_cmt = false;
// If multiple line comment is on, then check for end of it
else if (m_cmt == true && line[i] == '*' && line[i + 1] == '/')
m_cmt = false, i++;
// If this character is in a comment, ignore it
else if (s_cmt || m_cmt)
continue;
// Check for beginning of comments and set the approproate flags
else if ((line[i] == '/' && line[i + 1] == '/') || (line[i] == '#'))
s_cmt = true, i++;
else if (line[i] == '/' && line[i + 1] == '*')
m_cmt = true, i++;
// If current character is a non-comment character, append it to res
else
res += line[i];
}
return res;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdx), %ebp
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %esi, %esi
xorl %r15d, %r15d
xorl %ecx, %ecx
cmpl %ebp, %r15d
jae 0xc1f16
movl %r15d, %eax
testb $0x1, %cl
je 0xc1e9c
movq (%r14), %rdx
movb (%rdx,%rax), %dil
cmpb $0xa, %dil
sete %dl
andb %sil, %dl
cmpb $0xa, %dil
setne %dil
je 0xc1e95
xorb $0x1, %sil
testb $0x1, %sil
je 0xc1ea2
movl %r15d, %eax
movl %edi, %ecx
jmp 0xc1eda
testb $0x1, %sil
je 0xc1ebf
movq (%r14), %rsi
movb $0x1, %dl
cmpb $0x2a, (%rsi,%rax)
jne 0xc1ed7
cmpb $0x2f, 0x1(%rsi,%rax)
setne %dl
jne 0xc1ed7
incq %rax
movl %eax, %r15d
jmp 0xc1ed7
movq (%r14), %rdx
movzbl (%rdx,%rax), %ecx
cmpl $0x2f, %ecx
je 0xc1ee6
cmpl $0x23, %ecx
jne 0xc1efe
incl %r15d
movb $0x1, %cl
xorl %edx, %edx
movl %r15d, %eax
incl %eax
movl %edx, %esi
movl %eax, %r15d
jmp 0xc1e5f
movzbl 0x1(%rdx,%rax), %edx
incq %rax
cmpl $0x2a, %edx
je 0xc1f10
cmpl $0x2f, %edx
jne 0xc1efe
xorl %edx, %edx
movb $0x1, %cl
jmp 0xc1eda
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x13420
xorl %edx, %edx
movl %r15d, %eax
jmp 0xc1f12
movb $0x1, %dl
xorl %ecx, %ecx
jmp 0xc1eda
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x13a98
movq %r14, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/io/SectionParser.cpp |
OpenMD::CubicSpline::getValueAt(double const&, double&) | void CubicSpline::getValueAt(const RealType& t, RealType& v) {
// Evaluate the spline at t using coefficients
//
// Input parameters
// t = point where spline is to be evaluated.
// Output:
// value of spline at t.
if (!generated) generate();
// Find the interval ( x[j], x[j+1] ) that contains or is nearest
// to t.
if (isUniform) {
j = int((t - x_[0]) * dx);
} else {
j = n - 1;
for (int i = 0; i < n; i++) {
if (t < x_[i]) {
j = i - 1;
break;
}
}
}
j = std::clamp(j, 0, n - 1);
// Evaluate the cubic polynomial.
dt = t - x_[j];
v = y_[j] + dt * (b[j] + dt * (c[j] + dt * d[j]));
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x0, 0x9(%rdi)
jne 0xc274c
movq %r14, %rdi
callq 0xc2026
cmpb $0x1, 0x8(%r14)
jne 0xc2777
movsd (%r15), %xmm0
movq 0x28(%r14), %rax
movapd %xmm0, %xmm1
subsd (%rax), %xmm1
mulsd 0x10(%r14), %xmm1
cvttsd2si %xmm1, %esi
movl 0x20(%r14), %edx
leal -0x1(%rdx), %ecx
jmp 0xc27b2
movl 0x20(%r14), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x24(%r14)
movsd (%r15), %xmm0
movq 0x28(%r14), %rax
xorl %esi, %esi
testl %edx, %edx
movl $0x0, %edi
cmovgl %edx, %edi
cmpq %rsi, %rdi
je 0xc27ac
movsd (%rax,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0xc27b0
incq %rsi
jmp 0xc2797
movl %ecx, %esi
jmp 0xc27b2
decl %esi
cmpl %esi, %edx
cmovgl %esi, %ecx
xorl %edx, %edx
testl %esi, %esi
cmovnsl %ecx, %edx
movl %edx, 0x24(%r14)
movslq %edx, %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x18(%r14)
movq 0x40(%r14), %rax
movq 0x70(%r14), %rdx
movq 0x88(%r14), %rsi
movsd (%rsi,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%rdx,%rcx,8), %xmm1
movq 0x58(%r14), %rdx
mulsd %xmm0, %xmm1
addsd (%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%rax,%rcx,8), %xmm1
movsd %xmm1, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
| /OpenMD[P]OpenMD/src/math/CubicSpline.cpp |
OpenMD::ImproperCosineInversionType::ImproperCosineInversionType(std::vector<OpenMD::ImproperCosineInversionParameter, std::allocator<OpenMD::ImproperCosineInversionParameter>>&) | ImproperCosineInversionType::ImproperCosineInversionType(
std::vector<ImproperCosineInversionParameter>& parameters) {
std::vector<ImproperCosineInversionParameter>::iterator i;
i = std::max_element(parameters.begin(), parameters.end(),
LessThanPeriodicityFunctor());
if (i != parameters.end()) {
int maxPower = i->n;
ChebyshevT T(maxPower);
ChebyshevU U(maxPower);
// convert parameters of impropercosine type inversion into
// PolynomialInversion's parameters
DoublePolynomial finalPolynomial;
for (i = parameters.begin(); i != parameters.end(); ++i) {
DoublePolynomial cosTerm = T.getChebyshevPolynomial(i->n);
cosTerm *= cos(i->delta) * i->kchi;
DoublePolynomial sinTerm = U.getChebyshevPolynomial(i->n);
sinTerm *= -sin(i->delta) * i->kchi;
finalPolynomial = cosTerm + sinTerm;
finalPolynomial += i->kchi;
}
this->setPolynomial(finalPolynomial);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
andl $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x5a950(%rip), %rax # 0x11dc40
movq %rax, (%rdi)
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0xc357b
cmpq 0x8(%r14), %rax
je 0xc3462
movl 0x8(%rax), %ebp
leaq 0x60(%rsp), %rdi
movl %ebp, %esi
movq %rbx, (%rsp)
callq 0xc3620
leaq 0x38(%rsp), %rdi
movl %ebp, %esi
callq 0xc3be8
leaq 0x10(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq (%r14), %rbx
leaq 0xe8(%rsp), %r15
leaq 0xb8(%rsp), %r12
leaq 0x118(%rsp), %r13
leaq 0x8(%rsp), %rbp
cmpq 0x8(%r14), %rbx
je 0xc3410
movslq 0x8(%rbx), %rax
imulq $0x30, %rax, %rsi
addq 0x68(%rsp), %rsi
movq %r15, %rdi
callq 0x76a96
movsd 0x10(%rbx), %xmm0
callq 0x139f0
mulsd (%rbx), %xmm0
movq %r15, %rdi
callq 0xc305e
movslq 0x8(%rbx), %rax
imulq $0x30, %rax, %rsi
addq 0x40(%rsp), %rsi
movq %r12, %rdi
callq 0x76a96
movsd 0x10(%rbx), %xmm0
callq 0x13100
xorpd 0x3782(%rip), %xmm0 # 0xc6b40
mulsd (%rbx), %xmm0
movq %r12, %rdi
callq 0xc305e
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xc34ed
movq %rbp, %rdi
movq %r13, %rsi
callq 0xc35a4
movq %r13, %rdi
callq 0x76cb0
movsd (%rbx), %xmm0
movq %rbp, %rdi
callq 0xc3544
movq %r12, %rdi
callq 0x76cb0
movq %r15, %rdi
callq 0x76cb0
addq $0x18, %rbx
jmp 0xc3362
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x76a96
movq (%rsp), %rax
leaq 0x8(%rax), %rdi
leaq 0x88(%rsp), %rsi
callq 0xa5d76
leaq 0x88(%rsp), %rdi
callq 0x76cb0
leaq 0x8(%rsp), %rdi
callq 0x76cb0
leaq 0x38(%rsp), %rdi
callq 0xc3100
leaq 0x60(%rsp), %rdi
callq 0xc3114
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x88(%rsp), %rdi
jmp 0xc34b9
jmp 0xc3497
movq %rax, %r14
jmp 0xc34d2
jmp 0xc348e
movq %rbx, (%rsp)
movq %rax, %r14
jmp 0xc34dc
jmp 0xc349c
jmp 0xc34a1
movq %rax, %r14
jmp 0xc34be
movq %rax, %r14
jmp 0xc34b1
movq %rax, %r14
leaq 0xb8(%rsp), %rdi
callq 0x76cb0
leaq 0xe8(%rsp), %rdi
callq 0x76cb0
leaq 0x8(%rsp), %rdi
callq 0x76cb0
leaq 0x38(%rsp), %rdi
callq 0xc3100
leaq 0x60(%rsp), %rdi
callq 0xc3114
movq (%rsp), %rdi
callq 0xad0f8
movq %r14, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/types/ImproperCosineInversionType.cpp |
OpenMD::ChebyshevT::GeneratePolynomials(int) | void ChebyshevT::GeneratePolynomials(int maxPower) {
GenerateFirstTwoTerms();
DoublePolynomial twoX;
twoX.setCoefficient(1, 2.0);
// recursive generate the high order term of Chebyshev Polynomials
// Cn+1(x) = Cn(x) * 2x - Cn-1(x)
for (int i = 2; i <= maxPower; ++i) {
DoublePolynomial cn;
cn = polyList_[i - 1] * twoX - polyList_[i - 2];
polyList_.push_back(cn);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0xc37b8
leaq 0x40(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x38(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x769ce
addq $0x8, %rbx
movslq %r14d, %rax
movq %rax, (%rsp)
pushq $0x2
popq %rbp
xorl %r15d, %r15d
leaq 0x68(%rsp), %r14
leaq 0x98(%rsp), %r12
leaq 0x8(%rsp), %r13
cmpq (%rsp), %rbp
jg 0xc3767
andl $0x0, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
movq (%rbx), %rax
leaq (%rax,%r15), %rsi
addq $0x30, %rsi
movq %r14, %rdi
leaq 0x38(%rsp), %rdx
callq 0xc38fb
movq (%rbx), %rdx
addq %r15, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xc3889
movq %r13, %rdi
movq %r12, %rsi
callq 0xc35a4
movq %r12, %rdi
callq 0x76cb0
movq %r14, %rdi
callq 0x76cb0
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc39b6
movq %r13, %rdi
callq 0x76cb0
incq %rbp
addq $0x30, %r15
jmp 0xc36da
leaq 0x38(%rsp), %rdi
callq 0x76cb0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xc37a6
jmp 0xc3799
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x76cb0
jmp 0xc379c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x76cb0
leaq 0x38(%rsp), %rdi
callq 0x76cb0
movq %rbx, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/math/ChebyshevT.cpp |
OpenMD::ChebyshevU::GeneratePolynomials(int) | void ChebyshevU::GeneratePolynomials(int maxPower) {
GenerateFirstTwoTerms();
DoublePolynomial twoX;
twoX.setCoefficient(1, 2.0);
// recursive generate the high order term of Chebyshev Polynomials
// Cn+1(x) = Cn(x) * 2x - Cn-1(x)
for (int i = 2; i <= maxPower; ++i) {
DoublePolynomial cn;
cn = polyList_[i - 1] * twoX - polyList_[i - 2];
polyList_.push_back(cn);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0xc3d80
leaq 0x40(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x38(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x769ce
addq $0x8, %rbx
movslq %r14d, %rax
movq %rax, (%rsp)
pushq $0x2
popq %rbp
xorl %r15d, %r15d
leaq 0x68(%rsp), %r14
leaq 0x98(%rsp), %r12
leaq 0x8(%rsp), %r13
cmpq (%rsp), %rbp
jg 0xc3d2f
andl $0x0, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
movq (%rbx), %rax
leaq (%rax,%r15), %rsi
addq $0x30, %rsi
movq %r14, %rdi
leaq 0x38(%rsp), %rdx
callq 0xc38fb
movq (%rbx), %rdx
addq %r15, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xc3889
movq %r13, %rdi
movq %r12, %rsi
callq 0xc35a4
movq %r12, %rdi
callq 0x76cb0
movq %r14, %rdi
callq 0x76cb0
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc39b6
movq %r13, %rdi
callq 0x76cb0
incq %rbp
addq $0x30, %r15
jmp 0xc3ca2
leaq 0x38(%rsp), %rdi
callq 0x76cb0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xc3d6e
jmp 0xc3d61
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x76cb0
jmp 0xc3d64
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x76cb0
leaq 0x38(%rsp), %rdi
callq 0x76cb0
movq %rbx, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/math/ChebyshevU.cpp |
testing::internal::XmlUnitTestResultPrinter::EscapeXml(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::string XmlUnitTestResultPrinter::EscapeXml(
const std::string& str, bool is_attribute) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '<':
m << "<";
break;
case '>':
m << ">";
break;
case '&':
m << "&";
break;
case '\'':
if (is_attribute)
m << "'";
else
m << '\'';
break;
case '"':
if (is_attribute)
m << """;
else
m << '"';
break;
default:
if (IsValidXmlCharacter(ch)) {
if (is_attribute && IsNormalizableWhitespace(ch))
m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
<< ";";
else
m << ch;
}
break;
}
}
return m.GetString();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, 0x28(%rsp)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x25e24
cmpq $0x0, 0x8(%r15)
movq (%rbx), %rbx
je 0x2e3a3
leaq 0x10(%rbx), %r12
xorl %r13d, %r13d
movq (%r15), %rax
movb (%rax,%r13), %al
movzbl %al, %r14d
cmpl $0x26, %r14d
jle 0x2e259
cmpl $0x27, %r14d
je 0x2e273
movl $0x4, %edx
cmpl $0x3e, %r14d
je 0x2e29d
cmpl $0x3c, %r14d
jne 0x2e2d5
leaq 0x2308d(%rip), %rsi # 0x512e4
jmp 0x2e2bb
cmpl $0x22, %r14d
je 0x2e2a6
cmpl $0x26, %r14d
jne 0x2e2d5
movl $0x5, %edx
leaq 0x2307d(%rip), %rsi # 0x512ee
jmp 0x2e2bb
movl $0x6, %edx
leaq 0x23075(%rip), %rsi # 0x512f4
testb %bpl, %bpl
jne 0x2e2bb
movb $0x27, 0x8(%rsp)
movl $0x1, %edx
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x20530
jmp 0x2e2c3
leaq 0x23045(%rip), %rsi # 0x512e9
jmp 0x2e2bb
movl $0x6, %edx
leaq 0x23049(%rip), %rsi # 0x512fb
testb %bpl, %bpl
je 0x2e387
movq %r12, %rdi
callq 0x20530
incq %r13
cmpq 0x8(%r15), %r13
jb 0x2e224
jmp 0x2e3a3
cmpb $0x1f, %al
jg 0x2e2ea
cmpl $0xd, %r14d
ja 0x2e2c3
movl $0x2600, %ecx # imm = 0x2600
btl %r14d, %ecx
jae 0x2e2c3
testb %bpl, %bpl
je 0x2e36c
cmpl $0xd, %r14d
ja 0x2e36c
movl $0x2600, %ecx # imm = 0x2600
btl %r14d, %ecx
jae 0x2e36c
movl $0x3, %edx
movq %r12, %rdi
leaq 0x22ff3(%rip), %rsi # 0x51302
callq 0x20530
leaq 0x8(%rsp), %rdi
movl %r14d, %esi
callq 0x28e58
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x20530
movl $0x1, %edx
movq %r12, %rdi
leaq 0x22400(%rip), %rsi # 0x50742
callq 0x20530
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2e2c3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x2e2c3
movb %al, 0x8(%rsp)
movl $0x1, %edx
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x20530
jmp 0x2e2c3
movb $0x22, 0x8(%rsp)
movl $0x1, %edx
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x20530
jmp 0x2e2c3
movq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2608d
testq %rbx, %rbx
je 0x2e3c1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e3fc
jmp 0x2e3fc
jmp 0x2e3fc
jmp 0x2e3fc
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2e3ff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x2e3ff
movq %rax, %r14
testq %rbx, %rbx
je 0x2e40d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x20880
nop
| /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
const std::string& str) {
std::string output;
output.reserve(str.size());
for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
if (IsValidXmlCharacter(*it))
output.push_back(*it);
return output;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x44e86
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2e488
movq (%r14), %rcx
movl $0x2600, %ebp # imm = 0x2600
movq %rcx, %r12
movb (%r12), %dl
cmpb $0x1f, %dl
jg 0x2e46a
cmpb $0xd, %dl
ja 0x2e47c
movzbl %dl, %esi
btl %esi, %ebp
jae 0x2e47c
movsbl %dl, %esi
movq %rbx, %rdi
callq 0x45c70
movq (%r14), %rcx
movq 0x8(%r14), %rax
incq %r12
leaq (%rcx,%rax), %rdx
cmpq %rdx, %r12
jne 0x2e454
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e496
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2e4ac
movq (%r15), %rsi
incq %rsi
callq 0x20460
movq %r14, %rdi
callq 0x20880
| /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest.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);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rsi, %r14
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
movq %rsi, %rax
imulq %rcx
movq %rdx, %r15
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %r15
addq %rax, %r15
leaq 0xe8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x250(%rsp), %rsi
callq 0x20210
testq %rax, %rax
je 0x2e5fb
movl $0x76c, %eax # imm = 0x76C
addl 0x264(%rsp), %eax
leaq 0x22c(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x230(%rsp), %r12
movq %r12, %rdi
callq 0x45cd2
leaq 0x233f1(%rip), %rsi # 0x519b4
movq %r12, %rdi
callq 0x4830e
leaq 0x118(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2e619
movq %rdx, 0x108(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x118(%rsp)
jmp 0x2e620
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x22bf2(%rip), %rdx # 0x511fb
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4b2a0
jmp 0x2ef77
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
movq %rdx, 0x110(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x260(%rsp), %esi
incl %esi
leaq 0x208(%rsp), %rdi
movl $0x2, %edx
callq 0x28d74
movq 0x108(%rsp), %rcx
movq 0x110(%rsp), %r8
movq 0x210(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %rbp, %rcx
je 0x2e684
movq 0x118(%rsp), %rdi
movq 0x208(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x2e6b0
leaq 0x218(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x2e6ab
movq 0x218(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x2e6bf
leaq 0x108(%rsp), %rdi
callq 0x48354
jmp 0x2e6d0
leaq 0x208(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4b336
leaq 0x58(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x2e6f4
movq %rsi, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x2e6fa
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x23296(%rip), %rsi # 0x519b4
leaq 0x48(%rsp), %rdi
callq 0x4830e
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2e750
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x2e758
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x25c(%rsp), %esi
leaq 0x1e8(%rsp), %rdi
movl $0x2, %edx
callq 0x28d74
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x1f0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r12, %rcx
je 0x2e7ae
movq 0x18(%rsp), %rdi
movq 0x1e8(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x2e7da
leaq 0x1f8(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x2e7d5
movq 0x1f8(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x2e7e6
leaq 0x8(%rsp), %rdi
callq 0x48354
jmp 0x2e7f7
leaq 0x1e8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4b336
leaq 0x78(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x2e81b
movq %rsi, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0x2e821
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x70(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x23862(%rip), %rsi # 0x520a7
leaq 0x68(%rsp), %rdi
callq 0x4830e
leaq 0x138(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2e880
movq %rdx, 0x128(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x138(%rsp)
jmp 0x2e888
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x130(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x258(%rsp), %esi
leaq 0x1c8(%rsp), %rdi
movl $0x2, %edx
callq 0x28d74
movq 0x128(%rsp), %rcx
movq 0x130(%rsp), %r8
movq 0x1d0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r12, %rcx
je 0x2e8ea
movq 0x138(%rsp), %rdi
movq 0x1c8(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x2e916
leaq 0x1d8(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x2e911
movq 0x1d8(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x2e925
leaq 0x128(%rsp), %rdi
callq 0x48354
jmp 0x2e936
leaq 0x1c8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4b336
leaq 0x98(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x2e963
movq %rsi, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
jmp 0x2e969
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x90(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x22d59(%rip), %rsi # 0x516e9
leaq 0x88(%rsp), %rdi
callq 0x4830e
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2e9c4
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x2e9cc
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x254(%rsp), %esi
leaq 0x1a8(%rsp), %rdi
movl $0x2, %edx
callq 0x28d74
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x1b0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r13, %rcx
je 0x2ea22
movq 0x38(%rsp), %rdi
movq 0x1a8(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x2ea4e
leaq 0x1b8(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x2ea49
movq 0x1b8(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x2ea5a
leaq 0x28(%rsp), %rdi
callq 0x48354
jmp 0x2ea6b
leaq 0x1a8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4b336
leaq 0xb8(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x2ea98
movq %rsi, 0xa8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xb8(%rsp)
jmp 0x2ea9e
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0xb0(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x22c24(%rip), %rsi # 0x516e9
leaq 0xa8(%rsp), %rdi
callq 0x4830e
leaq 0x158(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2eb02
movq %rdx, 0x148(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x158(%rsp)
jmp 0x2eb0a
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x150(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x250(%rsp), %esi
leaq 0x188(%rsp), %rdi
movl $0x2, %edx
callq 0x28d74
movq 0x148(%rsp), %rcx
movq 0x150(%rsp), %r8
movq 0x190(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r13, %rcx
je 0x2eb6c
movq 0x158(%rsp), %rdi
movq 0x188(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x2eb98
leaq 0x198(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x2eb93
movq 0x198(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x2eba7
leaq 0x148(%rsp), %rdi
callq 0x48354
jmp 0x2ebb8
leaq 0x188(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4b336
leaq 0xd8(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x2ebe5
movq %rsi, 0xc8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xd8(%rsp)
jmp 0x2ebeb
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0xd0(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x22986(%rip), %rsi # 0x51598
leaq 0xc8(%rsp), %rdi
callq 0x4830e
imulq $0x3e8, %r15, %rcx # imm = 0x3E8
subq %rcx, %r14
leaq 0xf8(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2ec59
movq %rdx, 0xe8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xf8(%rsp)
jmp 0x2ec60
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0xf0(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x168(%rsp), %rdi
movl %r14d, %esi
movl $0x3, %edx
callq 0x28d74
movq 0xe8(%rsp), %rcx
movq 0xf0(%rsp), %r8
movq 0x170(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r15, %rcx
je 0x2ecbe
movq 0xf8(%rsp), %rdi
movq 0x168(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x2ecea
leaq 0x178(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x2ece5
movq 0x178(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x2ecf9
leaq 0xe8(%rsp), %rdi
callq 0x48354
jmp 0x2ed0a
leaq 0x168(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4b336
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x2ed29
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x2ed2f
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x178(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ed6c
movq 0x178(%rsp), %rsi
incq %rsi
callq 0x20460
movq 0xe8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ed89
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2edaa
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x198(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2edcb
movq 0x198(%rsp), %rsi
incq %rsi
callq 0x20460
movq 0x148(%rsp), %rdi
cmpq %r13, %rdi
je 0x2ede8
movq 0x158(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
leaq 0x18(%rsp), %r14
leaq 0x38(%rsp), %r15
je 0x2ee13
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x1b8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ee34
movq 0x1b8(%rsp), %rsi
incq %rsi
callq 0x20460
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ee4b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ee6c
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x1d8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ee8d
movq 0x1d8(%rsp), %rsi
incq %rsi
callq 0x20460
movq 0x128(%rsp), %rdi
cmpq %r12, %rdi
je 0x2eeaa
movq 0x138(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2eec5
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x1f8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2eee6
movq 0x1f8(%rsp), %rsi
incq %rsi
callq 0x20460
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2eefd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ef18
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x218(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ef39
movq 0x218(%rsp), %rsi
incq %rsi
callq 0x20460
movq 0x108(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2ef56
movq 0x118(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x240(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ef77
movq 0x240(%rsp), %rsi
incq %rsi
callq 0x20460
movq %rbx, %rax
addq $0x288, %rsp # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x178(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2efb5
movq 0x178(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x2efb5
movq %rax, %rbx
movq 0xe8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2efd7
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x2efd7
movq %rax, %rbx
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2effd
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x2effd
movq %rax, %rbx
leaq 0x198(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f023
movq 0x198(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x2f023
movq %rax, %rbx
movq 0x148(%rsp), %rdi
cmpq %r13, %rdi
je 0x2f045
movq 0x158(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x2f045
movq %rax, %rbx
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f06b
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x2f06b
movq %rax, %rbx
leaq 0x1b8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f091
movq 0x1b8(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x2f091
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2f0b2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x2f0b2
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f0d3
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x1d8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f0f4
movq 0x1d8(%rsp), %rsi
incq %rsi
callq 0x20460
movq 0x128(%rsp), %rdi
cmpq %r12, %rdi
je 0x2f111
movq 0x138(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f12c
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x1f8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f14d
movq 0x1f8(%rsp), %rsi
incq %rsi
callq 0x20460
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2f169
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f184
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x218(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f1a5
movq 0x218(%rsp), %rsi
incq %rsi
callq 0x20460
movq 0x108(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2f1c2
movq 0x118(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x240(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f1e3
movq 0x240(%rsp), %rsi
incq %rsi
callq 0x20460
movq %rbx, %rdi
callq 0x20880
movq %rax, %rbx
jmp 0x2f0d3
movq %rax, %rbx
jmp 0x2f0f4
movq %rax, %rbx
jmp 0x2f111
movq %rax, %rbx
jmp 0x2f12c
movq %rax, %rbx
jmp 0x2f14d
movq %rax, %rbx
jmp 0x2f169
movq %rax, %rbx
jmp 0x2f184
movq %rax, %rbx
jmp 0x2f1a5
movq %rax, %rbx
jmp 0x2f1c2
| /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest.cc |
testing::UnitTest::GetTestCase(int) const | inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
: v[static_cast<size_t>(i)];
} | testl %esi, %esi
js 0x364cf
movq 0x40(%rdi), %rax
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x364cf
movl %esi, %edx
cmpl $0x0, (%rcx,%rdx,4)
js 0x364cf
movq 0xb8(%rax), %rax
movq (%rax,%rdx,8), %rax
retq
xorl %eax, %eax
retq
| /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::ParseInt32Flag(char const*, char const*, int*) | bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag, false);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;
// Sets *value to the value of the flag.
return ParseInt32(Message() << "The value of flag --" << flag,
value_str, value);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x3873d
testq %rax, %rax
je 0x38713
movq %rax, %r15
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x25e24
movq (%rbx), %rbx
leaq 0x10(%rbx), %r13
leaq 0x192e2(%rip), %rsi # 0x519a1
movl $0x14, %edx
movq %r13, %rdi
callq 0x20530
testq %r12, %r12
je 0x386de
movq %r12, %rdi
callq 0x201a0
movq %rax, %rdx
jmp 0x386ea
movl $0x6, %edx
leaq 0x18507(%rip), %r12 # 0x50bf1
movq %r13, %rdi
movq %r12, %rsi
callq 0x20530
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x382dc
movl %eax, %ebp
testq %rbx, %rbx
je 0x38713
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
testq %rbx, %rbx
je 0x38735
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x20880
| /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest.cc |
testing::TempDir[abi:cxx11]() | std::string TempDir() {
#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
#elif GTEST_OS_WINDOWS_MOBILE
return "\\temp\\";
#elif GTEST_OS_WINDOWS
const char* temp_dir = internal::posix::GetEnv("TEMP");
if (temp_dir == nullptr || temp_dir[0] == '\0') {
return "\\temp\\";
} else if (temp_dir[strlen(temp_dir) - 1] == '\\') {
return temp_dir;
} else {
return std::string(temp_dir) + "\\";
}
#elif GTEST_OS_LINUX_ANDROID
const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
if (temp_dir == nullptr || temp_dir[0] == '\0') {
return "/data/local/tmp/";
} else {
return temp_dir;
}
#elif GTEST_OS_LINUX
const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
if (temp_dir == nullptr || temp_dir[0] == '\0') {
return "/tmp/";
} else {
return temp_dir;
}
#else
return "/tmp/";
#endif // GTEST_OS_WINDOWS_MOBILE
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1906b(%rip), %rdi # 0x519bc
callq 0x205d0
testq %rax, %rax
je 0x38980
movq %rax, %r14
cmpb $0x0, (%rax)
je 0x38980
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x201a0
movq %r14, %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x38998
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1903a(%rip), %rsi # 0x519c8
leaq 0x19038(%rip), %rdx # 0x519cd
movq %rbx, %rdi
callq 0x4b2a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest.cc |
testing::internal::DeathTestImpl::ReadAndInterpretStatusByte() | void DeathTestImpl::ReadAndInterpretStatusByte() {
char flag;
int bytes_read;
// The read() here blocks until data is available (signifying the
// failure of the death test) or until the pipe is closed (signifying
// its success), so it's okay to call this in the parent before
// the child process has exited.
do {
bytes_read = posix::Read(read_fd(), &flag, 1);
} while (bytes_read == -1 && errno == EINTR);
if (bytes_read == 0) {
set_outcome(DIED);
} else if (bytes_read == 1) {
switch (flag) {
case kDeathTestReturned:
set_outcome(RETURNED);
break;
case kDeathTestThrew:
set_outcome(THREW);
break;
case kDeathTestLived:
set_outcome(LIVED);
break;
case kDeathTestInternalError:
FailFromInternalError(read_fd()); // Does not return.
break;
default:
GTEST_LOG_(FATAL) << "Death test child process reported "
<< "unexpected status byte ("
<< static_cast<unsigned int>(flag) << ")";
}
} else {
GTEST_LOG_(FATAL) << "Read from death test child process failed: "
<< GetLastErrnoDescription();
}
GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd()));
set_read_fd(-1);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, %rbx
leaq 0x7(%rsp), %r14
movl 0x34(%rbx), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0x20710
cmpl $-0x1, %eax
jne 0x38cd8
callq 0x20060
cmpl $0x4, (%rax)
je 0x38cb7
jmp 0x38d15
testl %eax, %eax
je 0x38d9e
cmpl $0x1, %eax
jne 0x38d15
movzbl 0x7(%rsp), %r14d
cmpl $0x51, %r14d
jg 0x38e3b
cmpl $0x49, %r14d
je 0x38edd
cmpl $0x4c, %r14d
jne 0x38e57
movl $0x2, 0x30(%rbx)
jmp 0x38da5
leaq 0x18cfb(%rip), %rdx # 0x51a17
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x1f0, %ecx # imm = 0x1F0
callq 0x407bc
movq 0x2c2b9(%rip), %rdi # 0x64ff0
leaq 0x18d9e(%rip), %rsi # 0x51adc
movl $0x2b, %edx
callq 0x20530
leaq 0xf0(%rsp), %rdi
callq 0x38abd
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq 0x2c284(%rip), %rdi # 0x64ff0
callq 0x20530
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38d92
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x8(%rsp), %rdi
callq 0x408fe
jmp 0x38da5
movl $0x1, 0x30(%rbx)
movl 0x34(%rbx), %edi
callq 0x20950
cmpl $-0x1, %eax
jne 0x38e22
callq 0x20060
cmpl $0x4, (%rax)
je 0x38da5
leaq 0xe0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x18d39(%rip), %rsi # 0x51b08
leaq 0x18d45(%rip), %rdx # 0x51b1b
leaq 0xd0(%rsp), %rdi
callq 0x4b2a0
leaq 0x18c2d(%rip), %rsi # 0x51a17
leaq 0xd0(%rsp), %rdi
callq 0x4830e
leaq 0xc0(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x3906a
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x3907d
movl $0xffffffff, 0x34(%rbx) # imm = 0xFFFFFFFF
addq $0x1f8, %rsp # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x54, %r14d
je 0x38f4c
cmpl $0x52, %r14d
jne 0x38e57
movl $0x3, 0x30(%rbx)
jmp 0x38da5
leaq 0x18bb9(%rip), %rdx # 0x51a17
leaq 0xf0(%rsp), %rdi
movl $0x3, %esi
movl $0x1eb, %ecx # imm = 0x1EB
callq 0x407bc
movq 0x2c174(%rip), %rdi # 0x64ff0
leaq 0x18c1d(%rip), %rsi # 0x51aa0
movl $0x22, %edx
callq 0x20530
movq 0x2c15c(%rip), %rdi # 0x64ff0
leaq 0x18c28(%rip), %rsi # 0x51ac3
movl $0x18, %edx
callq 0x20530
movsbq %r14b, %rax
movl %eax, %esi
movq 0x2c13e(%rip), %rdi # 0x64ff0
callq 0x202b0
leaq 0x1815c(%rip), %rsi # 0x5101a
movl $0x1, %edx
movq %rax, %rdi
callq 0x20530
leaq 0xf0(%rsp), %rdi
callq 0x408fe
jmp 0x38da5
movl 0x34(%rbx), %r15d
leaq 0x90(%rsp), %r14
movq %r14, %rdi
callq 0x25e24
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0xf0(%rsp), %r13
movl $0xff, %edx
movl %r15d, %edi
movq %r13, %rsi
callq 0x20710
testl %eax, %eax
jle 0x38f39
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movb $0x0, 0xf0(%rsp,%rax)
movq %r13, %rdi
callq 0x201a0
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x20530
jmp 0x38f00
cmpl $-0x1, %eax
jne 0x38f58
callq 0x20060
movl (%rax), %ebp
cmpl $0x4, %ebp
je 0x38f00
jmp 0x38fa6
movl $0x4, 0x30(%rbx)
jmp 0x38da5
testl %eax, %eax
jne 0x38f9f
leaq 0x18ab4(%rip), %rdx # 0x51a17
leaq 0x28(%rsp), %rdi
movl $0x3, %esi
movl $0x168, %ecx # imm = 0x168
callq 0x407bc
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2608d
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x2c05b(%rip), %rdi # 0x64ff0
callq 0x20530
jmp 0x3902e
callq 0x20060
movl (%rax), %ebp
leaq 0x18a6a(%rip), %rdx # 0x51a17
leaq 0x28(%rsp), %rdi
movl $0x3, %esi
movl $0x16b, %ecx # imm = 0x16B
callq 0x407bc
movq 0x2c028(%rip), %rdi # 0x64ff0
leaq 0x19773(%rip), %rsi # 0x52742
movl $0x29, %edx
callq 0x20530
leaq 0x8(%rsp), %rdi
callq 0x38abd
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x2bffc(%rip), %rdi # 0x64ff0
callq 0x20530
movq %rax, %r15
leaq 0x19dd4(%rip), %rsi # 0x52dd7
movl $0x2, %edx
movq %rax, %rdi
callq 0x20530
movq %r15, %rdi
movl %ebp, %esi
callq 0x20860
leaq 0x18ecb(%rip), %rsi # 0x51eec
movl $0x1, %edx
movq %rax, %rdi
callq 0x20530
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39049
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x28(%rsp), %rdi
callq 0x408fe
testq %r14, %r14
je 0x38da5
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x38da5
movq %rdx, 0xb0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xc0(%rsp)
movq 0x8(%rax), %rdx
leaq 0xb0(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18a79(%rip), %rsi # 0x51b1c
callq 0x4830e
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x390cb
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x390d8
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x6c(%rsp), %rsi
movl $0x1f3, (%rsi) # imm = 0x1F3
leaq 0x70(%rsp), %rdi
callq 0x45cd2
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %r8
movq 0x78(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r12, %rcx
je 0x39127
movq 0x58(%rsp), %rdi
leaq 0x80(%rsp), %r13
movq -0x10(%r13), %rsi
cmpq %rdi, %rax
jbe 0x3914f
movl $0xf, %edi
cmpq %r13, %rsi
je 0x3914a
movq 0x80(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x3915b
leaq 0x48(%rsp), %rdi
callq 0x48354
jmp 0x39169
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4b336
leaq 0x38(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x39186
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x39193
movq %rsi, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x183e4(%rip), %rsi # 0x5159b
leaq 0x28(%rsp), %rdi
callq 0x4830e
leaq 0xa0(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x391e5
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
jmp 0x391f8
movq %rdx, 0x90(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xa0(%rsp)
movq 0x8(%rax), %rdx
leaq 0x90(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18906(%rip), %rsi # 0x51b24
callq 0x4830e
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x39248
movups (%rcx), %xmm0
leaq 0x18(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x39255
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18ac1(%rip), %rsi # 0x51d39
callq 0x4830e
leaq 0x100(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x392a8
movups (%rcx), %xmm0
leaq 0x100(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x392bb
movq %rdx, 0xf0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x100(%rsp)
movq 0x8(%rax), %rdx
leaq 0xf0(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x38b75
jmp 0x3933f
jmp 0x392ea
jmp 0x39430
jmp 0x392ea
movq %rax, %rbx
jmp 0x3935d
jmp 0x39430
movq %rax, %rbx
movq 0xf0(%rsp), %rdi
leaq 0x100(%rsp), %rax
cmpq %rax, %rdi
je 0x39321
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x39321
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3937c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x3937c
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3935d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20460
leaq 0x28(%rsp), %rdi
callq 0x408fe
jmp 0x39433
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
jmp 0x393eb
movq %rax, %rbx
movq 0x90(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3939e
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x3939e
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x393f8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x393f8
movq %rax, %rbx
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x393e6
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x393e6
jmp 0x393e3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x408fe
jmp 0x3948a
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0x39417
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x39417
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x39446
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x39446
movq %rax, %rbx
testq %r14, %r14
je 0x3948a
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x3948a
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
cmpq %r15, %rdi
je 0x39468
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x39468
movq %rax, %rbx
movq 0xd0(%rsp), %rdi
cmpq %r14, %rdi
je 0x3948a
movq 0xe0(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x3948a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x20880
| /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest-death-test.cc |
testing::internal::StreamingListener::Start() | void Start() { SendLn("gtest_streaming_protocol_version=1.0"); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9380(%rip), %rsi # 0x525a6
leaq 0x939d(%rip), %rdx # 0x525ca
movq %rsp, %r14
movq %r14, %rdi
callq 0x4b2a0
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x4aa24
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4925a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20460
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4927d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20460
movq %rbx, %rdi
callq 0x20880
nop
| /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestStart(testing::TestInfo const&) | void OnTestStart(const TestInfo& test_info) override {
SendLn(std::string("event=TestStart&name=") + test_info.name());
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x9098(%rip), %rsi # 0x52620
leaq 0x90a6(%rip), %rdx # 0x52635
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x4b2a0
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x4830e
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x495cf
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x495d6
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rbx), %rdi
callq 0x4aa24
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x49612
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20460
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x49629
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x20460
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x49654
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20460
jmp 0x49654
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x4966b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x20460
movq %rbx, %rdi
callq 0x20880
nop
| /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest-internal-inl.h |
socket | int socket(int domain, int type, int protocol)
{
HOOK_SYS_FUNC( socket );
if( !co_is_enable_sys_hook() )
{
return g_sys_socket_func( domain,type,protocol );
}
int fd = g_sys_socket_func(domain,type,protocol);
if( fd < 0 )
{
return fd;
}
rpchook_t *lp = alloc_by_fd( fd );
lp->domain = domain;
fcntl( fd, F_SETFL, g_sys_fcntl_func(fd, F_GETFL,0 ) );
return fd;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
cmpq $0x0, 0x6a0e(%rip) # 0xb330
jne 0x493a
leaq 0x36fd(%rip), %rsi # 0x8028
pushq $-0x1
popq %rdi
callq 0x42c0
movq %rax, 0x69f6(%rip) # 0xb330
callq 0x4490
movq 0x69ea(%rip), %rcx # 0xb330
testb %al, %al
je 0x4982
movl %ebp, %edi
movl %r14d, %esi
movl %ebx, %edx
callq *%rcx
movl %eax, %ebx
testl %eax, %eax
js 0x498d
movl %ebx, %edi
callq 0x499c
movl %ebp, 0x14(%rax)
pushq $0x3
popq %rsi
movl %ebx, %edi
xorl %edx, %edx
xorl %eax, %eax
callq *0x6a16(%rip) # 0xb388
pushq $0x4
popq %rsi
movl %ebx, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x4180
jmp 0x498d
movl %ebp, %edi
movl %r14d, %esi
movl %ebx, %edx
callq *%rcx
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x5ed4
| /abhinavabcd[P]libco/co_hook_sys_call.cpp |
co_accept(int, sockaddr*, unsigned int*) | int co_accept( int fd, struct sockaddr *addr, socklen_t *len )
{
HOOK_SYS_FUNC( fcntl );
int cli = accept( fd,addr,len );
if( cli < 0 )
{
return cli;
}
rpchook_t *lp = alloc_by_fd( cli );
int current_flags = g_sys_fcntl_func( cli ,F_GETFL, 0 );
int flag = current_flags;
flag |= O_NONBLOCK;
int ret = g_sys_fcntl_func( cli ,F_SETFL, flag );
if( 0 == ret && lp ){
lp->user_flag = current_flags;
}
return cli;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
cmpq $0x0, 0x66af(%rip) # 0xb388
jne 0x4cf1
leaq 0x338b(%rip), %rsi # 0x806d
pushq $-0x1
popq %rdi
callq 0x42c0
movq %rax, 0x6697(%rip) # 0xb388
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x40c0
movl %eax, %ebx
testl %eax, %eax
js 0x4d40
movl %ebx, %edi
callq 0x499c
movq %rax, %r14
pushq $0x3
popq %rsi
movl %ebx, %edi
xorl %edx, %edx
xorl %eax, %eax
callq *0x666b(%rip) # 0xb388
movl %eax, %ebp
movl %eax, %edx
orl $0x800, %edx # imm = 0x800
pushq $0x4
popq %rsi
movl %ebx, %edi
xorl %eax, %eax
callq *0x6654(%rip) # 0xb388
testq %r14, %r14
je 0x4d40
testl %eax, %eax
jne 0x4d40
movl %ebp, (%r14)
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /abhinavabcd[P]libco/co_hook_sys_call.cpp |
close | int close(int fd)
{
HOOK_SYS_FUNC( close );
if( !co_is_enable_sys_hook() )
{
return g_sys_close_func( fd );
}
free_by_fd( fd );
int ret = g_sys_close_func(fd);
return ret;
} | pushq %rbx
movl %edi, %ebx
cmpq $0x0, 0x62b0(%rip) # 0xb340
jne 0x50a8
leaq 0x2f9e(%rip), %rsi # 0x8037
pushq $-0x1
popq %rdi
callq 0x42c0
movq %rax, 0x6298(%rip) # 0xb340
callq 0x4490
xorb $0x1, %al
cmpl $0xf4240, %ebx # imm = 0xF4240
setae %cl
orb %al, %cl
jne 0x50d8
movl %ebx, %eax
leaq 0x631b(%rip), %rcx # 0xb3e0
movq (%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0x50d8
andq $0x0, (%rcx,%rax,8)
callq 0x4390
movl %ebx, %edi
popq %rbx
jmpq *0x625f(%rip) # 0xb340
| /abhinavabcd[P]libco/co_hook_sys_call.cpp |
gethostbyname | struct hostent *gethostbyname(const char *name)
{
HOOK_SYS_FUNC( gethostbyname );
#if defined( __APPLE__ ) || defined( __FreeBSD__ )
return g_sys_gethostbyname_func( name );
#else
if (!co_is_enable_sys_hook())
{
return g_sys_gethostbyname_func(name);
}
return co_gethostbyname(name);
#endif
} | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x56f6(%rip) # 0xb3b0
jne 0x5cd2
leaq 0x23cc(%rip), %rsi # 0x808f
pushq $-0x1
popq %rdi
callq 0x42c0
movq %rax, 0x56de(%rip) # 0xb3b0
callq 0x4490
movq %rbx, %rdi
testb %al, %al
je 0x5ce4
popq %rbx
jmp 0x44c0
popq %rbx
jmpq *0x56c5(%rip) # 0xb3b0
| /abhinavabcd[P]libco/co_hook_sys_call.cpp |
co_gethostbyname(char const*) | struct hostent *co_gethostbyname(const char *name)
{
if (!name)
{
return NULL;
}
if (__co_hostbuf_wrap->buffer && __co_hostbuf_wrap->iBufferSize > 1024)
{
free(__co_hostbuf_wrap->buffer);
__co_hostbuf_wrap->buffer = NULL;
}
if (!__co_hostbuf_wrap->buffer)
{
__co_hostbuf_wrap->buffer = (char*)malloc(1024);
__co_hostbuf_wrap->iBufferSize = 1024;
}
struct hostent *host = &__co_hostbuf_wrap->host;
struct hostent *result = NULL;
int *h_errnop = &(__co_hostbuf_wrap->host_errno);
int ret = -1;
while (ret = gethostbyname_r(name, host, __co_hostbuf_wrap->buffer,
__co_hostbuf_wrap->iBufferSize, &result, h_errnop) == ERANGE &&
*h_errnop == NETDB_INTERNAL )
{
free(__co_hostbuf_wrap->buffer);
__co_hostbuf_wrap->iBufferSize = __co_hostbuf_wrap->iBufferSize * 2;
__co_hostbuf_wrap->buffer = (char*)malloc(__co_hostbuf_wrap->iBufferSize);
}
if (ret == 0 && (host == result))
{
return host;
}
return NULL;
} | testq %rdi, %rdi
je 0x5e5e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x56c8(%rip), %rdi # 0xb3d1
callq 0x40a0
cmpq $0x0, 0x20(%rax)
je 0x5d50
leaq 0x56b5(%rip), %rdi # 0xb3d1
callq 0x40a0
cmpq $0x401, 0x28(%rax) # imm = 0x401
jb 0x5d50
leaq 0x569f(%rip), %r14 # 0xb3d1
movq %r14, %rdi
callq 0x40a0
movq 0x20(%rax), %rdi
callq 0x4390
movq %r14, %rdi
callq 0x40a0
andq $0x0, 0x20(%rax)
leaq 0x567a(%rip), %rdi # 0xb3d1
callq 0x40a0
cmpq $0x0, 0x20(%rax)
jne 0x5d93
movl $0x400, %edi # imm = 0x400
callq 0x43c0
movq %rax, %r14
leaq 0x565a(%rip), %r15 # 0xb3d1
movq %r15, %rdi
callq 0x40a0
movq %r14, 0x20(%rax)
movq %r15, %rdi
callq 0x40a0
movq $0x400, 0x28(%rax) # imm = 0x400
leaq 0x5637(%rip), %r15 # 0xb3d1
movq %r15, %rdi
callq 0x40a0
movq %rax, %r14
movq %rsp, %r12
andq $0x0, (%r12)
movq %r15, %rdi
callq 0x40a0
movq %rax, %r13
addq $0x30, %r13
movq %r15, %rdi
callq 0x40a0
movq 0x20(%rax), %rbp
movq %r15, %rdi
callq 0x40a0
movq 0x28(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %r12, %r8
movq %r13, %r9
callq 0x44f0
cmpl $0x22, %eax
jne 0x5e45
cmpl $-0x1, (%r13)
jne 0x5e45
movq %r15, %rdi
callq 0x40a0
movq 0x20(%rax), %rdi
callq 0x4390
movq %r15, %rdi
callq 0x40a0
movq 0x28(%rax), %rbp
addq %rbp, %rbp
movq %r15, %rdi
callq 0x40a0
movq %rbp, 0x28(%rax)
movq %r15, %rdi
callq 0x40a0
movq 0x28(%rax), %rdi
callq 0x43c0
movq %rax, %rbp
movq %r15, %rdi
callq 0x40a0
movq %rbp, 0x20(%rax)
jmp 0x5dbc
xorl %eax, %eax
cmpq (%rsp), %r14
cmoveq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
| /abhinavabcd[P]libco/co_hook_sys_call.cpp |
clsRoutineData_routine_hostbuf_wrap<hostbuf_wrap>::operator->() | struct hostent *co_gethostbyname(const char *name)
{
if (!name)
{
return NULL;
}
if (__co_hostbuf_wrap->buffer && __co_hostbuf_wrap->iBufferSize > 1024)
{
free(__co_hostbuf_wrap->buffer);
__co_hostbuf_wrap->buffer = NULL;
}
if (!__co_hostbuf_wrap->buffer)
{
__co_hostbuf_wrap->buffer = (char*)malloc(1024);
__co_hostbuf_wrap->iBufferSize = 1024;
}
struct hostent *host = &__co_hostbuf_wrap->host;
struct hostent *result = NULL;
int *h_errnop = &(__co_hostbuf_wrap->host_errno);
int ret = -1;
while (ret = gethostbyname_r(name, host, __co_hostbuf_wrap->buffer,
__co_hostbuf_wrap->iBufferSize, &result, h_errnop) == ERANGE &&
*h_errnop == NETDB_INTERNAL )
{
free(__co_hostbuf_wrap->buffer);
__co_hostbuf_wrap->iBufferSize = __co_hostbuf_wrap->iBufferSize * 2;
__co_hostbuf_wrap->buffer = (char*)malloc(__co_hostbuf_wrap->iBufferSize);
}
if (ret == 0 && (host == result))
{
return host;
}
return NULL;
} | pushq %rbx
cmpb $0x0, 0x7a6648(%rip) # 0x7ac5ec
jne 0x5fc0
leaq 0x7a6643(%rip), %rdi # 0x7ac5f0
leaq -0xee(%rip), %rsi # 0x5ec6
callq 0x42b0
movb $0x1, 0x7a662c(%rip) # 0x7ac5ec
movl 0x7a662e(%rip), %edi # 0x7ac5f4
callq 0x43d0
movq %rax, %rbx
testq %rax, %rax
jne 0x6002
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0x41f0
movq %rax, %rbx
movl 0x7a660d(%rip), %edi # 0x7ac5f4
movq %rax, %rsi
callq 0x45b0
testq %rbx, %rbx
je 0x6002
testl %eax, %eax
je 0x6002
movq %rbx, %rdi
callq 0x4390
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
nop
| /abhinavabcd[P]libco/co_hook_sys_call.cpp |
AllocTimeout(int) | stTimeout_t *AllocTimeout( int iSize )
{
stTimeout_t *lp = (stTimeout_t*)calloc( 1,sizeof(stTimeout_t) );
lp->iItemSize = iSize;
lp->pItems = (stTimeoutItemLink_t*)calloc( 1,sizeof(stTimeoutItemLink_t) * lp->iItemSize );
lp->ullStart = GetTickMS();
lp->llStartIdx = 0;
return lp;
} | pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
pushq $0x1
popq %r14
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x41f0
movq %rax, %r15
movl %ebx, 0x8(%rax)
movslq %ebx, %rsi
shlq $0x4, %rsi
movq %r14, %rdi
callq 0x41f0
movq %rax, (%r15)
callq 0x63e6
movq %rax, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
| /abhinavabcd[P]libco/co_routine.cpp |
co_create_env(stCoRoutineEnv_t*, stCoRoutineAttr_t const*, void* (*)(void*), void*) | struct stCoRoutine_t *co_create_env( stCoRoutineEnv_t * env, const stCoRoutineAttr_t* attr,
pfn_co_routine_t pfn,void *arg )
{
stCoRoutineAttr_t at;
if( attr )
{
memcpy( &at,attr,sizeof(at) );
}
if( at.stack_size <= 0 )
{
at.stack_size = 128 * 1024;
}
else if( at.stack_size > 1024 * 1024 * 8 )
{
at.stack_size = 1024 * 1024 * 8;
}
if( at.stack_size & 0xFFF )
{
at.stack_size &= ~0xFFF;
at.stack_size += 0x1000;
}
stCoRoutine_t *lp = (stCoRoutine_t*)malloc( sizeof(stCoRoutine_t) );
memset( lp,0,(long)(sizeof(stCoRoutine_t)));
lp->env = env;
lp->pfn = pfn;
lp->arg = arg;
stStackMem_t* stack_mem = NULL;
if( at.share_stack )
{
stack_mem = co_get_stackmem( at.share_stack);
at.stack_size = at.share_stack->stack_size;
}
else
{
stack_mem = co_alloc_stackmem(at.stack_size);
}
lp->stack_mem = stack_mem;
lp->ctx.ss_sp = stack_mem->stack_buffer;
lp->ctx.ss_size = at.stack_size;
lp->cStart = 0;
lp->cEnd = 0;
lp->cIsMain = 0;
lp->cEnableSysHook = 0;
lp->cIsShareStack = at.share_stack != NULL;
lp->save_size = 0;
lp->save_buffer = NULL;
return lp;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movl $0x20000, %ebx # imm = 0x20000
testq %rsi, %rsi
je 0x64d9
movl (%rsi), %eax
movq 0x4(%rsi), %rbp
testl %eax, %eax
jle 0x64db
movl $0x800000, %ebx # imm = 0x800000
cmpl $0x800000, %eax # imm = 0x800000
ja 0x64db
testw $0xfff, %ax # imm = 0xFFF
je 0x64d5
andl $0xfff000, %eax # imm = 0xFFF000
addl $0x1000, %eax # imm = 0x1000
movl %eax, %ebx
jmp 0x64db
xorl %ebp, %ebp
pushq $0x1
popq %rdi
movl $0x20c8, %esi # imm = 0x20C8
callq 0x41f0
movq %rax, %r13
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
testq %rbp, %rbp
je 0x6519
movl (%rbp), %eax
movl 0x4(%rbp), %ebx
leal 0x1(%rax), %ecx
movl %ecx, (%rbp)
movq 0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x8(%rbp)
movslq %edx, %rax
movq (%rcx,%rax,8), %rax
jmp 0x6520
movl %ebx, %edi
callq 0x41c0
movq %rax, 0xa8(%r13)
movq 0x18(%rax), %rax
movq %rax, 0x90(%r13)
movslq %ebx, %rax
movq %rax, 0x88(%r13)
andl $0x0, 0x98(%r13)
testq %rbp, %rbp
setne 0x9c(%r13)
andl $0x0, 0xb8(%r13)
andq $0x0, 0xc0(%r13)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /abhinavabcd[P]libco/co_routine.cpp |
co_free(stCoRoutine_t*) | void co_free( stCoRoutine_t *co )
{
if (!co->cIsShareStack)
{
free(co->stack_mem->stack_buffer);
free(co->stack_mem);
}
//walkerdu fix at 2018-01-20
//存在内存泄漏
else
{
if(co->save_buffer)
free(co->save_buffer);
if(co->stack_mem->occupy_co == co)
co->stack_mem->occupy_co = NULL;
}
free( co );
} | pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x9c(%rdi)
je 0x6686
movq 0xc0(%rbx), %rdi
callq 0x4390
movq 0xa8(%rbx), %rax
cmpq %rbx, (%rax)
jne 0x66a2
andq $0x0, (%rax)
jmp 0x66a2
movq 0xa8(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x4390
movq 0xa8(%rbx), %rdi
callq 0x4390
movq %rbx, %rdi
popq %rbx
jmp 0x4390
| /abhinavabcd[P]libco/co_routine.cpp |
co_cond_timedwait(stCoCond_t*, int) | int co_cond_timedwait( stCoCond_t *link,int ms )
{
stCoCondItem_t* psi = (stCoCondItem_t*)calloc(1, sizeof(stCoCondItem_t));
psi->timeout.pArg = GetCurrThreadCo();
psi->timeout.pfnProcess = OnSignalProcessEvent;
if( ms > 0 )
{
unsigned long long now = GetTickMS();
psi->timeout.ullExpireTime = now + ms;
int ret = AddTimeout( co_get_curr_thread_env()->pEpoll->pTimeout,&psi->timeout,now );
if( ret != 0 )
{
free(psi);
return ret;
}
}
AddTail( link, psi);
co_yield_ct();
RemoveFromLink<stCoCondItem_t,stCoCond_t>( psi );
free(psi);
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x58
popq %rsi
callq 0x41f0
movq %rax, %rbx
callq 0x44e0
movq %rax, 0x48(%rbx)
leaq 0x7c(%rip), %rax # 0x707f
movq %rax, 0x40(%rbx)
testl %ebp, %ebp
jle 0x7052
movq %rbx, %r15
addq $0x18, %r15
callq 0x63e6
movq %rax, %r12
movl %ebp, %eax
addq %r12, %rax
movq %rax, 0x30(%rbx)
leaq 0x3f7e(%rip), %rdi # 0xafa8
callq 0x4520
movq (%rax), %rax
movq 0x408(%rax), %rax
movq 0x8(%rax), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4170
movl %eax, %ebp
testl %eax, %eax
jne 0x706c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4280
callq 0x4050
movq %rbx, %rdi
callq 0x4220
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x4390
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /abhinavabcd[P]libco/co_routine.cpp |
void nlohmann::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double) | JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{
static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
"internal error: not enough precision");
JSON_ASSERT(std::isfinite(value));
JSON_ASSERT(value > 0);
// If the neighbors (and boundaries) of 'value' are always computed for double-precision
// numbers, all float's can be recovered using strtod (and strtof). However, the resulting
// decimal representations are not exactly "short".
//
// The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
// says "value is converted to a string as if by std::sprintf in the default ("C") locale"
// and since sprintf promotes float's to double's, I think this is exactly what 'std::to_chars'
// does.
// On the other hand, the documentation for 'std::to_chars' requires that "parsing the
// representation using the corresponding std::from_chars function recovers value exactly". That
// indicates that single precision floating-point numbers should be recovered using
// 'std::strtof'.
//
// NB: If the neighbors are computed for single-precision numbers, there is a single float
// (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
// value is off by 1 ulp.
#if 0
const boundaries w = compute_boundaries(static_cast<double>(value));
#else
const boundaries w = compute_boundaries(value);
#endif
grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0x1c595
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1c5b4
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x1c770
movq 0x10(%r12), %rcx
movl 0x18(%r12), %r8d
movups (%r12), %xmm0
movups 0x20(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1c8b9
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xa319(%rip), %rdi # 0x268b5
leaq 0x90af(%rip), %rsi # 0x25652
leaq 0xa47b(%rip), %rcx # 0x26a25
movl $0x3b7b, %edx # imm = 0x3B7B
callq 0x180c0
leaq 0xa4c9(%rip), %rdi # 0x26a84
leaq 0x9090(%rip), %rsi # 0x25652
leaq 0xa45c(%rip), %rcx # 0x26a25
movl $0x3b7c, %edx # imm = 0x3B7C
callq 0x180c0
| /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::dtoa_impl::format_buffer(char*, int, int, int, int) | inline char* format_buffer(char* buf, int len, int decimal_exponent,
int min_exp, int max_exp)
{
JSON_ASSERT(min_exp < 0);
JSON_ASSERT(max_exp > 0);
const int k = len;
const int n = len + decimal_exponent;
// v = buf * 10^(n-k)
// k is the length of the buffer (number of decimal digits)
// n is the position of the decimal point relative to the start of the buffer.
if (k <= n && n <= max_exp)
{
// digits[000]
// len <= max_exp + 2
std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
// Make it look like a floating-point number (#362, #378)
buf[n + 0] = '.';
buf[n + 1] = '0';
return buf + (static_cast<size_t>(n) + 2);
}
if (0 < n && n <= max_exp)
{
// dig.its
// len <= max_digits10 + 1
JSON_ASSERT(k > n);
std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
buf[n] = '.';
return buf + (static_cast<size_t>(k) + 1U);
}
if (min_exp < n && n <= 0)
{
// 0.[000]digits
// len <= 2 + (-min_exp - 1) + max_digits10
std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
buf[0] = '0';
buf[1] = '.';
std::memset(buf + 2, '0', static_cast<size_t>(-n));
return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
}
if (k == 1)
{
// dE+123
// len <= 1 + 5
buf += 1;
}
else
{
// d.igitsE+123
// len <= max_digits10 + 1 + 5
std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
buf[1] = '.';
buf += 1 + static_cast<size_t>(k);
}
*buf++ = 'e';
return append_exponent(buf, n - 1);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %ecx, %ecx
jns 0x1c713
testl %r8d, %r8d
jle 0x1c732
movq %rdi, %rbx
leal (%rdx,%rsi), %r14d
testl %edx, %edx
sets %al
cmpl %r8d, %r14d
setg %dil
orb %al, %dil
je 0x1c662
cmpl %r8d, %r14d
setg %al
testl %r14d, %r14d
setle %dil
orb %al, %dil
je 0x1c68b
testl %r14d, %r14d
setg %al
cmpl %ecx, %r14d
setle %cl
orb %al, %cl
jne 0x1c6cf
negl %r14d
leaq (%rbx,%r14), %r15
addq $0x2, %r15
movslq %esi, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x180b0
movw $0x2e30, (%rbx) # imm = 0x2E30
addq $0x2, %rbx
pushq $0x30
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x18140
addq %r12, %r15
jmp 0x1c6c0
movslq %esi, %rax
leaq (%rbx,%rax), %rdi
movslq %r14d, %r14
movq %r14, %rdx
subq %rax, %rdx
pushq $0x30
popq %rsi
callq 0x18140
leaq (%rbx,%r14), %r15
addq $0x2, %r15
movw $0x302e, -0x2(%r15) # imm = 0x302E
jmp 0x1c6c0
testl %edx, %edx
jns 0x1c751
movl %r14d, %ecx
leaq (%rbx,%rcx), %rax
leaq (%rbx,%rcx), %r14
incq %r14
movl %esi, %r15d
movq %r15, %rdx
subq %rcx, %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x180b0
movb $0x2e, -0x1(%r14)
addq %rbx, %r15
incq %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x1, %esi
je 0x1c6f2
leaq 0x2(%rbx), %rdi
leaq 0x1(%rbx), %rax
movslq %esi, %r15
leaq -0x1(%r15), %rdx
movq %rax, %rsi
callq 0x180b0
movb $0x2e, 0x1(%rbx)
addq %r15, %rbx
movb $0x65, 0x1(%rbx)
addq $0x2, %rbx
decl %r14d
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1d090
leaq 0xa7f3(%rip), %rdi # 0x26f0d
leaq 0x8f31(%rip), %rsi # 0x25652
leaq 0xa7f1(%rip), %rcx # 0x26f19
movl $0x3bd5, %edx # imm = 0x3BD5
callq 0x180c0
leaq 0xa82d(%rip), %rdi # 0x26f66
leaq 0x8f12(%rip), %rsi # 0x25652
leaq 0xa7d2(%rip), %rcx # 0x26f19
movl $0x3bd6, %edx # imm = 0x3BD6
callq 0x180c0
leaq 0xa81a(%rip), %rdi # 0x26f72
leaq 0x8ef3(%rip), %rsi # 0x25652
leaq 0xa7b3(%rip), %rcx # 0x26f19
movl $0x3bf0, %edx # imm = 0x3BF0
callq 0x180c0
| /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::dtoa_impl::boundaries nlohmann::detail::dtoa_impl::compute_boundaries<double>(double) | boundaries compute_boundaries(FloatType value)
{
JSON_ASSERT(std::isfinite(value));
JSON_ASSERT(value > 0);
// Convert the IEEE representation into a diyfp.
//
// If v is denormal:
// value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1))
// If v is normalized:
// value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
static_assert(std::numeric_limits<FloatType>::is_iec559,
"internal error: dtoa_short requires an IEEE-754 floating-point implementation");
constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
constexpr int kMinExp = 1 - kBias;
constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
const std::uint64_t bits = reinterpret_bits<bits_type>(value);
const std::uint64_t E = bits >> (kPrecision - 1);
const std::uint64_t F = bits & (kHiddenBit - 1);
const bool is_denormal = E == 0;
const diyfp v = is_denormal
? diyfp(F, kMinExp)
: diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
// Compute the boundaries m- and m+ of the floating-point value
// v = f * 2^e.
//
// Determine v- and v+, the floating-point predecessor and successor if v,
// respectively.
//
// v- = v - 2^e if f != 2^(p-1) or e == e_min (A)
// = v - 2^(e-1) if f == 2^(p-1) and e > e_min (B)
//
// v+ = v + 2^e
//
// Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
// between m- and m+ round to v, regardless of how the input rounding
// algorithm breaks ties.
//
// ---+-------------+-------------+-------------+-------------+--- (A)
// v- m- v m+ v+
//
// -----------------+------+------+-------------+-------------+--- (B)
// v- m- v m+ v+
const bool lower_boundary_is_closer = F == 0 && E > 1;
const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
const diyfp m_minus = lower_boundary_is_closer
? diyfp(4 * v.f - 1, v.e - 2) // (B)
: diyfp(2 * v.f - 1, v.e - 1); // (A)
// Determine the normalized w+ = m+.
const diyfp w_plus = diyfp::normalize(m_plus);
// Determine w- = m- such that e_(w-) = e_(w+).
const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
return {diyfp::normalize(v), w_minus, w_plus};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %xmm0, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
jge 0x1c87b
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1c89a
movq %rdi, %rbx
movabsq $0x10000000000000, %rcx # imm = 0x10000000000000
decq %rcx
andq %rax, %rcx
movq %rax, %rdx
shrq $0x34, %rdx
movq %rcx, %r14
btsq $0x34, %r14
leal -0x433(%rdx), %esi
testq %rdx, %rdx
cmoveq %rcx, %r14
movl $0xfffffbce, %r15d # imm = 0xFFFFFBCE
cmovnel %esi, %r15d
testq %rcx, %rcx
sete %cl
shrq $0x35, %rax
setne %al
leal -0x1(%r15), %esi
addl $0xfffffbcb, %edx # imm = 0xFFFFFBCB
testb %cl, %al
cmovel %esi, %edx
leaq -0x1(%r14,%r14), %rax
movabsq $0x3fffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFF
cmoveq %rax, %rcx
leaq 0x8(%rsp), %r12
movq %rcx, (%r12)
movl %edx, 0x8(%r12)
leaq 0x1(,%r14,2), %rdi
callq 0x1c9e8
movq %rax, (%rsp)
movl %edx, %ebp
movq %r12, %rdi
movl %edx, %esi
callq 0x1ca1e
movq %rax, %r12
movl %edx, %r13d
movq %r14, %rdi
movl %r15d, %esi
callq 0x1c9e8
movq %rax, (%rbx)
movl %edx, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movl %r13d, 0x18(%rbx)
movq (%rsp), %rax
movq %rax, 0x20(%rbx)
movl %ebp, 0x28(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa033(%rip), %rdi # 0x268b5
leaq 0x8dc9(%rip), %rsi # 0x25652
leaq 0xa1fe(%rip), %rcx # 0x26a8e
movl $0x38bb, %edx # imm = 0x38BB
callq 0x180c0
leaq 0xa1e3(%rip), %rdi # 0x26a84
leaq 0x8daa(%rip), %rsi # 0x25652
leaq 0xa1df(%rip), %rcx # 0x26a8e
movl $0x38bc, %edx # imm = 0x38BC
callq 0x180c0
| /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::dtoa_impl::grisu2(char*, int&, int&, nlohmann::detail::dtoa_impl::diyfp, nlohmann::detail::dtoa_impl::diyfp, nlohmann::detail::dtoa_impl::diyfp) | inline void grisu2(char* buf, int& len, int& decimal_exponent,
diyfp m_minus, diyfp v, diyfp m_plus)
{
JSON_ASSERT(m_plus.e == m_minus.e);
JSON_ASSERT(m_plus.e == v.e);
// --------(-----------------------+-----------------------)-------- (A)
// m- v m+
//
// --------------------(-----------+-----------------------)-------- (B)
// m- v m+
//
// First scale v (and m- and m+) such that the exponent is in the range
// [alpha, gamma].
const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
// The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
const diyfp w = diyfp::mul(v, c_minus_k);
const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
// ----(---+---)---------------(---+---)---------------(---+---)----
// w- w w+
// = c*m- = c*v = c*m+
//
// diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
// w+ are now off by a small amount.
// In fact:
//
// w - v * 10^k < 1 ulp
//
// To account for this inaccuracy, add resp. subtract 1 ulp.
//
// --------+---[---------------(---+---)---------------]---+--------
// w- M- w M+ w+
//
// Now any number in [M-, M+] (bounds included) will round to w when input,
// regardless of how the input rounding algorithm breaks ties.
//
// And digit_gen generates the shortest possible such number in [M-, M+].
// Note that this does not mean that Grisu2 always generates the shortest
// possible number in the interval (m-, m+).
const diyfp M_minus(w_minus.f + 1, w_minus.e);
const diyfp M_plus (w_plus.f - 1, w_plus.e );
decimal_exponent = -cached.k; // = -(-k) = k
grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x58(%rsp)
movl %r8d, 0x60(%rsp)
cmpl %r8d, 0xc8(%rsp)
jne 0x1c9aa
movq %rdi, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0xb0(%rsp), %r13
cmpl %r8d, 0x8(%r13)
jne 0x1c9c9
movl %r8d, %edi
callq 0x1ca7c
movq %rdx, %r12
leaq 0x68(%rsp), %r14
movq %rax, (%r14)
movl %r12d, 0x8(%r14)
movq %r13, %rdi
movq %r14, %rsi
callq 0x1cbba
movq %rax, %r15
movl %edx, %ebx
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x1cbba
movq %rax, %r13
movl %edx, %ebp
leaq 0xc0(%rsp), %rdi
movq %r14, %rsi
callq 0x1cbba
incq %r13
decq %rax
shrq $0x20, %r12
negl %r12d
movq 0x30(%rsp), %rcx
movl %r12d, (%rcx)
movq %r15, 0x48(%rsp)
movl %ebx, 0x50(%rsp)
movq %rax, 0x38(%rsp)
movl %edx, 0x40(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rcx, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x1cc16
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa207(%rip), %rdi # 0x26bb8
leaq 0x8c9a(%rip), %rsi # 0x25652
leaq 0xa20f(%rip), %rcx # 0x26bce
movl $0x3b3d, %edx # imm = 0x3B3D
callq 0x180c0
leaq 0xa252(%rip), %rdi # 0x26c22
leaq 0x8c7b(%rip), %rsi # 0x25652
leaq 0xa1f0(%rip), %rcx # 0x26bce
movl $0x3b3e, %edx # imm = 0x3B3E
callq 0x180c0
| /coin-au-carre[P]slacking/include/slacking/json.hpp |
slack::_detail::Slacking::setParameters(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&) | void setParameters(const std::string& method, const std::string& data = "") {
auto complete_url = base_url+ method;
session_.SetUrl(complete_url);
session_.SetBody(data);
#if SLACKING_VERBOSE_OUTPUT
std::cout << ">> sending: "<< complete_url << " " << data << '\n';
#endif
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d58e
leaq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x184a0
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d5c6
movq 0x15e22(%rip), %rdi # 0x32fc0
leaq 0x9e2a(%rip), %rsi # 0x26fcf
callq 0x18230
movq %rsp, %rsi
movq %rax, %rdi
callq 0x18130
leaq 0x9e20(%rip), %rsi # 0x26fdc
movq %rax, %rdi
callq 0x18230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18130
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x18290
movq %rsp, %rdi
callq 0x182d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x182d0
movq %rbx, %rdi
callq 0x18270
nop
| /coin-au-carre[P]slacking/include/slacking/slacking.hpp |
nlohmann::detail::parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::parse(bool, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>&) | void parse(const bool strict, BasicJsonType& result)
{
if (callback)
{
json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
sax_parse_internal(&sdp);
result.assert_invariant();
// in strict mode, input must be completely read
if (strict && (get_token() != token_type::end_of_input))
{
sdp.parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
parse_error::create(101, m_lexer.get_position(),
exception_message(token_type::end_of_input, "value")));
}
// in case of an error, return discarded value
if (sdp.is_errored())
{
result = value_t::discarded;
return;
}
// set top-level value to null if it was discarded by the callback
// function
if (result.is_discarded())
{
result = nullptr;
}
}
else
{
json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
sax_parse_internal(&sdp);
result.assert_invariant();
// in strict mode, input must be completely read
if (strict && (get_token() != token_type::end_of_input))
{
sdp.parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
parse_error::create(101, m_lexer.get_position(),
exception_message(token_type::end_of_input, "value")));
}
// in case of an error, return discarded value
if (sdp.is_errored())
{
result = value_t::discarded;
return;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
cmpq $0x0, 0x10(%rdi)
je 0x1dbed
leaq 0xc8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x1da3e
movzbl 0xc0(%r15), %ecx
leaq 0x108(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1ed68
leaq 0xc8(%rsp), %rdi
callq 0x1d3ec
leaq 0x108(%rsp), %rsi
movq %r15, %rdi
callq 0x1ee2c
movq %rbx, %rdi
callq 0x18f5c
testb %bpl, %bpl
je 0x1dbc7
movq %r15, %rdi
callq 0x1df10
cmpl $0xf, %eax
je 0x1dbc7
leaq 0x28(%r15), %rsi
movq 0x48(%r15), %r14
leaq 0x70(%rsp), %rdi
callq 0x1f814
leaq 0x48(%r15), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
leaq 0xb323(%rip), %rsi # 0x28e64
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x18410
leaq 0x50(%rsp), %rdi
pushq $0xf
popq %rdx
leaq 0x30(%rsp), %rcx
movq %r15, %rsi
callq 0x1fa56
leaq 0x90(%rsp), %rdi
pushq $0x65
popq %rsi
leaq 0x10(%rsp), %rdx
leaq 0x50(%rsp), %rcx
callq 0x1f8bc
leaq 0x108(%rsp), %rdi
leaq 0x70(%rsp), %rdx
leaq 0x90(%rsp), %rcx
movq %r14, %rsi
callq 0x1f7d0
leaq 0x90(%rsp), %rdi
callq 0x1fcd6
leaq 0x50(%rsp), %rdi
callq 0x182d0
leaq 0x30(%rsp), %rdi
callq 0x182d0
leaq 0x70(%rsp), %rdi
callq 0x182d0
cmpb $0x1, 0x180(%rsp)
jne 0x1dd3a
leaq 0xf8(%rsp), %r14
pushq $0x9
popq %rsi
movq %r14, %rdi
callq 0x1fcf6
jmp 0x1dd51
movb 0xc0(%r15), %al
leaq 0x110(%rsp), %r14
movq %rbx, -0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups %xmm0, 0x10(%r14)
movb $0x0, 0x20(%r14)
movb %al, 0x21(%r14)
leaq 0x108(%rsp), %rsi
movq %r15, %rdi
callq 0x1fd4c
movq %rbx, %rdi
callq 0x18f5c
testb %bpl, %bpl
je 0x1dcfb
movq %r15, %rdi
callq 0x1df10
cmpl $0xf, %eax
je 0x1dcfb
leaq 0x28(%r15), %rsi
movq 0x48(%r15), %r12
leaq 0x70(%rsp), %rdi
callq 0x1f814
leaq 0x48(%r15), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
leaq 0xb1ef(%rip), %rsi # 0x28e64
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x18410
leaq 0x50(%rsp), %rdi
pushq $0xf
popq %rdx
leaq 0x30(%rsp), %rcx
movq %r15, %rsi
callq 0x1fa56
leaq 0x90(%rsp), %rdi
pushq $0x65
popq %rsi
leaq 0x10(%rsp), %rdx
leaq 0x50(%rsp), %rcx
callq 0x1f8bc
leaq 0x108(%rsp), %rdi
leaq 0x70(%rsp), %rdx
leaq 0x90(%rsp), %rcx
movq %r12, %rsi
callq 0x206fc
leaq 0x90(%rsp), %rdi
callq 0x1fcd6
leaq 0x50(%rsp), %rdi
callq 0x182d0
leaq 0x30(%rsp), %rdi
callq 0x182d0
leaq 0x70(%rsp), %rdi
callq 0x182d0
cmpb $0x1, 0x130(%rsp)
jne 0x1dd30
leaq 0xb8(%rsp), %rdi
pushq $0x9
popq %rsi
callq 0x1fcf6
leaq 0xb8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1d3ac
movq %r15, %rdi
callq 0x18cca
movq %r14, %rdi
callq 0x20ca2
jmp 0x1dd71
cmpb $0x9, (%rbx)
jne 0x1dd64
leaq 0xe8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x18f40
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d3ac
movq %r14, %rdi
callq 0x18cca
leaq 0x108(%rsp), %rdi
callq 0x1fd10
addq $0x1c0, %rsp # imm = 0x1C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x1fcd6
jmp 0x1dd96
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x182d0
jmp 0x1dda5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x182d0
jmp 0x1ddb4
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x182d0
jmp 0x1de18
jmp 0x1de15
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x1fcd6
jmp 0x1ddd7
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x182d0
jmp 0x1dde6
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x182d0
jmp 0x1ddf5
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x182d0
jmp 0x1de25
jmp 0x1de22
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x1d3ec
jmp 0x1de32
movq %rax, %rbx
movq %r14, %rdi
callq 0x20ca2
jmp 0x1de32
movq %rax, %rbx
leaq 0x108(%rsp), %rdi
callq 0x1fd10
movq %rbx, %rdi
callq 0x18270
| /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::lexer(nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&, bool) | explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false)
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{} | pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movb %dl, 0x10(%rdi)
orl $-0x1, 0x14(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rcx, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
movb %al, 0x60(%rdi)
leaq 0x8528(%rip), %rax # 0x26418
movq %rax, 0x70(%rdi)
movups %xmm0, 0x78(%rdi)
andq $0x0, 0x88(%rdi)
callq 0x1df3c
movsbl %al, %eax
movl %eax, 0x90(%rbx)
popq %rbx
retq
| /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan_string() | token_type scan_string()
{
// reset token_buffer (ignore opening quote)
reset();
// we entered the function by reading an open quote
JSON_ASSERT(current == '\"');
while (true)
{
// get next character
switch (get())
{
// end of file while parsing string
case std::char_traits<char_type>::eof():
{
error_message = "invalid string: missing closing quote";
return token_type::parse_error;
}
// closing quote
case '\"':
{
return token_type::value_string;
}
// escapes
case '\\':
{
switch (get())
{
// quotation mark
case '\"':
add('\"');
break;
// reverse solidus
case '\\':
add('\\');
break;
// solidus
case '/':
add('/');
break;
// backspace
case 'b':
add('\b');
break;
// form feed
case 'f':
add('\f');
break;
// line feed
case 'n':
add('\n');
break;
// carriage return
case 'r':
add('\r');
break;
// tab
case 't':
add('\t');
break;
// unicode escapes
case 'u':
{
const int codepoint1 = get_codepoint();
int codepoint = codepoint1; // start with codepoint1
if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
}
// check if code point is a high surrogate
if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
{
// expect next \uxxxx entry
if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
{
const int codepoint2 = get_codepoint();
if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
}
// check if codepoint2 is a low surrogate
if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
{
// overwrite codepoint
codepoint = static_cast<int>(
// high surrogate occupies the most significant 22 bits
(static_cast<unsigned int>(codepoint1) << 10u)
// low surrogate occupies the least significant 15 bits
+ static_cast<unsigned int>(codepoint2)
// there is still the 0xD800, 0xDC00 and 0x10000 noise
// in the result so we have to subtract with:
// (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
- 0x35FDC00u);
}
else
{
error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
return token_type::parse_error;
}
}
else
{
error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
return token_type::parse_error;
}
}
else
{
if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
{
error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
return token_type::parse_error;
}
}
// result of the above calculation yields a proper codepoint
JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
// translate codepoint into bytes
if (codepoint < 0x80)
{
// 1-byte characters: 0xxxxxxx (ASCII)
add(static_cast<char_int_type>(codepoint));
}
else if (codepoint <= 0x7FF)
{
// 2-byte characters: 110xxxxx 10xxxxxx
add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else if (codepoint <= 0xFFFF)
{
// 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else
{
// 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
break;
}
// other characters after escape
default:
error_message = "invalid string: forbidden character after backslash";
return token_type::parse_error;
}
break;
}
// invalid control characters
case 0x00:
{
error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
return token_type::parse_error;
}
case 0x01:
{
error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
return token_type::parse_error;
}
case 0x02:
{
error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
return token_type::parse_error;
}
case 0x03:
{
error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
return token_type::parse_error;
}
case 0x04:
{
error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
return token_type::parse_error;
}
case 0x05:
{
error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
return token_type::parse_error;
}
case 0x06:
{
error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
return token_type::parse_error;
}
case 0x07:
{
error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
return token_type::parse_error;
}
case 0x08:
{
error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
return token_type::parse_error;
}
case 0x09:
{
error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
return token_type::parse_error;
}
case 0x0A:
{
error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
return token_type::parse_error;
}
case 0x0B:
{
error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
return token_type::parse_error;
}
case 0x0C:
{
error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
return token_type::parse_error;
}
case 0x0D:
{
error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
return token_type::parse_error;
}
case 0x0E:
{
error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
return token_type::parse_error;
}
case 0x0F:
{
error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
return token_type::parse_error;
}
case 0x10:
{
error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
return token_type::parse_error;
}
case 0x11:
{
error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
return token_type::parse_error;
}
case 0x12:
{
error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
return token_type::parse_error;
}
case 0x13:
{
error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
return token_type::parse_error;
}
case 0x14:
{
error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
return token_type::parse_error;
}
case 0x15:
{
error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
return token_type::parse_error;
}
case 0x16:
{
error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
return token_type::parse_error;
}
case 0x17:
{
error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
return token_type::parse_error;
}
case 0x18:
{
error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
return token_type::parse_error;
}
case 0x19:
{
error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
return token_type::parse_error;
}
case 0x1A:
{
error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
return token_type::parse_error;
}
case 0x1B:
{
error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
return token_type::parse_error;
}
case 0x1C:
{
error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
return token_type::parse_error;
}
case 0x1D:
{
error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
return token_type::parse_error;
}
case 0x1E:
{
error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
return token_type::parse_error;
}
case 0x1F:
{
error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
return token_type::parse_error;
}
// U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
case 0x20:
case 0x21:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2A:
case 0x2B:
case 0x2C:
case 0x2D:
case 0x2E:
case 0x2F:
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
case 0x3A:
case 0x3B:
case 0x3C:
case 0x3D:
case 0x3E:
case 0x3F:
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4A:
case 0x4B:
case 0x4C:
case 0x4D:
case 0x4E:
case 0x4F:
case 0x50:
case 0x51:
case 0x52:
case 0x53:
case 0x54:
case 0x55:
case 0x56:
case 0x57:
case 0x58:
case 0x59:
case 0x5A:
case 0x5B:
case 0x5D:
case 0x5E:
case 0x5F:
case 0x60:
case 0x61:
case 0x62:
case 0x63:
case 0x64:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6A:
case 0x6B:
case 0x6C:
case 0x6D:
case 0x6E:
case 0x6F:
case 0x70:
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77:
case 0x78:
case 0x79:
case 0x7A:
case 0x7B:
case 0x7C:
case 0x7D:
case 0x7E:
case 0x7F:
{
add(current);
break;
}
// U+0080..U+07FF: bytes C2..DF 80..BF
case 0xC2:
case 0xC3:
case 0xC4:
case 0xC5:
case 0xC6:
case 0xC7:
case 0xC8:
case 0xC9:
case 0xCA:
case 0xCB:
case 0xCC:
case 0xCD:
case 0xCE:
case 0xCF:
case 0xD0:
case 0xD1:
case 0xD2:
case 0xD3:
case 0xD4:
case 0xD5:
case 0xD6:
case 0xD7:
case 0xD8:
case 0xD9:
case 0xDA:
case 0xDB:
case 0xDC:
case 0xDD:
case 0xDE:
case 0xDF:
{
if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
{
return token_type::parse_error;
}
break;
}
// U+0800..U+0FFF: bytes E0 A0..BF 80..BF
case 0xE0:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
// U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
case 0xE1:
case 0xE2:
case 0xE3:
case 0xE4:
case 0xE5:
case 0xE6:
case 0xE7:
case 0xE8:
case 0xE9:
case 0xEA:
case 0xEB:
case 0xEC:
case 0xEE:
case 0xEF:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+D000..U+D7FF: bytes ED 80..9F 80..BF
case 0xED:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
case 0xF0:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
case 0xF1:
case 0xF2:
case 0xF3:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
case 0xF4:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// remaining bytes (80..C1 and F5..FF) are ill-formed
default:
{
error_message = "invalid string: ill-formed UTF-8 byte";
return token_type::parse_error;
}
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x1ebb4
cmpl $0x22, 0x14(%rbx)
jne 0x1e634
leaq 0x50(%rbx), %r14
leaq 0x6f07(%rip), %r12 # 0x25144
pushq $0xe
popq %rbp
movq %rbx, %rdi
callq 0x1e9a4
incl %eax
cmpl $0xf5, %eax
ja 0x1e606
movslq (%r12,%rax,4), %rcx
addq %r12, %rcx
movabsq $0xbf00000080, %rax # imm = 0xBF00000080
jmpq *%rcx
movb 0x14(%rbx), %r15b
movsbl %r15b, %esi
movq %r14, %rdi
callq 0x184c0
jmp 0x1e240
movq %rsp, %rsi
movq %rax, (%rsi)
pushq $0x2
jmp 0x1e312
movaps 0x6e22(%rip), %xmm0 # 0x250b0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
pushq $0x4
jmp 0x1e312
movups 0xc859(%rip), %xmm0 # 0x2aaf8
jmp 0x1e306
movaps 0x6df8(%rip), %xmm0 # 0x250a0
jmp 0x1e28e
movq %rbx, %rdi
callq 0x1e9a4
leaq 0x9593(%rip), %r13 # 0x2784c
leal -0x6e(%rax), %ecx
cmpl $0x7, %ecx
jbe 0x1e334
cmpl $0x22, %eax
je 0x1e42d
cmpl $0x2f, %eax
je 0x1e43d
cmpl $0x66, %eax
je 0x1e435
cmpl $0x62, %eax
je 0x1e445
cmpl $0x5c, %eax
jne 0x1e60d
movb $0x5c, %r15b
jmp 0x1e26c
movups 0xc813(%rip), %xmm0 # 0x2ab10
jmp 0x1e306
movups 0xc7da(%rip), %xmm0 # 0x2aae0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rax, 0x10(%rsi)
pushq $0x6
popq %rdx
movq %rbx, %rdi
callq 0x1ecb8
testb %al, %al
jne 0x1e240
jmp 0x1e611
movaps 0x6d91(%rip), %xmm0 # 0x250c0
jmp 0x1e28e
leaq 0x71e1(%rip), %rax # 0x2551c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb $0xa, %r15b
jmp 0x1e26c
movb $0xd, %r15b
jmp 0x1e26c
movq %rbx, %rdi
callq 0x1ebf0
leaq 0x93f8(%rip), %r13 # 0x2775b
cmpl $-0x1, %eax
je 0x1e60d
movl %eax, %r15d
andl $0xfffffc00, %eax # imm = 0xFFFFFC00
cmpl $0xd800, %eax # imm = 0xD800
jne 0x1e44d
movq %rbx, %rdi
callq 0x1e9a4
cmpl $0x5c, %eax
jne 0x1e622
movq %rbx, %rdi
callq 0x1e9a4
cmpl $0x75, %eax
jne 0x1e622
movq %rbx, %rdi
callq 0x1ebf0
cmpl $-0x1, %eax
je 0x1e60d
movl %eax, %ecx
andl $0xfffffc00, %ecx # imm = 0xFFFFFC00
leaq 0x93d0(%rip), %r13 # 0x27791
cmpl $0xdc00, %ecx # imm = 0xDC00
jne 0x1e60d
shll $0xa, %r15d
addl %eax, %r15d
addl $0xfca02400, %r15d # imm = 0xFCA02400
movl %r15d, %eax
shrl $0x12, %eax
orb $-0x10, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x184c0
movl %r15d, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x184c0
movl %r15d, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x184c0
andb $0x3f, %r15b
orb $-0x80, %r15b
jmp 0x1e26c
movb $0x9, %r15b
jmp 0x1e26c
movb $0x22, %r15b
jmp 0x1e26c
movb $0xc, %r15b
jmp 0x1e26c
movb $0x2f, %r15b
jmp 0x1e26c
movb $0x8, %r15b
jmp 0x1e26c
cmpl $0xdc00, %eax # imm = 0xDC00
je 0x1e62b
cmpl $0x110000, %r15d # imm = 0x110000
jae 0x1e653
cmpl $0x7f, %r15d
jbe 0x1e26c
cmpl $0x7ff, %r15d # imm = 0x7FF
ja 0x1e482
movl %r15d, %eax
shrl $0x6, %eax
orb $-0x40, %al
jmp 0x1e40d
cmpl $0xffff, %r15d # imm = 0xFFFF
ja 0x1e3db
movl %r15d, %eax
shrl $0xc, %eax
orb $-0x20, %al
jmp 0x1e3f8
leaq 0x9c7e(%rip), %r13 # 0x28121
jmp 0x1e60d
leaq 0x9b08(%rip), %r13 # 0x27fb7
jmp 0x1e60d
leaq 0x9946(%rip), %r13 # 0x27e01
jmp 0x1e60d
leaq 0x9733(%rip), %r13 # 0x27bfa
jmp 0x1e60d
leaq 0x9977(%rip), %r13 # 0x27e4a
jmp 0x1e60d
leaq 0x9769(%rip), %r13 # 0x27c48
jmp 0x1e60d
leaq 0x9a3a(%rip), %r13 # 0x27f25
jmp 0x1e60d
leaq 0x9be2(%rip), %r13 # 0x280d9
jmp 0x1e60d
leaq 0x94ea(%rip), %r13 # 0x279ed
jmp 0x1e60d
leaq 0x98a9(%rip), %r13 # 0x27db8
jmp 0x1e60d
leaq 0x9a53(%rip), %r13 # 0x27f6e
jmp 0x1e60d
leaq 0x947d(%rip), %r13 # 0x279a4
jmp 0x1e60d
leaq 0x9428(%rip), %r13 # 0x2795b
jmp 0x1e60d
leaq 0x9625(%rip), %r13 # 0x27b64
jmp 0x1e60d
leaq 0x94eb(%rip), %r13 # 0x27a36
jmp 0x1e60d
leaq 0x9af1(%rip), %r13 # 0x28048
jmp 0x1e60d
leaq 0x93af(%rip), %r13 # 0x27912
jmp 0x1e60d
leaq 0x91c6(%rip), %r13 # 0x27735
jmp 0x1e60d
leaq 0x97ab(%rip), %r13 # 0x27d26
jmp 0x1e60d
leaq 0x9342(%rip), %r13 # 0x278c9
jmp 0x1e60d
leaq 0x92ed(%rip), %r13 # 0x27880
jmp 0x1e60d
leaq 0x97d3(%rip), %r13 # 0x27d6f
jmp 0x1e60d
leaq 0x9571(%rip), %r13 # 0x27b16
jmp 0x1e60d
leaq 0x9bbb(%rip), %r13 # 0x28169
jmp 0x1e60d
leaq 0x94c8(%rip), %r13 # 0x27a7f
jmp 0x1e60d
leaq 0x991c(%rip), %r13 # 0x27edc
jmp 0x1e60d
leaq 0x95e9(%rip), %r13 # 0x27bb2
jmp 0x1e60d
leaq 0x96c4(%rip), %r13 # 0x27c96
jmp 0x1e60d
leaq 0x94ed(%rip), %r13 # 0x27ac8
jmp 0x1e60d
leaq 0x98af(%rip), %r13 # 0x27e93
jmp 0x1e60d
leaq 0x9a12(%rip), %r13 # 0x27fff
jmp 0x1e60d
leaq 0x96e8(%rip), %r13 # 0x27cde
jmp 0x1e60d
leaq 0x9a92(%rip), %r13 # 0x28091
jmp 0x1e60d
pushq $0x4
popq %rbp
jmp 0x1e611
leaq 0x9ba4(%rip), %r13 # 0x281b1
movq %r13, 0x70(%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9168(%rip), %r13 # 0x27791
jmp 0x1e60d
leaq 0x91ab(%rip), %r13 # 0x277dd
jmp 0x1e60d
leaq 0x8f86(%rip), %rdi # 0x275c1
leaq 0x7010(%rip), %rsi # 0x25652
leaq 0x8f88(%rip), %rcx # 0x275d1
movl $0x17f3, %edx # imm = 0x17F3
callq 0x180c0
leaq 0x91c7(%rip), %rdi # 0x27821
leaq 0x6ff1(%rip), %rsi # 0x25652
leaq 0x8f69(%rip), %rcx # 0x275d1
movl $0x186b, %edx # imm = 0x186B
callq 0x180c0
| /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::unget() | void unget()
{
next_unget = true;
--position.chars_read_total;
// in case we "unget" a newline, we have to also decrement the lines_read
if (position.chars_read_current_line == 0)
{
if (position.lines_read > 0)
{
--position.lines_read;
}
}
else
{
--position.chars_read_current_line;
}
if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
{
JSON_ASSERT(!token_string.empty());
token_string.pop_back();
}
} | movb $0x1, 0x18(%rdi)
decq 0x20(%rdi)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1ea31
leaq 0x28(%rdi), %rcx
jmp 0x1ea3e
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x1ea44
leaq 0x30(%rdi), %rcx
decq %rax
movq %rax, (%rcx)
cmpl $-0x1, 0x14(%rdi)
je 0x1ea5b
movq 0x40(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x1ea5c
decq %rax
movq %rax, 0x40(%rdi)
retq
pushq %rax
leaq 0x87be(%rip), %rdi # 0x27222
leaq 0x6be7(%rip), %rsi # 0x25652
leaq 0x87c6(%rip), %rcx # 0x27238
movl $0x1c62, %edx # imm = 0x1C62
callq 0x180c0
| /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>> nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::erase<nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>, 0>(nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>) | IteratorType erase(IteratorType pos)
{
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
}
IteratorType result = end();
switch (m_type)
{
case value_t::boolean:
case value_t::number_float:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::string:
case value_t::binary:
{
if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
{
JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
}
if (is_string())
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
m_value.string = nullptr;
}
else if (is_binary())
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
m_value.binary = nullptr;
}
m_type = value_t::null;
assert_invariant();
break;
}
case value_t::object:
{
result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
break;
}
case value_t::array:
{
result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
break;
}
default:
JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpq %rsi, (%rdx)
jne 0x21b58
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2194e
movzbl (%r14), %eax
leal -0x3(%rax), %ecx
cmpl $0x6, %ecx
jae 0x21af1
cmpq $0x0, 0x18(%r15)
jne 0x21bab
cmpl $0x8, %eax
je 0x21b12
cmpl $0x3, %eax
jne 0x21b2b
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
callq 0x182d0
jmp 0x21b1f
cmpl $0x1, %eax
je 0x21b45
cmpl $0x2, %eax
jne 0x21bfb
movq 0x8(%r14), %rdi
movq 0x10(%r15), %rsi
callq 0x21f7c
movq %rax, 0x10(%rbx)
jmp 0x21b37
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
callq 0x1a9ae
movq (%r15), %rdi
callq 0x18210
andq $0x0, (%r15)
movb $0x0, (%r14)
movq %r14, %rdi
callq 0x18f5c
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdi
movq 0x8(%r15), %rsi
callq 0x21f82
movq %rax, 0x8(%rbx)
jmp 0x21b37
pushq $0x20
popq %rdi
callq 0x18160
movq %rax, %rbx
leaq 0x7300(%rip), %rsi # 0x28e6a
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x18410
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xca, %esi
callq 0x21e46
xorl %ebp, %ebp
leaq 0x110b1(%rip), %rsi # 0x32c48
leaq -0x1ec8(%rip), %rdx # 0x1fcd6
movq %rbx, %rdi
callq 0x18260
jmp 0x21c63
pushq $0x20
popq %rdi
callq 0x18160
movq %rax, %rbx
leaq 0x72d1(%rip), %rsi # 0x28e8e
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x18410
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcd, %esi
callq 0x21e46
xorl %ebp, %ebp
leaq 0x1105e(%rip), %rsi # 0x32c48
leaq -0x1f1b(%rip), %rdx # 0x1fcd6
movq %rbx, %rdi
callq 0x18260
jmp 0x21c63
pushq $0x20
popq %rdi
callq 0x18160
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a202
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x18410
leaq 0x727d(%rip), %rsi # 0x28ea4
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x19848
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x133, %esi # imm = 0x133
callq 0x19e56
xorl %ebp, %ebp
leaq 0x10ebc(%rip), %rsi # 0x32b10
leaq -0x1f85(%rip), %rdx # 0x1fcd6
movq %rbx, %rdi
callq 0x18260
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x182d0
jmp 0x21c78
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
jmp 0x21c8d
jmp 0x21c99
jmp 0x21c85
jmp 0x21c99
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x182d0
testb %bpl, %bpl
jne 0x21c9c
jmp 0x21ca4
movq %rax, %r14
movq %rbx, %rdi
callq 0x183a0
movq %r14, %rdi
callq 0x18270
| /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::operator++() | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
default:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x21ce3
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x21cd3
cmpl $0x1, %eax
jne 0x21cda
leaq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x22089
jmp 0x21cde
addq $0x10, 0x10(%rbx)
jmp 0x21cde
incq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x6ec0(%rip), %rdi # 0x28baa
leaq 0x3961(%rip), %rsi # 0x25652
leaq 0x71c5(%rip), %rcx # 0x28ebd
movl $0x2b54, %edx # imm = 0x2B54
callq 0x180c0
| /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::set_end() | void set_end() noexcept
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
case value_t::object:
{
m_it.object_iterator = m_object->m_value.object->end();
break;
}
case value_t::array:
{
m_it.array_iterator = m_object->m_value.array->end();
break;
}
default:
{
m_it.primitive_iterator.set_end();
break;
}
}
} | movq (%rdi), %rax
testq %rax, %rax
je 0x21f5c
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0x21f46
cmpl $0x1, %ecx
jne 0x21f53
movq 0x8(%rax), %rax
addq $0x8, %rax
movq %rax, 0x8(%rdi)
retq
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rdi)
retq
movq $0x1, 0x18(%rdi)
retq
pushq %rax
leaq 0x6c46(%rip), %rdi # 0x28baa
leaq 0x36e7(%rip), %rsi # 0x25652
leaq 0x6d93(%rip), %rcx # 0x28d05
movl $0x2ae3, %edx # imm = 0x2AE3
callq 0x180c0
| /coin-au-carre[P]slacking/include/slacking/json.hpp |
CommandReader::args() const | std::unique_ptr<char *[]> args() const {
// same
if (!this->enclosed) {
auto empty = std::unique_ptr<char *[]>();
return empty;
}
auto args = std::make_unique<char *[]>(this->arguments.size() + 1);
for (size_t i = 0; i < this->arguments.size(); i++) {
args[i] = (char *)this->arguments[i].c_str();
}
args[this->arguments.size()] = nullptr;
return args;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x2(%rsi)
je 0x4f42
movq %rsi, %r15
movq 0x30(%rsi), %rax
subq 0x28(%rsi), %rax
sarq $0x5, %rax
leaq 0x1(%rax), %rcx
shrq $0x3d, %rcx
leaq 0x8(,%rax,8), %rax
xorl %r12d, %r12d
negq %rcx
sbbq %r12, %r12
orq %rax, %r12
movq %r12, %rdi
callq 0x4030
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x4100
movq %r14, (%rbx)
movq 0x28(%r15), %rax
movq 0x30(%r15), %rdx
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rax, %rdx
je 0x4f3c
cmpq $0x1, %rcx
movq %rcx, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
movq (%rax), %rdi
movq %rdi, (%r14,%rsi,8)
incq %rsi
addq $0x20, %rax
cmpq %rsi, %rdx
jne 0x4f29
leaq (%r14,%rcx,8), %rax
jmp 0x4f4c
movq $0x0, (%rbx)
movq %rbx, %rax
movq $0x0, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /tongyuantongyu[P]BasicSH/main.cpp |
mzd_addmul_v_uint64_30_128 | void mzd_addmul_v_uint64_30_128(mzd_local_t* c, mzd_local_t const* v, mzd_local_t const* A) {
block_t* cblock = BLOCK(c, 0);
const block_t* Ablock = CONST_BLOCK(A, 0);
word idx = CONST_BLOCK(v, 0)->w64[1] >> 34;
for (unsigned int i = 15; i; --i, idx >>= 2, ++Ablock) {
const word mask1 = -(idx & 1);
const word mask2 = -((idx >> 1) & 1);
for (unsigned int j = 0; j < 2; ++j) {
cblock->w64[j] ^= (Ablock->w64[j] & mask1) ^ (Ablock->w64[j + 2] & mask2);
}
}
} | pushq %rbx
movq 0x8(%rsi), %rax
movl $0xf, %ecx
shrq $0x22, %rax
movl %eax, %r9d
movq %rax, %r8
shlq $0x3e, %r8
andl $0x1, %r9d
movb $0x1, %sil
xorl %r10d, %r10d
sarq $0x3f, %r8
negq %r9
movq (%rdx,%r10,8), %r11
movq 0x10(%rdx,%r10,8), %rbx
andq %r9, %r11
andq %r8, %rbx
xorq %r11, %rbx
xorq %rbx, (%rdi,%r10,8)
movl $0x1, %r10d
testb $0x1, %sil
movl $0x0, %esi
jne 0x5176
shrq $0x2, %rax
addq $0x20, %rdx
decl %ecx
jne 0x515b
popq %rbx
retq
| /IAIK[P]Picnic/mzd_additional.c |
mzd_addmul_v_uint64_30_256 | void mzd_addmul_v_uint64_30_256(mzd_local_t* c, mzd_local_t const* v, mzd_local_t const* A) {
block_t* cblock = BLOCK(c, 0);
const block_t* Ablock = CONST_BLOCK(A, 0);
word idx = CONST_BLOCK(v, 0)->w64[3] >> 34;
for (unsigned int i = 30; i; --i, idx >>= 1, ++Ablock) {
const word mask = -(idx & 1);
mzd_xor_mask_uint64_block(cblock, Ablock, mask, 4);
}
} | movq 0x18(%rsi), %rax
movl $0x1e, %ecx
shrq $0x22, %rax
movl %eax, %esi
andl $0x1, %esi
xorl %r8d, %r8d
negq %rsi
movq (%rdx,%r8,8), %r9
andq %rsi, %r9
xorq %r9, (%rdi,%r8,8)
incq %r8
cmpq $0x4, %r8
jne 0x51fb
shrq %rax
addq $0x20, %rdx
decl %ecx
jne 0x51f0
retq
| /IAIK[P]Picnic/mzd_additional.c |
mzd_addmul_v_s256_30_192 | ATTR_TARGET_AVX2
void mzd_addmul_v_s256_30_192(mzd_local_t* c, mzd_local_t const* v, mzd_local_t const* A) {
mzd_addmul_v_s256_30_256_idx(c, A, CONST_BLOCK(v, 0)->w64[2] >> 34);
} | movq 0x10(%rsi), %rax
vmovdqa (%rdx), %ymm1
btq $0x22, %rax
movq %rax, %rsi
sbbq %rcx, %rcx
shlq $0x1c, %rsi
shrq $0x24, %rax
sarq $0x3f, %rsi
vpbroadcastq %rcx, %ymm0
movl $0x40, %ecx
vpternlogq $0x6a, (%rdi), %ymm1, %ymm0
vpbroadcastq %rsi, %ymm1
vpand 0x20(%rdx), %ymm1, %ymm1
movq %rax, %r8
shlq $0x3e, %r8
movl %eax, %esi
andl $0x1, %esi
movq %rax, %r9
shlq $0x3d, %r9
sarq $0x3f, %r8
negq %rsi
sarq $0x3f, %r9
vpbroadcastq %r8, %ymm3
movq %rax, %r8
shlq $0x3c, %r8
vpbroadcastq %rsi, %ymm2
vpbroadcastq %r9, %ymm4
shrq $0x4, %rax
sarq $0x3f, %r8
vpternlogq $0x78, (%rdx,%rcx), %ymm2, %ymm0
vpternlogq $0x78, 0x20(%rdx,%rcx), %ymm3, %ymm1
vpbroadcastq %r8, %ymm2
vpternlogq $0x78, 0x40(%rdx,%rcx), %ymm4, %ymm0
vpternlogq $0x78, 0x60(%rdx,%rcx), %ymm2, %ymm1
subq $-0x80, %rcx
cmpl $0x3c0, %ecx # imm = 0x3C0
jne 0x5607
vpxor %ymm0, %ymm1, %ymm0
vmovdqa %ymm0, (%rdi)
vzeroupper
retq
| /IAIK[P]Picnic/mzd_additional.c |
mzd_addmul_v_s256_30_256 | ATTR_TARGET_AVX2
void mzd_addmul_v_s256_30_256(mzd_local_t* c, mzd_local_t const* v, mzd_local_t const* A) {
mzd_addmul_v_s256_30_256_idx(c, A, CONST_BLOCK(v, 0)->w64[3] >> 34);
} | movq 0x18(%rsi), %rax
vmovdqa (%rdx), %ymm1
btq $0x22, %rax
movq %rax, %rsi
sbbq %rcx, %rcx
shlq $0x1c, %rsi
shrq $0x24, %rax
sarq $0x3f, %rsi
vpbroadcastq %rcx, %ymm0
movl $0x40, %ecx
vpternlogq $0x6a, (%rdi), %ymm1, %ymm0
vpbroadcastq %rsi, %ymm1
vpand 0x20(%rdx), %ymm1, %ymm1
movq %rax, %r8
shlq $0x3e, %r8
movl %eax, %esi
andl $0x1, %esi
movq %rax, %r9
shlq $0x3d, %r9
sarq $0x3f, %r8
negq %rsi
sarq $0x3f, %r9
vpbroadcastq %r8, %ymm3
movq %rax, %r8
shlq $0x3c, %r8
vpbroadcastq %rsi, %ymm2
vpbroadcastq %r9, %ymm4
shrq $0x4, %rax
sarq $0x3f, %r8
vpternlogq $0x78, (%rdx,%rcx), %ymm2, %ymm0
vpternlogq $0x78, 0x20(%rdx,%rcx), %ymm3, %ymm1
vpbroadcastq %r8, %ymm2
vpternlogq $0x78, 0x40(%rdx,%rcx), %ymm4, %ymm0
vpternlogq $0x78, 0x60(%rdx,%rcx), %ymm2, %ymm1
subq $-0x80, %rcx
cmpl $0x3c0, %ecx # imm = 0x3C0
jne 0x56c3
vpxor %ymm0, %ymm1, %ymm0
vmovdqa %ymm0, (%rdi)
vzeroupper
retq
| /IAIK[P]Picnic/mzd_additional.c |
mzd_mul_v_parity_s256_256_30 | ATTR_TARGET_AVX2
void mzd_mul_v_parity_s256_256_30(mzd_local_t* c, mzd_local_t const* v, mzd_local_t const* At) {
const word256 vblock = mm256_load(v->w64);
word256 res = mm256_zero;
// process 3 rows at a time
for (unsigned int i = 30; i; i -= 3) {
const word256 Ablock1 = mm256_and(vblock, mm256_load(CONST_BLOCK(At, 30 - i)->w64));
const word256 Ablock2 = mm256_and(vblock, mm256_load(CONST_BLOCK(At, 30 - i + 1)->w64));
const word256 Ablock3 = mm256_and(vblock, mm256_load(CONST_BLOCK(At, 30 - i + 2)->w64));
res = mm256_xor(
res, _mm256_sll_epi64(mm256_parity_3(Ablock1, Ablock2, Ablock3), _mm_set1_epi64x(64 - i)));
}
for (unsigned int j = 0; j < 3; j++) {
c->w64[j] = 0;
}
// combine the parities of each quad word
#if defined(__x86_64__) || defined(_M_X64)
c->w64[3] = _mm256_extract_epi64(res, 0) ^ _mm256_extract_epi64(res, 1) ^
_mm256_extract_epi64(res, 2) ^ _mm256_extract_epi64(res, 3);
#else
// workaround for missing _mm256_extract_epi64 on x86-32
uint64_t tmp[4] ATTR_ALIGNED(sizeof(word256));
mm256_store(tmp, res);
c->w64[3] = tmp[0] ^ tmp[1] ^ tmp[2] ^ tmp[3];
#endif
} | vmovdqa (%rsi), %ymm1
vpbroadcastb 0xe6b(%rip), %ymm2 # 0x6612
vbroadcasti128 0xf20(%rip), %ymm3 # ymm3 = mem[0,1,0,1]
vpbroadcastq 0xe67(%rip), %ymm4 # 0x6620
vpbroadcastq 0xe66(%rip), %ymm5 # 0x6628
vpbroadcastq 0xe9d(%rip), %ymm6 # 0x6668
addq $0x40, %rdx
vpxor %xmm0, %xmm0, %xmm0
movl $0x22, %eax
vpand -0x40(%rdx), %ymm1, %ymm7
vpand -0x20(%rdx), %ymm1, %ymm8
vpand (%rdx), %ymm1, %ymm9
addq $0x60, %rdx
vpsrld $0x4, %ymm7, %ymm10
vpand %ymm2, %ymm7, %ymm7
vpand %ymm2, %ymm10, %ymm10
vpshufb %ymm7, %ymm3, %ymm7
vpshufb %ymm10, %ymm3, %ymm10
vpsadbw %ymm7, %ymm10, %ymm7
vpsrld $0x4, %ymm8, %ymm10
vpand %ymm2, %ymm8, %ymm8
vpand %ymm2, %ymm10, %ymm10
vpshufb %ymm8, %ymm3, %ymm8
vpshufb %ymm10, %ymm3, %ymm10
vpsadbw %ymm10, %ymm8, %ymm8
vpsrld $0x4, %ymm9, %ymm10
vpand %ymm2, %ymm9, %ymm9
vpand %ymm2, %ymm10, %ymm10
vpshufb %ymm9, %ymm3, %ymm9
vpshufb %ymm10, %ymm3, %ymm10
vpaddq %ymm8, %ymm8, %ymm8
vpsadbw %ymm10, %ymm9, %ymm9
vpand %ymm4, %ymm8, %ymm8
vpternlogq $0xf8, %ymm5, %ymm7, %ymm8
vpsllq $0x2, %ymm9, %ymm7
vmovq %rax, %xmm9
addq $0x3, %rax
vpternlogq $0xec, %ymm6, %ymm8, %ymm7
vpsllq %xmm9, %ymm7, %ymm7
vpxor %ymm0, %ymm7, %ymm0
cmpq $0x40, %rax
jne 0x57d8
vpxor %xmm1, %xmm1, %xmm1
movq $0x0, 0x10(%rdi)
vmovdqu %xmm1, (%rdi)
vextracti128 $0x1, %ymm0, %xmm1
vpxor %xmm1, %xmm0, %xmm0
vpshufd $0xee, %xmm0, %xmm1 # xmm1 = xmm0[2,3,2,3]
vpxor %xmm1, %xmm0, %xmm0
vmovq %xmm0, 0x18(%rdi)
vzeroupper
retq
nopw %cs:(%rax,%rax)
nop
| /IAIK[P]Picnic/mzd_additional.c |
JlGetObjectNumberF64 | JL_STATUS
JlGetObjectNumberF64
(
JlDataObject const* NumberObject,
double* pNumberF64
)
{
JL_STATUS jlStatus;
if( NULL != NumberObject
&& NULL != pNumberF64 )
{
if( JL_DATA_TYPE_NUMBER == NumberObject->Type
&& JL_NUM_TYPE_FLOAT == NumberObject->Number.Type )
{
// Number stored as a double. Easy.
*pNumberF64 = NumberObject->Number.f64;
jlStatus = JL_STATUS_SUCCESS;
}
else if( JL_DATA_TYPE_NUMBER == NumberObject->Type
&& JL_NUM_TYPE_UNSIGNED == NumberObject->Number.Type )
{
// Convert from uint64_t to double. Precision may be lost.
*pNumberF64 = (double)(NumberObject->Number.u64);
jlStatus = JL_STATUS_SUCCESS;
}
else if( JL_DATA_TYPE_NUMBER == NumberObject->Type
&& JL_NUM_TYPE_SIGNED == NumberObject->Number.Type )
{
// Convert from int64_t to double. Precision may be lost.
*pNumberF64 = (double)(NumberObject->Number.s64);
jlStatus = JL_STATUS_SUCCESS;
}
else
{
*pNumberF64 = 0.0;
jlStatus = JL_STATUS_WRONG_TYPE;
}
}
else
{
jlStatus = JL_STATUS_INVALID_PARAMETER;
}
return jlStatus;
} | testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
orb %cl, %dl
jne 0x1ef4
movl $0xfffffffc, %eax # imm = 0xFFFFFFFC
xorpd %xmm0, %xmm0
cmpl $0x2, (%rdi)
jne 0x1ef0
movl 0x10(%rdi), %ecx
cmpl $0xa, %ecx
je 0x1ece
cmpl $0xb, %ecx
je 0x1ec3
cmpl $0xc, %ecx
jne 0x1ef0
movsd 0x18(%rdi), %xmm0
jmp 0x1eee
xorps %xmm0, %xmm0
cvtsi2sdq 0x18(%rdi), %xmm0
jmp 0x1eee
movsd 0x18(%rdi), %xmm1
unpcklps 0x43f6(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x43fe(%rip), %xmm1 # 0x62e0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
xorl %eax, %eax
movsd %xmm0, (%rsi)
retq
| /WaterJuice[P]JsonLib/lib/JsonLib/Source/JlDataModel.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 0x10b0
pushq %rax
callq 0x1030
movl $0x16, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
| /macressler[P]curl/tests/libtest/first.c |
main | int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour by the C library in order to test for undesired side
* effects that could cause in libcurl.
*/
#ifdef HAVE_SETLOCALE
setlocale(LC_ALL, "");
#endif
if(argc< 2) {
fprintf(stderr, "Pass URL as argument please\n");
return 1;
}
test_argc = argc;
test_argv = argv;
if(argc>2)
libtest_arg2 = argv[2];
if(argc>3)
libtest_arg3 = argv[3];
URL = argv[1]; /* provide this to the rest */
fprintf(stderr, "URL: %s\n", URL);
result = test(URL);
#ifdef USE_NSS
if(PR_Initialized())
/* prevent valgrind from reporting possibly lost memory (fd cache, ...) */
PR_Cleanup();
#endif
return result;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xae2(%rip), %rsi # 0x20d4
movl $0x6, %edi
callq 0x10a0
cmpl $0x1, %ebp
jg 0x1625
movq 0x29d0(%rip), %rax # 0x3fd8
movq (%rax), %rdi
leaq 0xac9(%rip), %rsi # 0x20db
xorl %eax, %eax
callq 0x10f0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %ebp, 0x2d11(%rip) # 0x433c
movq %rbx, 0x2d0e(%rip) # 0x4340
cmpl $0x2, %ebp
je 0x1642
movq 0x10(%rbx), %rax
movq %rax, 0x2a8e(%rip) # 0x40d0
cmpl $0x4, %ebp
jl 0x1652
movq 0x18(%rbx), %rax
movq %rax, 0x2a86(%rip) # 0x40d8
movq 0x8(%rbx), %rbx
movq 0x297b(%rip), %rax # 0x3fd8
movq (%rax), %rdi
leaq 0xa91(%rip), %rsi # 0x20f8
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x123c
| /macressler[P]curl/tests/libtest/first.c |
bsplib::TicToc::push(bsplib::TicToc::Category) | static unsigned push(Category c ) {
s_pos += s_pow * c;
s_pow *= N_CATEGORIES;
assert( s_pow < 1000000 );
if (s_timers.size() <= s_pos)
s_timers.resize( s_pos + 1);
return s_pos;
} | pushq %rbx
movl %edi, %eax
leaq 0xf92c(%rip), %rcx # 0x192d0
movl (%rcx), %edx
imull %edx, %eax
leaq 0xf978(%rip), %rbx # 0x19328
addl (%rbx), %eax
movl %eax, (%rbx)
leal (%rdx,%rdx,4), %edx
leal (%rdx,%rdx,2), %edx
movl %edx, (%rcx)
cmpl $0xf4240, %edx # imm = 0xF4240
jae 0x99f2
leaq 0xf945(%rip), %rcx # 0x19310
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x5, %rdx
movl %eax, %ecx
cmpq %rcx, %rdx
ja 0x99f0
incl %eax
leaq 0xf92a(%rip), %rdi # 0x19310
movq %rax, %rsi
callq 0x9a12
movl (%rbx), %eax
popq %rbx
retq
leaq 0x99a0(%rip), %rdi # 0x13399
leaq 0x99a9(%rip), %rsi # 0x133a9
leaq 0x9a03(%rip), %rcx # 0x1340a
movl $0x73, %edx
callq 0x61c0
nop
| /wijnand-suijlen[P]bsponmpi/src/tictoc.h |
void bsplib::serial<unsigned long>(bsplib::A2A&, int, unsigned long) | void serial( A2A & a2a, int pid, UInt x ) {
typedef UIntSerialize< UInt > S;
typename S::Buffer buf;
{ const int n = S::write(x, buf );
a2a.send( pid, buf, n );
}
} | subq $0x18, %rsp
xorl %ecx, %ecx
movq %rdx, %rax
movl %edx, %r8d
andb $0x7f, %r8b
shrq $0x7, %rax
cmpq $0x7f, %rdx
seta %r9b
shlb $0x7, %r9b
orb %r8b, %r9b
movb %r9b, 0xe(%rsp,%rcx)
incq %rcx
cmpq $0x7f, %rdx
movq %rax, %rdx
ja 0x9c4b
leaq 0xe(%rsp), %rdx
callq 0xa360
addq $0x18, %rsp
retq
nop
| /wijnand-suijlen[P]bsponmpi/src/a2a.h |
bsplib::Spmd::Spmd(int) | Spmd :: Spmd( int nprocs )
{
int mpi_init;
int world_pid = -1;
MPI_Initialized(&mpi_init);
assert( mpi_init );
MPI_Bcast( &nprocs, 1, MPI_INT, 0, MPI_COMM_WORLD );
MPI_Comm_rank( MPI_COMM_WORLD, & world_pid );
m_closed = false;
m_active = world_pid < nprocs;
MPI_Comm_split( MPI_COMM_WORLD, m_active, world_pid, &m_comm );
MPI_Comm_size( m_comm, &m_nprocs );
MPI_Comm_rank( m_comm, &m_pid );
#ifdef HAS_CLOCK_GETTIME
clock_gettime( CLOCK_MONOTONIC, &m_time );
#else
m_time = MPI_Wtime();
#endif
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %esi, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp) # imm = 0xFFFFFFFF
leaq 0x14(%rsp), %r14
movq %r14, %rdi
callq 0x6160
cmpl $0x0, (%r14)
je 0x9dd7
movq 0xf264(%rip), %rdx # 0x18fb8
movq 0xf225(%rip), %r14 # 0x18f80
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
movq %r14, %r8
callq 0x6080
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x63f0
movb $0x0, 0x8(%rbx)
movl (%r12), %edx
xorl %esi, %esi
cmpl (%r15), %edx
setl %sil
setl 0x9(%rbx)
movq %r14, %rdi
movq %rbx, %rcx
callq 0x6480
movq (%rbx), %rdi
leaq 0x24(%rbx), %rsi
callq 0x62f0
movq (%rbx), %rdi
leaq 0x20(%rbx), %rsi
callq 0x63f0
addq $0x10, %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x6290
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x980c(%rip), %rdi # 0x135ea
leaq 0x980e(%rip), %rsi # 0x135f3
leaq 0x9867(%rip), %rcx # 0x13653
movl $0xd, %edx
callq 0x61c0
| /wijnand-suijlen[P]bsponmpi/src/spmd.cc |
bsplib::A2A::send(int, void const*, unsigned long) | void * A2A::send( int dst_pid, const void * data, std::size_t size )
{
assert( dst_pid >= 0 );
assert( dst_pid < m_nprocs );
assert( m_send_cap == m_send_bufs.size() / m_nprocs );
std::size_t offset = m_send_sizes[ dst_pid ];
if ( m_send_cap < offset + size ) {
std::size_t new_cap =
std::max( 2 * m_send_cap , offset + size );
m_send_bufs.resize( m_nprocs * new_cap );
for ( int p = m_nprocs; p > 0; --p ) {
std::size_t displ = new_cap - m_send_cap;
for ( size_t i = p*new_cap; i > (p-1)*new_cap; --i) {
m_send_bufs[i-1] = m_send_bufs[i-displ*(p-1)-1];
}
}
m_send_cap = new_cap;
}
m_send_sizes[ dst_pid ] += size;
void * send_buf = m_send_bufs.data() + dst_pid * m_send_cap + offset;
std::memcpy( send_buf , data, size );
return send_buf;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0xa47b
movq %rcx, %rbx
movl %esi, %ecx
movq %rdi, %r15
movl 0x8(%rdi), %esi
cmpl %ecx, %esi
jle 0xa49a
movq %rdx, %r8
movq 0x20(%r15), %r14
movq 0xa8(%r15), %rdi
movq 0xb0(%r15), %rax
subq %rdi, %rax
xorl %edx, %edx
divq %rsi
cmpq %rax, %r14
jne 0xa4b9
movl %ecx, %r13d
movq 0x78(%r15), %rcx
movq (%rcx,%r13,8), %rbp
leaq (%rbx,%rbp), %rax
cmpq %rax, %r14
jae 0xa453
movq %r8, (%rsp)
leaq 0xa8(%r15), %r12
addq %r14, %r14
cmpq %rax, %r14
cmovbeq %rax, %r14
imulq %r14, %rsi
movq %r12, %rdi
callq 0xaeba
movslq 0x8(%r15), %rax
testq %rax, %rax
jle 0xa439
leaq -0x1(%rax), %rcx
movq %rax, %rdx
movq %r14, %rsi
imulq %rax, %rsi
decq %rax
movq %r14, %rdi
imulq %rax, %rdi
cmpq %rdi, %rsi
jbe 0xa430
movq 0x20(%r15), %r8
subq %r14, %r8
imulq %rcx, %r8
movq (%r12), %r9
leaq (%r9,%rsi), %r10
movb -0x1(%r8,%r10), %r10b
movb %r10b, -0x1(%r9,%rsi)
decq %rsi
cmpq %rdi, %rsi
ja 0xa416
decq %rcx
cmpq $0x1, %rdx
jg 0xa3f2
movq %r14, 0x20(%r15)
movq 0x78(%r15), %rcx
movq 0xa8(%r15), %rdi
movq (%rcx,%r13,8), %rax
addq %rbx, %rax
movq (%rsp), %r8
movq %rax, (%rcx,%r13,8)
imulq 0x20(%r15), %r13
addq %rbp, %rdi
addq %r13, %rdi
movq %r8, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6250
leaq 0x9220(%rip), %rdi # 0x136a2
leaq 0x9226(%rip), %rsi # 0x136af
leaq 0x927e(%rip), %rcx # 0x1370e
movl $0x47, %edx
callq 0x61c0
leaq 0x92a5(%rip), %rdi # 0x13746
leaq 0x9207(%rip), %rsi # 0x136af
leaq 0x925f(%rip), %rcx # 0x1370e
movl $0x48, %edx
callq 0x61c0
leaq 0x9299(%rip), %rdi # 0x13759
leaq 0x91e8(%rip), %rsi # 0x136af
leaq 0x9240(%rip), %rcx # 0x1370e
movl $0x4a, %edx
callq 0x61c0
| /wijnand-suijlen[P]bsponmpi/src/a2a.cc |
bsplib::A2A::exchange() | void A2A::exchange( )
{
std::size_t max_recv = 0, max_bruck_vol = 0;
std::size_t new_cap = m_send_cap;
{
#ifdef PROFILE
TicToc t( TicToc::MPI_META_A2A, 4*sizeof(std::size_t)*m_nprocs );
#endif
// exchange data sizes.
MPI_Alltoall( m_send_sizes.data(), sizeof(std::size_t), MPI_BYTE,
m_recv_sizes.data(), sizeof(std::size_t), MPI_BYTE,
m_comm );
// determine ideal nr of bytes to send over MPI_Alltoall
m_lincost.reset( m_nprocs );
for ( int i = 0; i < m_nprocs; ++i )
if ( m_send_sizes[i] > 0 )
m_lincost.send( m_send_sizes[i]);
std::size_t pref_bruck_vol = m_lincost.get_bruck_vol();
m_lincost.reset( m_nprocs );
for ( int i = 0; i < m_nprocs; ++i )
if ( m_recv_sizes[i] > 0 )
m_lincost.send( m_recv_sizes[i]);
// Determine max communication sizes
pref_bruck_vol =
std::max( pref_bruck_vol, m_lincost.get_bruck_vol() );
std::size_t max_send = *std::max_element( m_send_sizes.begin(),
m_send_sizes.begin() + m_nprocs );
std::size_t global_comm_send[3] =
{ m_send_cap, max_send, pref_bruck_vol };
std::size_t global_comm_recv[3];
MPI_Allreduce( global_comm_send, global_comm_recv,
3, MY_MPI_SIZE_T, MPI_MAX, m_comm );
new_cap = global_comm_recv[0];
max_recv = global_comm_recv[1];
max_bruck_vol = global_comm_recv[2];
}
// Ensure correct size memory of recv buffers
if ( m_method == RMA &&
new_cap != m_recv_cap && m_recv_win != MPI_WIN_NULL )
MPI_Win_free( &m_recv_win );
m_recv_bufs.resize( new_cap * m_nprocs );
if ( m_method == RMA && new_cap != m_recv_cap ) {
MPI_Win_create( m_recv_bufs.data(),
new_cap * m_nprocs, 1,
MPI_INFO_NULL, m_comm, &m_recv_win );
}
m_recv_cap = new_cap;
assert( m_recv_cap >= max_recv );
if ( max_recv == 0 ) {
/* no need to do anything */
clear();
}
else {
std::size_t sm = std::min( max_bruck_vol, m_small_a2a_size_per_proc ) ;
{
#ifdef PROFILE
TicToc t( TicToc::MPI_SMALL_A2A );
#endif
for (int p = 0; p < m_nprocs; ++p ) {
std::size_t size = std::min( sm, m_send_sizes[p]);
memcpy( m_small_send_buf.data() + p * sm,
m_send_bufs.data() + p * m_send_cap,
size);
#ifdef PROFILE
t.add_bytes( sm );
#endif
}
// In small exchanges, Bruck's algorithm will be used again
MPI_Alltoall( m_small_send_buf.data(), int(sm), MPI_BYTE,
m_small_recv_buf.data(), int(sm), MPI_BYTE,
m_comm );
for (int p = 0; p < m_nprocs; ++p ) {
std::size_t size = std::min( sm, m_recv_sizes[p]);
memcpy( m_recv_bufs.data() + p * m_recv_cap,
m_small_recv_buf.data() + p * sm,
size );
}
} // end plain all-to-all
// start normal message exchange
if ( m_method == RMA) {
#ifdef PROFILE
TicToc t( TicToc::MPI_PUT );
#endif
assert( m_recv_cap > 0 );
assert( m_recv_win != MPI_WIN_NULL );
MPI_Win_fence( 0, m_recv_win );
for (int p = 0; p < m_nprocs; ++p ) {
std::size_t o = std::min( sm, m_send_sizes[p] );
std::size_t size = m_send_sizes[p] - o;
std::size_t o1 = m_send_cap * p + o;
std::size_t o2 = m_recv_cap * m_pid + o;
#ifdef PROFILE
t.add_bytes( size );
#endif
while ( size > 0 ) {
std::size_t s = std::min( m_max_msg_size, size );
//size_t s = size;
MPI_Put( m_send_bufs.data() + o1, int(s), MPI_BYTE,
p, o2, int(s), MPI_BYTE, m_recv_win );
size -= s;
o1 += s;
o2 += s;
}
}
MPI_Win_fence( 0, m_recv_win );
} else if ( m_method == MSG ) {
#ifdef PROFILE
TicToc tr( TicToc::MPI_LARGE_RECV );
TicToc ts( TicToc::MPI_LARGE_SEND );
#endif
for ( int p = 0 ; p < m_nprocs; ++p ) {
std::size_t so = std::min( sm, m_send_sizes[p] );
std::size_t ro = std::min( sm, m_recv_sizes[p] );
m_send_sizes[p] -= so;
m_send_pos[p] = p * m_send_cap + so;
m_recv_sizes[p] -= ro;
m_recv_pos[p] = p * m_recv_cap + ro;
}
// Do a personalized exchange
int outcount = MPI_UNDEFINED;
bool first_time = true;
do {
for (int p = 0; p < m_nprocs; ++p ) {
if (m_reqs[p] != MPI_REQUEST_NULL) continue;
std::size_t recv_size
= std::min( m_max_msg_size, m_recv_sizes[p] );
#ifdef PROFILE
tr.add_bytes( recv_size );
#endif
int tag = 0;
if (recv_size > 0 )
MPI_Irecv( m_recv_bufs.data() + m_recv_pos[p],
int( recv_size ), MPI_BYTE, p,
tag, m_comm, & m_reqs[p] );
m_recv_sizes[p] -= recv_size;
m_recv_pos[p] += recv_size;
}
if (first_time)
MPI_Barrier( m_comm ); // Using the barrier the first time
// allows to use ready sends
for (int p = 0; p < m_nprocs; ++p ) {
if (m_reqs[m_nprocs + p] != MPI_REQUEST_NULL) continue;
std::size_t send_size
= std::min( m_max_msg_size, m_send_sizes[p] );
#ifdef PROFILE
ts.add_bytes( send_size );
#endif
int tag = 0;
if (send_size > 0 ) {
if (first_time)
MPI_Irsend( m_send_bufs.data() + m_send_pos[p],
int( send_size ), MPI_BYTE, p,
tag, m_comm, & m_reqs[m_nprocs + p ] );
else
MPI_Isend( m_send_bufs.data() + m_send_pos[p],
int( send_size ), MPI_BYTE, p,
tag, m_comm, & m_reqs[m_nprocs + p ] );
}
m_send_sizes[p] -= send_size;
m_send_pos[p] += send_size;
}
first_time = false;
MPI_Waitsome( int( m_reqs.size() ), m_reqs.data(), &outcount,
m_ready.data(), MPI_STATUSES_IGNORE );
} while (outcount != MPI_UNDEFINED );
for (int p = 0 ; p < m_nprocs; ++p ) {
assert( m_recv_sizes[p] == 0 );
assert( m_send_sizes[p] == 0 );
assert( m_reqs[p] == MPI_REQUEST_NULL );
assert( m_reqs[m_nprocs+p] == MPI_REQUEST_NULL );
m_recv_sizes[p] = m_recv_pos[p] - p * m_recv_cap;
}
} // end of plain message exchange
} // end of else
m_send_cap = m_recv_cap;
m_send_bufs.resize( m_nprocs * m_send_cap );
for (int p = 0 ; p < m_nprocs; ++p ) {
m_send_sizes[p] = 0;
m_send_pos[p] = 0;
m_recv_pos[p] = 0;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movslq 0x8(%rdi), %r15
shlq $0x5, %r15
movl $0x8, %edi
callq 0x999a
movl %eax, 0x10(%rsp)
leaq 0x30(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x6290
movaps (%r14), %xmm0
movups %xmm0, 0x18(%rsp)
movq %r15, 0x28(%rsp)
movq 0x78(%rbx), %rdi
movq 0xc0(%rbx), %rcx
movq 0x138(%rbx), %rax
movq %rax, (%rsp)
movq 0xe9e2(%rip), %rdx # 0x18f60
movl $0x8, %esi
movl $0x8, %r8d
movq %rdx, %r9
callq 0x6150
leaq 0x30(%rbx), %r14
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x10968
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0xa5f5
leaq 0x48(%rbx), %r15
xorl %r13d, %r13d
leaq 0x30(%rsp), %r12
movq 0x78(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
testq %rcx, %rcx
je 0xa5ea
movq %rcx, 0x30(%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0xa5dc
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x50(%rbx)
jmp 0xa5ea
movq %r15, %rdi
movq %r12, %rdx
callq 0xaf7e
movl 0x8(%rbx), %eax
incq %r13
movslq %eax, %rcx
cmpq %rcx, %r13
jl 0xa5b3
movq %r14, %rdi
callq 0x109f0
movq %rax, %r15
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x10968
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0xa662
leaq 0x48(%rbx), %r12
xorl %ebp, %ebp
leaq 0x30(%rsp), %r13
movq 0xc0(%rbx), %rcx
movq (%rcx,%rbp,8), %rcx
testq %rcx, %rcx
je 0xa657
movq %rcx, 0x30(%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0xa649
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x50(%rbx)
jmp 0xa657
movq %r12, %rdi
movq %r13, %rdx
callq 0xaf7e
movl 0x8(%rbx), %eax
incq %rbp
movslq %eax, %rcx
cmpq %rcx, %rbp
jl 0xa61d
movq %r14, %rdi
callq 0x109f0
cmpq %rax, %r15
cmovaq %r15, %rax
movq 0x78(%rbx), %rcx
movslq 0x8(%rbx), %rdx
cmpq $0x2, %rdx
jb 0xa6a6
shlq $0x3, %rdx
leaq 0x8(%rcx), %rsi
movq (%rcx), %rdi
addq $-0x8, %rdx
movq (%rsi), %r8
cmpq %r8, %rdi
cmovbeq %r8, %rdi
cmovbq %rsi, %rcx
addq $0x8, %rsi
addq $-0x8, %rdx
jne 0xa68e
movq (%rcx), %rcx
movq 0x20(%rbx), %rdx
leaq 0x30(%rsp), %rdi
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq 0x138(%rbx), %r9
movq 0xe8fd(%rip), %rcx # 0x18fc8
movq 0xe8b6(%rip), %r8 # 0x18f88
leaq 0x50(%rsp), %rsi
movl $0x3, %edx
callq 0x6350
movq 0x50(%rsp), %r15
movq 0x58(%rsp), %r14
movq 0x60(%rsp), %rbp
leaq 0x10(%rsp), %rdi
callq 0x9628
cmpl $0x0, (%rbx)
jne 0xa721
cmpq 0x28(%rbx), %r15
je 0xa721
movq 0x140(%rbx), %rax
cmpq 0xe85d(%rip), %rax # 0x18f70
je 0xa721
leaq 0x140(%rbx), %rdi
callq 0x6090
leaq 0xf0(%rbx), %rdi
movslq 0x8(%rbx), %rsi
imulq %r15, %rsi
callq 0xaeba
cmpl $0x0, (%rbx)
jne 0xa76e
cmpq 0x28(%rbx), %r15
je 0xa76e
movslq 0x8(%rbx), %rsi
imulq %r15, %rsi
movq 0xf0(%rbx), %rdi
movq 0x138(%rbx), %r8
leaq 0x140(%rbx), %r9
movq 0xe874(%rip), %rcx # 0x18fd8
movl $0x1, %edx
callq 0x6050
movq %r15, 0x28(%rbx)
cmpq %r14, %r15
jb 0xadf0
testq %r14, %r14
je 0xabb1
movq 0x18(%rbx), %rax
cmpq %rbp, %rax
cmovbq %rax, %rbp
movl $0x9, %edi
callq 0x999a
movl %eax, 0x10(%rsp)
leaq 0x30(%rsp), %r15
movl $0x1, %edi
movq %r15, %rsi
callq 0x6290
movaps (%r15), %xmm0
movups %xmm0, 0x18(%rsp)
movq $0x0, 0x28(%rsp)
cmpl $0x0, 0x8(%rbx)
jle 0xa80e
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x78(%rbx), %rax
movq (%rax,%r15,8), %rdx
cmpq %rbp, %rdx
cmovaeq %rbp, %rdx
movq 0x108(%rbx), %rdi
addq %r14, %rdi
movq 0x20(%rbx), %rsi
imulq %r15, %rsi
addq 0xa8(%rbx), %rsi
callq 0x6250
addq %rbp, 0x28(%rsp)
incq %r15
movslq 0x8(%rbx), %rax
addq %rbp, %r14
cmpq %rax, %r15
jl 0xa7cd
movq 0x108(%rbx), %rdi
movq 0x120(%rbx), %rcx
movq 0x138(%rbx), %rax
movq %rax, (%rsp)
movq 0xe732(%rip), %rdx # 0x18f60
movl %ebp, %esi
movl %ebp, %r8d
movq %rdx, %r9
callq 0x6150
cmpl $0x0, 0x8(%rbx)
jle 0xa886
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0xc0(%rbx), %rax
movq (%rax,%r15,8), %rdx
cmpq %rbp, %rdx
cmovaeq %rbp, %rdx
movq 0x28(%rbx), %rdi
imulq %r15, %rdi
addq 0xf0(%rbx), %rdi
movq 0x120(%rbx), %rsi
addq %r14, %rsi
callq 0x6250
incq %r15
movslq 0x8(%rbx), %rax
addq %rbp, %r14
cmpq %rax, %r15
jl 0xa847
leaq 0x10(%rsp), %rdi
callq 0x9628
movl (%rbx), %eax
testl %eax, %eax
je 0xabfa
cmpl $0x1, %eax
jne 0xad15
movl $0xa, %edi
callq 0x999a
movl %eax, 0x10(%rsp)
leaq 0x30(%rsp), %r15
movl $0x1, %edi
movq %r15, %rsi
callq 0x6290
movaps (%r15), %xmm0
movups %xmm0, 0x18(%rsp)
movq $0x0, 0x28(%rsp)
movl $0xb, %edi
callq 0x999a
movl %eax, 0x30(%rsp)
leaq 0x50(%rsp), %r15
movl $0x1, %edi
movq %r15, %rsi
callq 0x6290
movaps (%r15), %xmm0
movups %xmm0, 0x38(%rsp)
movq $0x0, 0x48(%rsp)
movslq 0x8(%rbx), %rax
testq %rax, %rax
jle 0xa976
movq 0x78(%rbx), %rcx
movq 0x90(%rbx), %rdx
movq 0xc0(%rbx), %rsi
movq 0xd8(%rbx), %rdi
xorl %r8d, %r8d
movq (%rcx,%r8,8), %r9
cmpq %rbp, %r9
movq %rbp, %r10
cmovbq %r9, %r10
movq (%rsi,%r8,8), %r11
cmpq %rbp, %r11
cmovaeq %rbp, %r11
subq %r10, %r9
movq %r9, (%rcx,%r8,8)
movq 0x20(%rbx), %r9
imulq %r8, %r9
addq %r10, %r9
movq %r9, (%rdx,%r8,8)
subq %r11, (%rsi,%r8,8)
movq 0x28(%rbx), %r9
imulq %r8, %r9
addq %r11, %r9
movq %r9, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0xa92c
leaq 0x50(%rsp), %rax
movl $0xffff8002, (%rax) # imm = 0xFFFF8002
movb $0x1, %r14b
movq 0xe645(%rip), %rbp # 0x18fd0
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0xaa2a
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x148(%rbx), %rcx
cmpq %rbp, (%rcx,%r15)
jne 0xaa17
movq 0x10(%rbx), %r13
movq 0xc0(%rbx), %rsi
movq (%rsi,%r15), %rdx
cmpq %r13, %rdx
cmovbq %rdx, %r13
addq %r13, 0x28(%rsp)
movq 0xd8(%rbx), %rdx
testq %r13, %r13
je 0xaa0f
addq %r15, %rcx
movq 0xf0(%rbx), %rdi
movq 0x138(%rbx), %r9
addq (%rdx,%r15), %rdi
movq %rcx, (%rsp)
movl %r13d, %esi
movq 0xe56d(%rip), %rdx # 0x18f60
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x63d0
movq 0xc0(%rbx), %rsi
movq 0xd8(%rbx), %rdx
movl 0x8(%rbx), %eax
subq %r13, (%rsi,%r15)
addq %r13, (%rdx,%r15)
incq %r12
movslq %eax, %rcx
addq $0x8, %r15
cmpq %rcx, %r12
jl 0xa99c
testb $0x1, %r14b
je 0xaa3f
movq 0x138(%rbx), %rdi
callq 0x6210
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0xaafa
xorl %r12d, %r12d
movslq %eax, %rcx
addq %r12, %rcx
movq 0x148(%rbx), %rdx
cmpq %rbp, (%rdx,%rcx,8)
jne 0xaaeb
movq 0x10(%rbx), %r13
movq 0x78(%rbx), %rax
movq (%rax,%r12,8), %rax
cmpq %r13, %rax
cmovbq %rax, %r13
addq %r13, 0x48(%rsp)
testq %r13, %r13
je 0xaad5
leaq (%rdx,%rcx,8), %rax
movq 0x90(%rbx), %rcx
movq 0xa8(%rbx), %rdi
addq (%rcx,%r12,8), %rdi
movq 0x138(%rbx), %r9
testb $0x1, %r14b
je 0xaabc
movq %rax, (%rsp)
movl %r13d, %esi
movq 0xe4b1(%rip), %rdx # 0x18f60
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x6070
jmp 0xaad5
movq %rax, (%rsp)
movl %r13d, %esi
movq 0xe496(%rip), %rdx # 0x18f60
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x6100
movq 0x78(%rbx), %rax
subq %r13, (%rax,%r12,8)
movq 0x90(%rbx), %rax
addq %r13, (%rax,%r12,8)
movl 0x8(%rbx), %eax
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0xaa4a
movq 0x148(%rbx), %rsi
movq 0x150(%rbx), %rdi
subq %rsi, %rdi
shrq $0x3, %rdi
movq 0x160(%rbx), %rcx
leaq 0x50(%rsp), %rdx
xorl %r8d, %r8d
callq 0x62a0
xorl %r14d, %r14d
cmpl $0xffff8002, 0x50(%rsp) # imm = 0xFFFF8002
jne 0xa98b
movslq 0x8(%rbx), %rax
testq %rax, %rax
jle 0xaba2
movq 0x78(%rbx), %rcx
movq 0xc0(%rbx), %rdx
movq 0x148(%rbx), %rsi
movq 0xd8(%rbx), %rdi
leaq (%rsi,%rax,8), %r8
xorl %r9d, %r9d
cmpq $0x0, (%rdx,%r9,8)
jne 0xadd1
cmpq $0x0, (%rcx,%r9,8)
jne 0xadb2
cmpq %rbp, (%rsi,%r9,8)
jne 0xad93
cmpq %rbp, (%r8,%r9,8)
jne 0xad74
movq (%rdi,%r9,8), %r10
movq 0x28(%rbx), %r11
imulq %r9, %r11
subq %r11, %r10
movq %r10, (%rdx,%r9,8)
incq %r9
cmpq %r9, %rax
jne 0xab5d
leaq 0x30(%rsp), %rdi
callq 0x9628
jmp 0xad0b
movslq 0x8(%rbx), %rax
testq %rax, %rax
jle 0xad15
movq 0xc0(%rbx), %rcx
movq 0x78(%rbx), %rdx
movq 0x90(%rbx), %rsi
movq 0xd8(%rbx), %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
movq %r8, (%rcx,%r9,8)
movq %r8, (%rdx,%r9,8)
movq %r8, (%rdi,%r9,8)
movq %r8, (%rsi,%r9,8)
incq %r9
cmpq %r9, %rax
jne 0xabdd
jmp 0xad15
movl $0xc, %edi
callq 0x999a
movl %eax, 0x10(%rsp)
leaq 0x30(%rsp), %r12
movl $0x1, %edi
movq %r12, %rsi
callq 0x6290
movaps (%r12), %xmm0
movups %xmm0, 0x18(%rsp)
movq $0x0, 0x28(%rsp)
cmpq $0x0, 0x28(%rbx)
je 0xae0f
movq 0x140(%rbx), %rsi
cmpq 0xe32a(%rip), %rsi # 0x18f70
je 0xae2e
xorl %edi, %edi
callq 0x64f0
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0xacfd
xorl %r12d, %r12d
movq %rbp, 0x70(%rsp)
movq 0x78(%rbx), %rcx
movq (%rcx,%r12,8), %r14
cmpq %rbp, %r14
movq %rbp, %rcx
cmovbq %r14, %rcx
subq %rcx, %r14
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %r13
movslq 0x4(%rbx), %rdx
addq %r14, 0x28(%rsp)
testq %r14, %r14
je 0xacee
imulq %rdx, %r13
addq %rcx, %r13
imulq %r12, %r15
addq %rcx, %r15
movq 0x10(%rbx), %rbp
movq 0x140(%rbx), %rax
cmpq %rbp, %r14
cmovbq %r14, %rbp
movq 0xa8(%rbx), %rdi
addq %r15, %rdi
movq %rax, 0x8(%rsp)
movq 0xe299(%rip), %rdx # 0x18f60
movq %rdx, (%rsp)
movl %ebp, %esi
movl %r12d, %ecx
movq %r13, %r8
movl %ebp, %r9d
callq 0x6370
addq %rbp, %r15
addq %rbp, %r13
subq %rbp, %r14
jne 0xac9f
movl 0x8(%rbx), %eax
movq 0x70(%rsp), %rbp
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0xac66
movq 0x140(%rbx), %rsi
xorl %edi, %edi
callq 0x64f0
leaq 0x10(%rsp), %rdi
callq 0x9628
movq 0x28(%rbx), %rax
movq %rax, 0x20(%rbx)
leaq 0xa8(%rbx), %rdi
movslq 0x8(%rbx), %rsi
imulq %rax, %rsi
callq 0xaeba
movslq 0x8(%rbx), %rax
testq %rax, %rax
jle 0xad65
movq 0x78(%rbx), %rcx
movq 0x90(%rbx), %rdx
movq 0xd8(%rbx), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movq %rdi, (%rcx,%r8,8)
movq %rdi, (%rdx,%r8,8)
movq %rdi, (%rsi,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0xad51
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8ab0(%rip), %rdi # 0x1382b
leaq 0x892d(%rip), %rsi # 0x136af
leaq 0x8a13(%rip), %rcx # 0x1379c
movl $0x137, %edx # imm = 0x137
callq 0x61c0
leaq 0x8a73(%rip), %rdi # 0x1380d
leaq 0x890e(%rip), %rsi # 0x136af
leaq 0x89f4(%rip), %rcx # 0x1379c
movl $0x136, %edx # imm = 0x136
callq 0x61c0
leaq 0x8a3f(%rip), %rdi # 0x137f8
leaq 0x88ef(%rip), %rsi # 0x136af
leaq 0x89d5(%rip), %rcx # 0x1379c
movl $0x135, %edx # imm = 0x135
callq 0x61c0
leaq 0x8a0b(%rip), %rdi # 0x137e3
leaq 0x88d0(%rip), %rsi # 0x136af
leaq 0x89b6(%rip), %rcx # 0x1379c
movl $0x134, %edx # imm = 0x134
callq 0x61c0
leaq 0x898e(%rip), %rdi # 0x13785
leaq 0x88b1(%rip), %rsi # 0x136af
leaq 0x8997(%rip), %rcx # 0x1379c
movl $0xa8, %edx
callq 0x61c0
leaq 0x89a3(%rip), %rdi # 0x137b9
leaq 0x8892(%rip), %rsi # 0x136af
leaq 0x8978(%rip), %rcx # 0x1379c
movl $0xce, %edx
callq 0x61c0
leaq 0x8993(%rip), %rdi # 0x137c8
leaq 0x8873(%rip), %rsi # 0x136af
leaq 0x8959(%rip), %rcx # 0x1379c
movl $0xcf, %edx
callq 0x61c0
jmp 0xae72
jmp 0xae72
jmp 0xae72
jmp 0xae72
jmp 0xae72
jmp 0xae72
jmp 0xae72
jmp 0xae72
jmp 0xae72
jmp 0xae63
jmp 0xae63
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x9628
jmp 0xae75
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9628
movq %rbx, %rdi
callq 0x6520
nop
| /wijnand-suijlen[P]bsponmpi/src/a2a.cc |
bsplib::Unbuf::Unbuf(unsigned long, ompi_communicator_t*) | Unbuf::Unbuf( size_t max_msg_size, MPI_Comm comm)
: m_pid(-1), m_nprocs(-1)
, m_comm(MPI_COMM_NULL)
, m_max_msg_size( max_msg_size )
{
MPI_Comm_dup( comm, &m_comm );
MPI_Comm_size( m_comm, &m_nprocs );
MPI_Comm_rank( m_comm, &m_pid );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq $-0x1, (%rdi)
leaq 0x8(%rdi), %r13
movq 0xd6de(%rip), %rax # 0x18fb0
movq %rax, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x30(%rdi), %r15
leaq 0x48(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movq %rdx, %rdi
movq %r13, %rsi
callq 0x63c0
leaq 0x4(%rbx), %rsi
movq (%r13), %rdi
callq 0x62f0
movq 0x8(%rbx), %rdi
movq %rbx, %rsi
callq 0x63f0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r13
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xb947
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x62c0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x675b
movq %r13, %rdi
callq 0x6520
| /wijnand-suijlen[P]bsponmpi/src/unbuf.cc |
bsplib::Rdma::get(int, unsigned long, unsigned long, void*, unsigned long) | void Rdma::get( int src_pid, Memslot src_slot, size_t src_offset,
void * dst, size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::GET );
#endif
assert( !( slot( m_pid, src_slot ).status & Memblock::PUSHED) );
Memslot dst_slot = m_local_slots.size();
m_local_slots.push_back( dst );
Action action = { Action::GET, src_pid, src_pid, m_pid,
0, src_slot, dst_slot, src_offset, size };
m_send_actions.push_back( action );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, (%rsp)
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movq %r8, 0x8(%rsp)
movl $0x4, %edi
callq 0x999a
movl %eax, 0x10(%rsp)
leaq 0x30(%rsp), %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x6290
movaps (%rbx), %xmm0
movups %xmm0, 0x18(%rsp)
movq $0x0, 0x28(%rsp)
movslq 0x2f4(%r14), %rax
imulq %r12, %rax
leaq (%rax,%rax,2), %rcx
shlq $0x3, %rcx
addq 0x338(%r14), %rcx
movslq 0x2f0(%r14), %rax
leaq (%rax,%rax,2), %rdx
testb $0x1, 0x10(%rcx,%rdx,8)
jne 0xccd8
movq 0x378(%r14), %rsi
movq %rsi, %rbx
subq 0x370(%r14), %rbx
cmpq 0x380(%r14), %rsi
je 0xcc6b
movq %r13, (%rsi)
addq $0x8, 0x378(%r14)
jmp 0xcc83
leaq 0x370(%r14), %rdi
leaq 0x8(%rsp), %rdx
callq 0xf420
movl 0x2f0(%r14), %eax
sarq $0x3, %rbx
xorl %ecx, %ecx
leaq 0x30(%rsp), %rsi
movl %ecx, (%rsi)
movl %ebp, 0x4(%rsi)
movl %ebp, 0x8(%rsi)
movl %eax, 0xc(%rsi)
movl %ecx, 0x10(%rsi)
movq %r12, 0x18(%rsi)
movq %rbx, 0x20(%rsi)
movq %r15, 0x28(%rsi)
movq (%rsp), %rax
movq %rax, 0x30(%rsi)
addq $0x388, %r14 # imm = 0x388
movq %r14, %rdi
callq 0xe740
leaq 0x10(%rsp), %rdi
callq 0x9628
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6d42(%rip), %rdi # 0x13a21
leaq 0x6bf9(%rip), %rsi # 0x138df
leaq 0x6d6a(%rip), %rcx # 0x13a57
movl $0x7a, %edx
callq 0x61c0
jmp 0xccf9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9628
movq %rbx, %rdi
callq 0x6520
| /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
runOneSimulation(QTable const&, PlanningUnitDecPOMDPDiscrete const*, SimulationDecPOMDPDiscrete const&) | double runOneSimulation( const QTable & q,
const PlanningUnitDecPOMDPDiscrete *np,
const SimulationDecPOMDPDiscrete &sim
)
{
AgentMDP agent(np, 0, q);
AgentFullyObservable *newAgent;
vector<AgentFullyObservable*> agents;
for(Index i=0; i < np->GetNrAgents(); i++)
{
newAgent=new AgentMDP(agent);
newAgent->SetIndex(i);
agents.push_back(newAgent);
}
SimulationResult result=sim.RunSimulations(agents);
double avgReward=result.GetAvgReward();
for(Index i=0; i < np->GetNrAgents(); i++)
delete agents[i];
return(avgReward);
} | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x118(%rsp), %rsi
movq 0x120(%rsp), %rcx
leaq 0xb8(%rsp), %rdi
xorl %edx, %edx
callq 0x61d0
leaq 0x98(%rsp), %rdi
callq 0x8640
movl $0x0, 0x94(%rsp)
movl 0x94(%rsp), %eax
movq %rax, 0x30(%rsp)
movq 0x118(%rsp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq %rax, 0x38(%rsp)
jmp 0x728a
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq %rcx, %rax
jae 0x7367
movl $0x58, %edi
callq 0x6100
movq %rax, 0x28(%rsp)
jmp 0x72ae
movq 0x28(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x6050
jmp 0x72c2
movq 0x28(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %rax, %rdi
addq %rcx, %rdi
movl 0x94(%rsp), %esi
movq (%rax,%rcx), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x72f7
leaq 0x98(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x8650
jmp 0x730e
jmp 0x7310
movl 0x94(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0x7266
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x7470
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
movl $0x58, %esi
callq 0x60c0
jmp 0x7470
movq 0x110(%rsp), %rsi
leaq 0x50(%rsp), %rdi
leaq 0x98(%rsp), %rdx
callq 0x86c0
jmp 0x7383
leaq 0x50(%rsp), %rdi
callq 0x8dd0
vmovsd %xmm0, 0x20(%rsp)
jmp 0x7395
vmovsd 0x20(%rsp), %xmm0
vmovsd %xmm0, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq %rax, 0x10(%rsp)
movq 0x118(%rsp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq %rax, 0x18(%rsp)
jmp 0x73ca
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x7434
movl 0x44(%rsp), %eax
movl %eax, %esi
leaq 0x98(%rsp), %rdi
callq 0x8de0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x7405
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x7407
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x73a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x60e0
jmp 0x7470
vmovsd 0x48(%rsp), %xmm0
vmovsd %xmm0, (%rsp)
leaq 0x50(%rsp), %rdi
callq 0x60e0
leaq 0x98(%rsp), %rdi
callq 0x8e00
leaq 0xb8(%rsp), %rdi
callq 0x6130
vmovsd (%rsp), %xmm0
addq $0x128, %rsp # imm = 0x128
retq
leaq 0x98(%rsp), %rdi
callq 0x8e00
leaq 0xb8(%rsp), %rdi
callq 0x6130
movq 0x88(%rsp), %rdi
callq 0x6280
nopw (%rax,%rax)
| /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/solvers/MMDP_Solver.cpp |
main | int main(int argc, char **argv)
{
ArgumentHandlers::Arguments args;
argp_parse (&ArgumentHandlers::theArgpStruc, argc, argv, 0, 0, &args);
try
{
Timing Time;
cout << "Instantiating the problem..."<<endl;
DecPOMDPDiscreteInterface* decpomdp = GetDecPOMDPDiscreteInterfaceFromArgs(args);
cout << "...done."<<endl;
//construct MMDP_Solver
PlanningUnitDecPOMDPDiscrete *np = new NullPlanner(args.horizon, decpomdp);
MDPSolver *mdpSolver=NULL;
string methodName;
switch (args.mmdp_method)
{
case ArgumentHandlers::ValueIteration:
mdpSolver=new MDPValueIteration(*np);
methodName="MMDP_Solver_VI";
cout << "Running value iteration..."<<endl;
break;
case ArgumentHandlers::PolicyIteration:
mdpSolver=new MDPPolicyIteration(*np);
cout << "Running policy iteration..."<<endl;
methodName="MMDP_Solver_PI";
break;
case ArgumentHandlers::PolicyIterationGPU:
#if HAVE_CUDA_CUSOLVERDN_H
mdpSolver=new MDPPolicyIterationGPU(*np);
cout << "Running GPU supported policy iteration..."<<endl;
methodName="MMDP_Solver_PIgpu";
#else
cerr<<"No 'MDPPolicyIterationGPU' available. Install cuda, reconfigure and recompile."<<endl;
exit(1);
#endif
break;
default:
cerr<<"Unkown mmdp_method"<<endl;
exit(1);
}
//set up output files
string filename="/dev/null", timingsFilename="/dev/null";
if(!args.dryrun)
{
stringstream ss;
ss << directories::MADPGetResultsFilename(methodName, *decpomdp, args)
<< "_h" << args.horizon;
filename=ss.str();
timingsFilename=filename + "_Timings";
if(!file_exists(filename))
{
cout << "MMDP_Solver: could not open " << filename <<endl;
cout << "Results will not be stored to disk." <<endl;
args.dryrun = true;
}
}
//start planning
Time.Start("Plan");
mdpSolver->Plan(); // calls PlanSlow() on MDPPolicyIteration and MDPPolicyIterationGPU objects
Time.Stop("Plan");
cout << "...done."<<endl;
QTable q = mdpSolver->GetQTable(0); //<- infinite horizon, so get 1 value function of stage 0
int nrRuns = args.nrRuns; //defaults to 1000, see argumentHandlers.h
int seed = args.randomSeed; //defaults to 42
cout << "Simulating policy with nrRuns: " << nrRuns << " and seed: " << seed <<endl;
SimulationDecPOMDPDiscrete sim(*np, nrRuns, seed);
//write intermediate simulation results to file
if(!args.dryrun)
sim.SaveIntermediateResults(filename);
vector<double> avgRewards;
double r = runOneSimulation(q, np, sim);
cout << "...done"<<endl;
avgRewards.push_back(r);
cout << "Avg rewards: " << SoftPrintVector(avgRewards) << endl;
//write MDPSOLVER timing information to file
if(!args.dryrun)
Time.Save(timingsFilename);
}
catch(E& e){ e.Print(); }
return(0);
} | subq $0x758, %rsp # imm = 0x758
movl $0x0, 0x754(%rsp)
movl %edi, 0x750(%rsp)
movq %rsi, 0x748(%rsp)
leaq 0x510(%rsp), %rdi
movq %rdi, 0x110(%rsp)
callq 0x8e60
movq 0x110(%rsp), %r9
movl 0x750(%rsp), %esi
movq 0x748(%rsp), %rdx
leaq 0x8ce4(%rip), %rdi # 0x10268
xorl %ecx, %ecx
movl %ecx, %r8d
callq 0x6270
jmp 0x7590
leaq 0x4c8(%rsp), %rdi
callq 0x6140
jmp 0x759f
movq 0x89f2(%rip), %rdi # 0xff98
leaq 0x4b42(%rip), %rsi # 0xc0ef
callq 0x6250
movq %rax, 0x108(%rsp)
jmp 0x75bc
movq 0x108(%rsp), %rdi
movq 0x8a0d(%rip), %rsi # 0xffd8
callq 0x6400
jmp 0x75d2
leaq 0x510(%rsp), %rdi
callq 0x6080
movq %rax, 0x100(%rsp)
jmp 0x75e9
movq 0x100(%rsp), %rax
movq %rax, 0x4c0(%rsp)
movq 0x8998(%rip), %rdi # 0xff98
leaq 0x4b05(%rip), %rsi # 0xc10c
callq 0x6250
movq %rax, 0xf8(%rsp)
jmp 0x7616
movq 0xf8(%rsp), %rdi
movq 0x89b3(%rip), %rsi # 0xffd8
callq 0x6400
jmp 0x762c
movl $0x338, %edi # imm = 0x338
callq 0x6100
movq %rax, 0xf0(%rsp)
jmp 0x7640
movq 0xf0(%rsp), %rdi
movslq 0x588(%rsp), %rsi
movq 0x4c0(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x6210
jmp 0x7663
movq 0xf0(%rsp), %rax
movq %rax, 0x4b8(%rsp)
movq $0x0, 0x4b0(%rsp)
leaq 0x490(%rsp), %rdi
callq 0x61b0
movl 0x744(%rsp), %eax
movl %eax, 0xec(%rsp)
testl %eax, %eax
je 0x7741
jmp 0x76a4
movl 0xec(%rsp), %eax
subl $0x1, %eax
je 0x780e
jmp 0x76b6
movl 0xec(%rsp), %eax
subl $0x2, %eax
je 0x78c2
jmp 0x78ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
jmp 0x81fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
jmp 0x8179
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
jmp 0x816c
movq 0xf0(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
movl $0x338, %esi # imm = 0x338
callq 0x60c0
jmp 0x816c
movl $0x40, %edi
callq 0x6100
movq %rax, 0xe0(%rsp)
jmp 0x7755
movq 0xe0(%rsp), %rdi
movq 0x4b8(%rsp), %rsi
callq 0x63e0
jmp 0x776c
movq 0xe0(%rsp), %rax
movq %rax, 0x4b0(%rsp)
leaq 0x4992(%rip), %rsi # 0xc115
leaq 0x490(%rsp), %rdi
callq 0x6200
jmp 0x7792
movq 0x87ff(%rip), %rdi # 0xff98
leaq 0x4984(%rip), %rsi # 0xc124
callq 0x6250
movq %rax, 0xd8(%rsp)
jmp 0x77af
movq 0xd8(%rsp), %rdi
movq 0x881a(%rip), %rsi # 0xffd8
callq 0x6400
jmp 0x77c5
jmp 0x793c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
jmp 0x815f
movq 0xe0(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
movl $0x40, %esi
callq 0x60c0
jmp 0x815f
movl $0x40, %edi
callq 0x6100
movq %rax, 0xd0(%rsp)
jmp 0x7822
movq 0xd0(%rsp), %rdi
movq 0x4b8(%rsp), %rsi
callq 0x6470
jmp 0x7839
movq 0xd0(%rsp), %rax
movq %rax, 0x4b0(%rsp)
movq 0x8748(%rip), %rdi # 0xff98
leaq 0x48e8(%rip), %rsi # 0xc13f
callq 0x6250
movq %rax, 0xc8(%rsp)
jmp 0x7866
movq 0xc8(%rsp), %rdi
movq 0x8763(%rip), %rsi # 0xffd8
callq 0x6400
jmp 0x787c
leaq 0x48d8(%rip), %rsi # 0xc15b
leaq 0x490(%rsp), %rdi
callq 0x6200
jmp 0x7892
jmp 0x793c
movq 0xd0(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
movl $0x40, %esi
callq 0x60c0
jmp 0x815f
movq 0x871f(%rip), %rdi # 0xffe8
leaq 0x489a(%rip), %rsi # 0xc16a
callq 0x6250
movq %rax, 0xc0(%rsp)
jmp 0x78df
movq 0xc0(%rsp), %rdi
movq 0x86ea(%rip), %rsi # 0xffd8
callq 0x6400
jmp 0x78f5
movl $0x1, %edi
callq 0x62a0
movq 0x86e2(%rip), %rdi # 0xffe8
leaq 0x48ac(%rip), %rsi # 0xc1b9
callq 0x6250
movq %rax, 0xb8(%rsp)
jmp 0x791c
movq 0xb8(%rsp), %rdi
movq 0x86ad(%rip), %rsi # 0xffd8
callq 0x6400
jmp 0x7932
movl $0x1, %edi
callq 0x62a0
leaq 0x46f(%rsp), %rdi
movq %rdi, 0xb0(%rsp)
callq 0x63d0
movq 0xb0(%rsp), %rdx
leaq 0x486c(%rip), %rsi # 0xc1cc
leaq 0x470(%rsp), %rdi
callq 0x8580
jmp 0x796f
leaq 0x46f(%rsp), %rdi
callq 0x6490
leaq 0x447(%rsp), %rdi
movq %rdi, 0xa8(%rsp)
callq 0x63d0
movq 0xa8(%rsp), %rdx
leaq 0x482c(%rip), %rsi # 0xc1cc
leaq 0x448(%rsp), %rdi
callq 0x8580
jmp 0x79af
leaq 0x447(%rsp), %rdi
callq 0x6490
cmpl $0x0, 0x558(%rsp)
jne 0x7c68
leaq 0x2b8(%rsp), %rdi
callq 0x6170
jmp 0x79d9
leaq 0x2c8(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x4c0(%rsp), %rdx
movq (%rdx), %rax
movq -0x40(%rax), %rax
addq %rax, %rdx
leaq 0x298(%rsp), %rdi
leaq 0x490(%rsp), %rsi
leaq 0x510(%rsp), %rcx
callq 0x6350
jmp 0x7a1a
movq 0xa0(%rsp), %rdi
leaq 0x298(%rsp), %rsi
callq 0x6160
movq %rax, 0x98(%rsp)
jmp 0x7a39
movq 0x98(%rsp), %rdi
leaq 0x478e(%rip), %rsi # 0xc1d6
callq 0x6250
movq %rax, 0x90(%rsp)
jmp 0x7a57
movq 0x90(%rsp), %rdi
movl 0x588(%rsp), %esi
callq 0x61a0
jmp 0x7a6d
leaq 0x298(%rsp), %rdi
callq 0x62d0
leaq 0x278(%rsp), %rdi
leaq 0x2b8(%rsp), %rsi
callq 0x62c0
jmp 0x7a91
leaq 0x470(%rsp), %rdi
movq %rdi, 0x88(%rsp)
leaq 0x278(%rsp), %rsi
movq %rsi, 0x80(%rsp)
callq 0x6240
movq 0x80(%rsp), %rdi
callq 0x62d0
movq 0x88(%rsp), %rsi
leaq 0x4707(%rip), %rdx # 0xc1d9
leaq 0x258(%rsp), %rdi
callq 0x92b0
jmp 0x7ae1
leaq 0x448(%rsp), %rdi
leaq 0x258(%rsp), %rsi
movq %rsi, 0x70(%rsp)
callq 0x6240
movq 0x70(%rsp), %rdi
callq 0x62d0
leaq 0x470(%rsp), %rdi
callq 0x74a0
movb %al, 0x7f(%rsp)
jmp 0x7b18
movb 0x7f(%rsp), %al
testb $0x1, %al
jne 0x7c47
jmp 0x7b26
movq 0x846b(%rip), %rdi # 0xff98
leaq 0x46ae(%rip), %rsi # 0xc1e2
callq 0x6250
movq %rax, 0x68(%rsp)
jmp 0x7b40
movq 0x68(%rsp), %rdi
leaq 0x470(%rsp), %rsi
callq 0x6160
movq %rax, 0x60(%rsp)
jmp 0x7b59
movq 0x60(%rsp), %rdi
movq 0x8473(%rip), %rsi # 0xffd8
callq 0x6400
jmp 0x7b6c
movq 0x8425(%rip), %rdi # 0xff98
leaq 0x4685(%rip), %rsi # 0xc1ff
callq 0x6250
movq %rax, 0x58(%rsp)
jmp 0x7b86
movq 0x58(%rsp), %rdi
movq 0x8446(%rip), %rsi # 0xffd8
callq 0x6400
jmp 0x7b99
movl $0x1, 0x558(%rsp)
jmp 0x7c47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
leaq 0x46f(%rsp), %rdi
callq 0x6490
jmp 0x815f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
leaq 0x447(%rsp), %rdi
callq 0x6490
jmp 0x8152
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
jmp 0x8145
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
jmp 0x7c56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
leaq 0x298(%rsp), %rdi
callq 0x62d0
jmp 0x7c56
leaq 0x2b8(%rsp), %rdi
callq 0x61e0
jmp 0x7c68
leaq 0x2b8(%rsp), %rdi
callq 0x61e0
jmp 0x8145
leaq 0x237(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x63d0
movq 0x50(%rsp), %rdx
leaq 0x459d(%rip), %rsi # 0xc223
leaq 0x238(%rsp), %rdi
callq 0x8580
jmp 0x7c95
leaq 0x4c8(%rsp), %rdi
leaq 0x238(%rsp), %rsi
callq 0x60f0
jmp 0x7cac
leaq 0x238(%rsp), %rdi
callq 0x62d0
leaq 0x237(%rsp), %rdi
callq 0x6490
movq 0x4b0(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0x7cd9
leaq 0x20f(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x63d0
movq 0x48(%rsp), %rdx
leaq 0x452c(%rip), %rsi # 0xc223
leaq 0x210(%rsp), %rdi
callq 0x8580
jmp 0x7d06
leaq 0x4c8(%rsp), %rdi
leaq 0x210(%rsp), %rsi
callq 0x6450
jmp 0x7d1d
leaq 0x210(%rsp), %rdi
callq 0x62d0
leaq 0x20f(%rsp), %rdi
callq 0x6490
movq 0x825a(%rip), %rdi # 0xff98
leaq 0x43c7(%rip), %rsi # 0xc10c
callq 0x6250
movq %rax, 0x40(%rsp)
jmp 0x7d51
movq 0x40(%rsp), %rdi
movq 0x827b(%rip), %rsi # 0xffd8
callq 0x6400
jmp 0x7d64
movq 0x4b0(%rsp), %rsi
movq (%rsi), %rax
movq 0x50(%rax), %rax
leaq 0x1d8(%rsp), %rdi
xorl %edx, %edx
callq *%rax
jmp 0x7d81
movl 0x670(%rsp), %eax
movl %eax, 0x1d4(%rsp)
movl 0x674(%rsp), %eax
movl %eax, 0x1d0(%rsp)
movq 0x81f4(%rip), %rdi # 0xff98
leaq 0x447d(%rip), %rsi # 0xc228
callq 0x6250
movq %rax, 0x38(%rsp)
jmp 0x7db7
movq 0x38(%rsp), %rdi
movl 0x1d4(%rsp), %esi
callq 0x61a0
movq %rax, 0x30(%rsp)
jmp 0x7dcf
movq 0x30(%rsp), %rdi
leaq 0x446d(%rip), %rsi # 0xc248
callq 0x6250
movq %rax, 0x28(%rsp)
jmp 0x7de7
movq 0x28(%rsp), %rdi
movl 0x1d0(%rsp), %esi
callq 0x61a0
movq %rax, 0x20(%rsp)
jmp 0x7dff
movq 0x20(%rsp), %rdi
movq 0x81cd(%rip), %rsi # 0xffd8
callq 0x6400
jmp 0x7e12
movq 0x4b8(%rsp), %rsi
movl 0x1d4(%rsp), %edx
movl 0x1d0(%rsp), %ecx
leaq 0x180(%rsp), %rdi
xorl %r8d, %r8d
callq 0x6380
jmp 0x7e3a
cmpl $0x0, 0x558(%rsp)
jne 0x7f72
leaq 0x160(%rsp), %rdi
leaq 0x470(%rsp), %rsi
callq 0x60d0
jmp 0x7e5f
leaq 0x180(%rsp), %rdi
leaq 0x160(%rsp), %rsi
callq 0x63b0
jmp 0x7e76
leaq 0x160(%rsp), %rdi
callq 0x62d0
jmp 0x7f72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
jmp 0x7ebf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
leaq 0x238(%rsp), %rdi
callq 0x62d0
leaq 0x237(%rsp), %rdi
callq 0x6490
jmp 0x8145
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
jmp 0x7f08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
leaq 0x210(%rsp), %rdi
callq 0x62d0
leaq 0x20f(%rsp), %rdi
callq 0x6490
jmp 0x8145
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
jmp 0x8138
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
jmp 0x812b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
leaq 0x160(%rsp), %rdi
callq 0x62d0
jmp 0x812b
leaq 0x148(%rsp), %rdi
callq 0x9340
movq 0x4b8(%rsp), %rsi
leaq 0x1d8(%rsp), %rdi
leaq 0x180(%rsp), %rdx
callq 0x7210
vmovsd %xmm0, 0x18(%rsp)
jmp 0x7fa4
vmovsd 0x18(%rsp), %xmm0
vmovsd %xmm0, 0x140(%rsp)
movq 0x7fde(%rip), %rdi # 0xff98
leaq 0x4293(%rip), %rsi # 0xc254
callq 0x6250
movq %rax, 0x10(%rsp)
jmp 0x7fcd
movq 0x10(%rsp), %rdi
movq 0x7fff(%rip), %rsi # 0xffd8
callq 0x6400
jmp 0x7fe0
leaq 0x148(%rsp), %rdi
leaq 0x140(%rsp), %rsi
callq 0x9350
jmp 0x7ff7
movq 0x7f9a(%rip), %rdi # 0xff98
leaq 0x4257(%rip), %rsi # 0xc25c
callq 0x6250
movq %rax, 0x8(%rsp)
jmp 0x8011
leaq 0x120(%rsp), %rdi
leaq 0x148(%rsp), %rsi
callq 0x8220
jmp 0x8028
movq 0x8(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x6160
movq %rax, (%rsp)
jmp 0x8040
movq (%rsp), %rdi
movq 0x7f8d(%rip), %rsi # 0xffd8
callq 0x6400
jmp 0x8052
leaq 0x120(%rsp), %rdi
callq 0x62d0
cmpl $0x0, 0x558(%rsp)
jne 0x80be
leaq 0x4c8(%rsp), %rdi
leaq 0x448(%rsp), %rsi
callq 0x63a0
jmp 0x8080
jmp 0x80be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
jmp 0x811e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
leaq 0x120(%rsp), %rdi
callq 0x62d0
jmp 0x811e
leaq 0x148(%rsp), %rdi
callq 0x93c0
leaq 0x180(%rsp), %rdi
callq 0x6340
leaq 0x1d8(%rsp), %rdi
callq 0x9420
leaq 0x448(%rsp), %rdi
callq 0x62d0
leaq 0x470(%rsp), %rdi
callq 0x62d0
leaq 0x490(%rsp), %rdi
callq 0x62d0
leaq 0x4c8(%rsp), %rdi
callq 0x6480
jmp 0x81b6
leaq 0x148(%rsp), %rdi
callq 0x93c0
leaq 0x180(%rsp), %rdi
callq 0x6340
leaq 0x1d8(%rsp), %rdi
callq 0x9420
leaq 0x448(%rsp), %rdi
callq 0x62d0
leaq 0x470(%rsp), %rdi
callq 0x62d0
leaq 0x490(%rsp), %rdi
callq 0x62d0
leaq 0x4c8(%rsp), %rdi
callq 0x6480
movl 0x504(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x81fa
movq 0x508(%rsp), %rdi
callq 0x6070
movq %rax, 0x118(%rsp)
movq 0x118(%rsp), %rdi
callq 0x9450
jmp 0x81ad
callq 0x62e0
jmp 0x81b4
jmp 0x81b6
movl $0x0, 0x754(%rsp)
leaq 0x510(%rsp), %rdi
callq 0x94b0
movl 0x754(%rsp), %eax
addq $0x758, %rsp # imm = 0x758
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x508(%rsp)
movl %eax, 0x504(%rsp)
callq 0x62e0
jmp 0x81f8
jmp 0x81fa
leaq 0x510(%rsp), %rdi
callq 0x94b0
movq 0x508(%rsp), %rdi
callq 0x6280
movq %rax, %rdi
callq 0x94a0
nopl (%rax)
| /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/solvers/MMDP_Solver.cpp |
ArgumentHandlers::parse_main(int, char*, argp_state*) | static error_t
parse_main (int key, char *arg, struct argp_state *state)
{
struct arguments *theArgumentsStruc = (struct arguments*) state->input;
switch (key)
{
case ARGP_KEY_INIT:
//give child_parsers access to the arguments structure on
//initialization.
for(unsigned i = 0; i < size(childVector); i++)
state->child_inputs[i] = theArgumentsStruc;
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
} | subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x20(%rsp), %eax
subl $0x1000003, %eax # imm = 0x1000003
jne 0x8436
jmp 0x83ed
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
leaq 0x81fd(%rip), %rdi # 0x10600
callq 0x9560
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jae 0x8434
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x83f5
jmp 0x8440
movl $0x7, 0x24(%rsp)
jmp 0x8448
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/solvers/../../src/planning/argumentHandlersPostChild.h |
ArgumentHandlers::Arguments::Arguments() | Arguments()
{
// general
verbose = 0;
testMode = false;
// problem file
dpf = 0;
problem_type = PARSE;
nrAgents = 2;
nrHouses = 3;
nrFLs = 3;
islandConf = ProblemAloha::InLine;
alohaVariation = ProblemAloha::NoNewPacket;
maxBacklog = 2;
// output
dryrun = 0;
description = NULL;
prefix = NULL;
noReCompute = 0;
outputPolicy = false;
// model
cache_flat_models = false;
sparse = 0;
isTOI = 0;
discount = -1;
// solution method
horizon = 2;
infiniteHorizon = false;
nrRestarts = 1;
// jpol index
jpolIndex = 0;
// BGSolver options
bgsolver = BFS;
deadline = 0;
// GMAA
gmaa = MAAstar;
nrAMRestarts = 10;
k = 1;
saveAllBGs = 0;
saveTimings = 0; // also used for Perseus
useQcache = 0;
requireQcache = false;
exactBGs = true;
slack = 0.0;
GMAAdeadline = 0;
// GMAA Cluster
useBGclustering = 0;
BGClusterAlgorithm = 0;
thresholdJB = 0;
thresholdPjaoh = 0;
//JESP options
jesp = JESPDP;
// Perseus
savePOMDP = 0;
saveIntermediateV = 0;
minimumNrIterations = 0;
initializeWithImmediateReward = 0;
initializeWithZero = 0;
// Perseus belief set sampling options
nrBeliefs = 10;
saveBeliefs = 0;
resetAfter = 0;
uniqueBeliefs = 0;
useQMDPforSamplingBeliefs = 0;
QMDPexploreProb = 0.1;
// PerseusBackup
backup = POMDP;
bgBackup = BGIP_SOLVER_EXHAUSTIVE;
waitPenalty = -1;
weight = -1;
commModel = -1;
computeVectorForEachBelief = 0;
// Qheur options
qheur = eQheurUndefined;
QHybridHorizonLastTimeSteps = 0;
QHybridFirstTS = eQBG;
QHybridLastTS = eQMDP;
TreeIPpruneAfterUnion = true;
TreeIPpruneAfterCrossSum = true;
TreeIPuseVectorCache = true;
acceleratedPruningThreshold = 200;
// Simulation options
nrRuns = 1000;
randomSeed = 42;
successfulCommProb = -1;
// TOI options
TOIpolicy = 0;
// TOIcentralized options
TOIcentralized = 0;
useCentralizedModels = 0;
// CE (cross-entropy) options
nrCERestarts = 10;
nrCEIterations = 50;
nrCESamples = 50;
nrCESamplesForUpdate = 10;
CE_use_hard_threshold = 1; //(gamma in CE papers)
CE_alpha = 0.3; //the learning rate
nrCEEvaluationRuns = 100; // number of policy evaluation runs. 0 = exact evaluation
// online POMDP
nrNodesExpanded = 10;
// RL options;
nrRLruns=10000;
nrIntermediateEvaluations=10;
startAtRLrun=0;
// options for max-plus
maxplus_maxiter = 25;
maxplus_verbose = 0;
maxplus_damping = 0.5;
maxplus_nrRestarts = 1;
maxplus_updateT = std::string("PARALL");
BnBJointTypeOrdering = IdentityMapping;
BnB_keepAll = false;
BnB_consistentCompleteInformationHeur = true;
// solveBG options
bgFilename = 0;
startIndex = -1;
endIndex = -1;
useASCIIformat = false;
isCGBG = false;
// Event-Driven POMDP options
marginalize = false;
marginalizationIndex = false;
falseNegativeObs = -1;
mmdp_method = ValueIteration;
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x1e8, %rdi # imm = 0x1E8
movq %rdi, (%rsp)
callq 0x61b0
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movb $0x0, 0x4(%rax)
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq $0x2, 0x18(%rax)
movq $0x3, 0x20(%rax)
movq $0x3, 0x28(%rax)
movl $0xb, 0x38(%rax)
movl $0x0, 0x3c(%rax)
movq $0x2, 0x40(%rax)
movl $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
movl $0x0, 0x60(%rax)
movb $0x0, 0x64(%rax)
movb $0x0, 0x65(%rax)
movl $0x0, 0x68(%rax)
movl $0x0, 0x6c(%rax)
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, 0x70(%rax)
movl $0x2, 0x78(%rax)
movb $0x0, 0x7c(%rax)
movl $0x1, 0x80(%rax)
movq $0x0, 0x88(%rax)
movl $0x0, 0x90(%rax)
movq $0x0, 0x98(%rax)
movl $0x0, 0xa0(%rax)
movl $0xa, 0xe4(%rax)
movl $0x1, 0xa4(%rax)
movl $0x0, 0xa8(%rax)
movl $0x0, 0xac(%rax)
movl $0x0, 0xb0(%rax)
movb $0x0, 0xb4(%rax)
movb $0x1, 0xb5(%rax)
movq $0x0, 0xb8(%rax)
movq $0x0, 0xc0(%rax)
movl $0x0, 0xc8(%rax)
movl $0x0, 0xcc(%rax)
movq $0x0, 0xd0(%rax)
movq $0x0, 0xd8(%rax)
movl $0x1, 0xe0(%rax)
movl $0x0, 0xe8(%rax)
movl $0x0, 0xec(%rax)
movl $0x0, 0xf0(%rax)
movl $0x0, 0xf4(%rax)
movl $0x0, 0xf8(%rax)
movl $0xa, 0x100(%rax)
movl $0x0, 0x104(%rax)
movl $0x0, 0x108(%rax)
movl $0x0, 0xfc(%rax)
movl $0x0, 0x10c(%rax)
movabsq $0x3fb999999999999a, %rdx # imm = 0x3FB999999999999A
movq %rdx, 0x110(%rax)
movl $0x0, 0x118(%rax)
movl $0x2, 0x11c(%rax)
movq %rcx, 0x120(%rax)
movq %rcx, 0x128(%rax)
movl $0xffffffff, 0x130(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x134(%rax)
movl $0xb, 0x138(%rax)
movq $0x0, 0x140(%rax)
movl $0x2, 0x148(%rax)
movl $0x0, 0x14c(%rax)
movb $0x1, 0x150(%rax)
movb $0x1, 0x151(%rax)
movb $0x1, 0x152(%rax)
movq $0xc8, 0x158(%rax)
movl $0x3e8, 0x160(%rax) # imm = 0x3E8
movl $0x2a, 0x164(%rax)
movq %rcx, 0x168(%rax)
movl $0x0, 0x170(%rax)
movl $0x0, 0x174(%rax)
movl $0x0, 0x178(%rax)
movq $0xa, 0x180(%rax)
movq $0x32, 0x188(%rax)
movq $0x32, 0x190(%rax)
movq $0xa, 0x198(%rax)
movb $0x1, 0x1a0(%rax)
movabsq $0x3fd3333333333333, %rcx # imm = 0x3FD3333333333333
movq %rcx, 0x1a8(%rax)
movq $0x64, 0x1b0(%rax)
movl $0xa, 0x1b8(%rax)
movl $0x2710, 0x1bc(%rax) # imm = 0x2710
movl $0xa, 0x1c0(%rax)
movl $0x0, 0x1c4(%rax)
movq $0x19, 0x1c8(%rax)
movq $0x0, 0x1d0(%rax)
movabsq $0x3fe0000000000000, %rcx # imm = 0x3FE0000000000000
movq %rcx, 0x1d8(%rax)
movq $0x1, 0x1e0(%rax)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x63d0
movq 0x10(%rsp), %rdx
leaq 0x309f(%rip), %rsi # 0xc26a
leaq 0x30(%rsp), %rdi
callq 0x8580
jmp 0x91d7
movq 0x8(%rsp), %rdi
addq $0x1e8, %rdi # imm = 0x1E8
leaq 0x30(%rsp), %rsi
callq 0x6240
leaq 0x30(%rsp), %rdi
callq 0x62d0
leaq 0x2f(%rsp), %rdi
callq 0x6490
movq 0x8(%rsp), %rax
movl $0x0, 0x208(%rax)
movb $0x0, 0x20c(%rax)
movb $0x1, 0x20d(%rax)
movq $0x0, 0x210(%rax)
movl $0xffffffff, 0x218(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x21c(%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x220(%rax)
movb $0x0, 0x221(%rax)
movb $0x0, 0x222(%rax)
movq $0x0, 0x228(%rax)
movl $0xffffffff, 0x230(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x234(%rax)
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0x6490
movq (%rsp), %rdi
callq 0x62d0
movq 0x20(%rsp), %rdi
callq 0x6280
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/solvers/../../src/planning/argumentHandlers.h |
boost::numeric::ublas::matrix<double, boost::numeric::ublas::basic_row_major<unsigned long, long>, boost::numeric::ublas::unbounded_array<double, std::allocator<double>>>::~matrix() | class matrix:
public matrix_container<matrix<T, L, A> > {
typedef T *pointer;
typedef L layout_type;
typedef matrix<T, L, A> self_type;
public:
#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
using matrix_container<self_type>::operator ();
#endif
typedef typename A::size_type size_type;
typedef typename A::difference_type difference_type;
typedef T value_type;
typedef const T &const_reference;
typedef T &reference;
typedef A array_type;
typedef const matrix_reference<const self_type> const_closure_type;
typedef matrix_reference<self_type> closure_type;
typedef vector<T, A> vector_temporary_type;
typedef self_type matrix_temporary_type;
typedef dense_tag storage_category;
// This could be better for performance,
// typedef typename unknown_orientation_tag orientation_category;
// but others depend on the orientation information...
typedef typename L::orientation_category orientation_category;
// Construction and destruction
/// Default dense matrix constructor. Make a dense matrix of size (0,0)
BOOST_UBLAS_INLINE
matrix ():
matrix_container<self_type> (),
size1_ (0), size2_ (0), data_ () {}
/** Dense matrix constructor with defined size
* \param size1 number of rows
* \param size2 number of columns
*/
BOOST_UBLAS_INLINE
matrix (size_type size1, size_type size2):
matrix_container<self_type> (),
size1_ (size1), size2_ (size2), data_ (layout_type::storage_size (size1, size2)) {
}
/** Dense matrix constructor with defined size a initial value for all the matrix elements
* \param size1 number of rows
* \param size2 number of columns
* \param init initial value assigned to all elements
*/
matrix (size_type size1, size_type size2, const value_type &init):
matrix_container<self_type> (),
size1_ (size1), size2_ (size2), data_ (layout_type::storage_size (size1, size2), init) {
}
/** Dense matrix constructor with defined size and an initial data array
* \param size1 number of rows
* \param size2 number of columns
* \param data array to copy into the matrix. Must have the same dimension as the matrix
*/
BOOST_UBLAS_INLINE
matrix (size_type size1, size_type size2, const array_type &data):
matrix_container<self_type> (),
size1_ (size1), size2_ (size2), data_ (data) {}
/** Copy-constructor of a dense matrix
* \param m is a dense matrix
*/
BOOST_UBLAS_INLINE
matrix (const matrix &m):
matrix_container<self_type> (),
size1_ (m.size1_), size2_ (m.size2_), data_ (m.data_) {}
/** Copy-constructor of a dense matrix from a matrix expression
* \param ae is a matrix expression
*/
template<class AE>
BOOST_UBLAS_INLINE
matrix (const matrix_expression<AE> &ae):
matrix_container<self_type> (),
size1_ (ae ().size1 ()), size2_ (ae ().size2 ()), data_ (layout_type::storage_size (size1_, size2_)) {
matrix_assign<scalar_assign> (*this, ae);
}
// Accessors
/** Return the number of rows of the matrix
* You can also use the free size<>() function in operation/size.hpp as size<1>(m) where m is a matrix
*/
BOOST_UBLAS_INLINE
size_type size1 () const {
return size1_;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x10, %rdi
callq 0x9640
movq 0x8(%rsp), %rdi
callq 0x96a0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/solvers/../../src/boost/boost/numeric/ublas/matrix.hpp |
boost::numeric::ublas::unbounded_array<double, std::allocator<double>>::~unbounded_array() | BOOST_UBLAS_INLINE
~unbounded_array () {
if (size_) {
if (! detail::has_trivial_destructor<T>::value) {
// std::_Destroy (begin(), end(), alloc_);
const iterator i_end = end();
for (iterator i = begin (); i != i_end; ++i) {
iterator_destroy (i);
}
}
alloc_.deallocate (data_, size_);
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x9670
movq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
callq 0x96b0
jmp 0x966e
jmp 0x9670
movq 0x8(%rsp), %rdi
callq 0x96e0
movq 0x8(%rsp), %rdi
callq 0x96f0
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x94a0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/solvers/../../src/boost/boost/numeric/ublas/storage.hpp |
Kraken::KAPI::public_method(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<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&) const | std::string KAPI::public_method(const std::string& method,
const KAPI::Input& input) const
{
// build method URL
std::string path = "/" + version_ + "/public/" + method;
std::string method_url = url_ + path + "?" + build_query(input);
curl_easy_setopt(curl_, CURLOPT_URL, method_url.c_str());
// reset the http header
curl_easy_setopt(curl_, CURLOPT_HTTPHEADER, NULL);
// where CURL write callback function stores the response
std::string response;
curl_easy_setopt(curl_, CURLOPT_WRITEDATA, static_cast<void*>(&response));
// Set GET method
curl_easy_setopt(curl_, CURLOPT_HTTPGET, 1L);
// perform CURL request
CURLcode result = curl_easy_perform(curl_);
if (result != CURLE_OK) {
std::ostringstream oss;
oss << "curl_easy_perform() failed: "<< curl_easy_strerror(result);
throw std::runtime_error(oss.str());
}
return response;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsi), %rdx
leaq 0x1df0(%rip), %rsi # 0x7148
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x5d2c
leaq 0x1dd5(%rip), %rdx # 0x7141
leaq 0x80(%rsp), %rdi
movq %r13, %rsi
callq 0x5d0d
leaq 0x60(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq %r12, %rdx
callq 0x5cee
leaq 0x80(%rsp), %rdi
callq 0x4320
leaq 0x20(%rsp), %rdi
callq 0x4320
leaq 0x40(%r14), %rsi
movq %rsp, %rdi
leaq 0x60(%rsp), %rdx
callq 0x5c96
leaq 0x1d8a(%rip), %rdx # 0x714a
leaq 0x80(%rsp), %rdi
movq %rsp, %rsi
callq 0x5d0d
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x55d7
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x5da2
leaq 0x40(%rsp), %rdi
callq 0x4320
leaq 0x80(%rsp), %rdi
callq 0x4320
movq %rsp, %rdi
callq 0x4320
movq 0x80(%r14), %rdi
movq 0x20(%rsp), %rdx
movl $0x2712, %esi # imm = 0x2712
xorl %eax, %eax
callq 0x43b0
movq 0x80(%r14), %rdi
movl $0x2727, %esi # imm = 0x2727
xorl %edx, %edx
xorl %eax, %eax
callq 0x43b0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x80(%r14), %rdi
movl $0x2711, %esi # imm = 0x2711
movq %rbx, %rdx
xorl %eax, %eax
callq 0x43b0
movq 0x80(%r14), %rdi
pushq $0x50
popq %rsi
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0x43b0
movq 0x80(%r14), %rdi
callq 0x4300
movl %eax, %ebp
testl %eax, %eax
jne 0x54b5
leaq 0x20(%rsp), %rdi
callq 0x4320
leaq 0x60(%rsp), %rdi
callq 0x4320
movq %rbx, %rax
addq $0x1f8, %rsp # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x80(%rsp), %rdi
callq 0x4430
leaq 0x1c83(%rip), %rsi # 0x714c
leaq 0x80(%rsp), %rdi
callq 0x4260
movq %rax, %r14
movl %ebp, %edi
callq 0x41b0
movq %r14, %rdi
movq %rax, %rsi
callq 0x4260
pushq $0x10
popq %rdi
callq 0x4180
movq %rax, %r15
leaq 0x88(%rsp), %rsi
movq %rsp, %rdi
callq 0x4190
movb $0x1, %bpl
movq %rsp, %rsi
movq %r15, %rdi
callq 0x4120
xorl %ebp, %ebp
movq 0x4ac3(%rip), %rsi # 0x9fe0
movq 0x4ab4(%rip), %rdx # 0x9fd8
movq %r15, %rdi
callq 0x4290
movq %rax, %r14
movq %rsp, %rdi
callq 0x4320
testb %bpl, %bpl
jne 0x5541
jmp 0x554e
movq %rax, %r14
movq %r15, %rdi
callq 0x43d0
jmp 0x554e
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0x43e0
jmp 0x55ae
jmp 0x55ab
jmp 0x55ab
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x4320
jmp 0x5573
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0x4320
jmp 0x5585
movq %rax, %r14
movq %rsp, %rdi
jmp 0x55c0
movq %rax, %r14
jmp 0x55c5
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0x4320
jmp 0x55a4
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x55ca
movq %rax, %r14
movq %rbx, %rdi
callq 0x4320
jmp 0x55bb
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x4320
leaq 0x60(%rsp), %rdi
callq 0x4320
movq %r14, %rdi
callq 0x42c0
| /voidloop[P]krakenapi/kapi.cpp |
ads2_checkFact3_Test::TestBody() | TEST(ads2, checkFact3) {
EXPECT_EQ(3628800, fact(10));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
movl $0x375f00, (%rbx) # imm = 0x375F00
movl $0xa, %edi
callq 0x9120
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x2f94b(%rip), %rsi # 0x3b146
leaq 0x2f94c(%rip), %rdx # 0x3b14e
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
callq 0xce71
cmpb $0x0, (%r14)
jne 0xb87c
leaq 0x8(%rsp), %rdi
callq 0x1bce0
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xb831
movq (%rax), %r8
jmp 0xb838
leaq 0x32771(%rip), %r8 # 0x3dfa9
leaq 0x2f850(%rip), %rdx # 0x3b08f
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x19, %ecx
callq 0x18290
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x15c10
leaq 0x10(%rsp), %rdi
callq 0x182fc
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb87c
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0xb890
leaq 0x20(%rsp), %rdi
callq 0xc94c
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x182fc
jmp 0xb8aa
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb8ba
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0xb8c8
movq %rax, %rbx
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0xb8dc
leaq 0x20(%rsp), %rdi
callq 0xc94c
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/test/tests.cpp |
ads2_checkSinn2_Test::TestBody() | TEST(ads2, checkSinn2) {
EXPECT_DOUBLE_EQ(0.9999996829318345, sinn(3.14/2, 10));
} | pushq %rbx
subq $0x20, %rsp
movsd 0x2f04f(%rip), %xmm0 # 0x3b060
movl $0xa, %edi
callq 0x9520
movaps %xmm0, %xmm1
leaq 0x2f242(%rip), %rsi # 0x3b267
leaq 0x2f24e(%rip), %rdx # 0x3b27a
leaq 0x10(%rsp), %rbx
movsd 0x2f02f(%rip), %xmm0 # 0x3b068
movq %rbx, %rdi
callq 0xc500
cmpb $0x0, (%rbx)
jne 0xc0a5
movq %rsp, %rdi
callq 0x1bce0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xc05d
movq (%rax), %r8
jmp 0xc064
leaq 0x31f45(%rip), %r8 # 0x3dfa9
leaq 0x2f024(%rip), %rdx # 0x3b08f
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x39, %ecx
callq 0x18290
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x15c10
leaq 0x8(%rsp), %rdi
callq 0x182fc
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc0a5
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xc0b9
leaq 0x18(%rsp), %rdi
callq 0xc94c
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x182fc
jmp 0xc0d1
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc0e0
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0xc0ed
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xc101
leaq 0x18(%rsp), %rdi
callq 0xc94c
movq %rbx, %rdi
callq 0x99e0
nop
| /NNTU-CS[P]ADS-2/test/tests.cpp |
testing::internal::SuiteApiResolver<testing::Test>::GetTearDownCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
SetUpTearDownSuiteFuncType test_suite_fp =
GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);
GTEST_CHECK_(!test_case_fp || !test_suite_fp)
<< "Test can not provide both TearDownTestSuite and TearDownTestCase,"
" please make sure there is only one present at"
<< filename << ":" << line_num;
return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
#else
(void)(filename);
(void)(line_num);
return &T::TearDownTestSuite;
#endif
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x10142
testb %al, %al
jne 0xc4df
leaq 0x2eecc(%rip), %rdx # 0x3b2fb
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x223, %ecx # imm = 0x223
callq 0x161ce
movq 0x46ba6(%rip), %rdi # 0x52ff0
leaq 0x2ef44(%rip), %rsi # 0x3b395
movl $0x32, %edx
callq 0x95f0
movq 0x46b8e(%rip), %r15 # 0x52ff0
leaq 0x2efca(%rip), %rsi # 0x3b433
movl $0x6f, %edx
movq %r15, %rdi
callq 0x95f0
testq %r14, %r14
je 0xc497
movq %r14, %rdi
callq 0x9230
movq 0x46b66(%rip), %rdi # 0x52ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x95f0
jmp 0xc4af
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x9980
movq 0x46b3a(%rip), %rdi # 0x52ff0
leaq 0x31fda(%rip), %rsi # 0x3e497
movl $0x1, %edx
callq 0x95f0
movq 0x46b22(%rip), %rdi # 0x52ff0
movl %ebx, %esi
callq 0x99a0
leaq 0xc(%rsp), %rdi
callq 0x16310
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x16310
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::StringFromGTestEnv(char const*, char const*) | const char* StringFromGTestEnv(const char* flag, const char* default_value) {
#if defined(GTEST_GET_STRING_FROM_ENV_)
return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#else
const std::string env_var = FlagToEnvVar(flag);
const char* const value = posix::GetEnv(env_var.c_str());
return value == nullptr ? default_value : value;
#endif // defined(GTEST_GET_STRING_FROM_ENV_)
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x16901
movq (%r14), %r15
movq %r15, %rdi
callq 0x96b0
movq %rax, %r14
leaq 0x10(%rsp), %rax
cmpq %rax, %r15
je 0xd210
movq 0x10(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x9500
testq %r14, %r14
cmovneq %r14, %rbx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc |
testing::internal::DeathTestAbort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void DeathTestAbort(const std::string& message) {
// On a POSIX system, this function may be called from a threadsafe-style
// death test child process, which operates on a very small stack. Use
// the heap for any additional non-minuscule memory requirements.
const InternalRunDeathTestFlag* const flag =
GetUnitTestImpl()->internal_run_death_test_flag();
if (flag != nullptr) {
FILE* parent = posix::FDOpen(flag->write_fd(), "w");
fputc(kDeathTestInternalError, parent);
fprintf(parent, "%s", message.c_str());
fflush(parent);
_exit(1);
} else {
fprintf(stderr, "%s", message.c_str());
fflush(stderr);
posix::Abort();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1832e
movq 0x46430(%rip), %rax # 0x537f0
movq 0x238(%rax), %rax
testq %rax, %rax
jne 0xd3eb
movq 0x45bfd(%rip), %r14 # 0x52fd0
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x95c0
movq (%r14), %rdi
callq 0x9640
callq 0x3073b
movl 0x28(%rax), %edi
leaq 0x3123d(%rip), %rsi # 0x3e632
callq 0x3470b
movq %rax, %r14
movl $0x49, %edi
movq %rax, %rsi
callq 0x96e0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x95c0
movq %r14, %rdi
callq 0x9640
movl $0x1, %edi
callq 0x9960
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::DefaultDeathTestFactory::Create(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>, char const*, int, testing::internal::DeathTest**) | bool DefaultDeathTestFactory::Create(const char* statement,
Matcher<const std::string&> matcher,
const char* file, int line,
DeathTest** test) {
UnitTestImpl* const impl = GetUnitTestImpl();
const InternalRunDeathTestFlag* const flag =
impl->internal_run_death_test_flag();
const int death_test_index =
impl->current_test_info()->increment_death_test_count();
if (flag != nullptr) {
if (death_test_index > flag->index()) {
DeathTest::set_last_death_test_message(
"Death test count (" + StreamableToString(death_test_index) +
") somehow exceeded expected maximum (" +
StreamableToString(flag->index()) + ")");
return false;
}
if (!(flag->file() == file && flag->line() == line &&
flag->index() == death_test_index)) {
*test = nullptr;
return true;
}
}
#if GTEST_OS_WINDOWS
if (GTEST_FLAG_GET(death_test_style) == "threadsafe" ||
GTEST_FLAG_GET(death_test_style) == "fast") {
*test = new WindowsDeathTest(statement, std::move(matcher), file, line);
}
#elif GTEST_OS_FUCHSIA
if (GTEST_FLAG_GET(death_test_style) == "threadsafe" ||
GTEST_FLAG_GET(death_test_style) == "fast") {
*test = new FuchsiaDeathTest(statement, std::move(matcher), file, line);
}
#else
if (GTEST_FLAG_GET(death_test_style) == "threadsafe") {
*test = new ExecDeathTest(statement, std::move(matcher), file, line);
} else if (GTEST_FLAG_GET(death_test_style) == "fast") {
*test = new NoExecDeathTest(statement, std::move(matcher));
}
#endif // GTEST_OS_WINDOWS
else { // NOLINT - this is more readable than unbalanced brackets inside #if.
DeathTest::set_last_death_test_message("Unknown death test style \"" +
GTEST_FLAG_GET(death_test_style) +
"\" encountered");
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
callq 0x1832e
movq 0x4079a(%rip), %rax # 0x537f0
movq 0x238(%rax), %r14
movq 0x170(%rax), %rcx
movl 0xf8(%rcx), %eax
leal 0x1(%rax), %edx
movl %edx, 0xf8(%rcx)
movl %edx, 0xc(%rsp)
testq %r14, %r14
je 0x130b1
cmpl 0x24(%r14), %eax
jge 0x1313f
movq %r14, %rdi
movq %r13, %rsi
callq 0x9190
testl %eax, %eax
jne 0x131a1
cmpl %ebp, 0x20(%r14)
jne 0x131a1
movl 0x24(%r14), %eax
cmpl 0xc(%rsp), %eax
jne 0x131a1
leaq 0x40580(%rip), %rdi # 0x53638
leaq 0x29ad6(%rip), %rsi # 0x3cb95
callq 0x9190
testl %eax, %eax
je 0x131ad
leaq 0x40565(%rip), %rdi # 0x53638
leaq 0x28936(%rip), %rsi # 0x3ba10
callq 0x9190
testl %eax, %eax
je 0x132fc
leaq 0x29e7d(%rip), %rsi # 0x3cf6b
leaq 0x40543(%rip), %rdx # 0x53638
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x3062a
leaq 0x29e7d(%rip), %rsi # 0x3cf86
movq %rbx, %rdi
callq 0x9ac0
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x134c0
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0x134c7
leaq 0xb8(%rsp), %rbx
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x30307
leaq 0x29dd7(%rip), %rcx # 0x3cf32
movl $0x12, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x95d0
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x13212
movq %rdx, 0x90(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xa0(%rsp)
jmp 0x13219
movq $0x0, (%rbx)
jmp 0x1335b
movl $0x50, %edi
callq 0x94d0
movq %rax, %r14
leaq 0x3f7bf(%rip), %rax # 0x52980
leaq 0xf0(%rsp), %rdx
movq %rax, (%rdx)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rdx)
movq 0x10(%r12), %rax
movq %rax, 0x10(%rdx)
movq $0x0, 0x8(%r12)
leaq 0x3f51a(%rip), %rax # 0x52708
movq %rax, (%rdx)
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rcx
movl %ebp, %r8d
callq 0x30534
movq %r14, (%rbx)
leaq 0xf0(%rsp), %rdi
jmp 0x13356
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x90(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x29d06(%rip), %rsi # 0x3cf45
callq 0x9ac0
leaq 0x60(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1326c
movq %rdx, 0x50(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x60(%rsp)
jmp 0x13274
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x58(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x24(%r14), %eax
leaq 0xb4(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x70(%rsp), %rdi
callq 0x30307
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %r8
movq 0x78(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x132c6
movq 0x60(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x132eb
leaq 0x80(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x132e6
movq 0x80(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x13362
movq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x91a0
jmp 0x13370
movl $0x40, %edi
callq 0x94d0
movq %rax, %r14
leaq 0x3f670(%rip), %rax # 0x52980
leaq 0xd8(%rsp), %rdx
movq %rax, (%rdx)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rdx)
movq 0x10(%r12), %rax
movq %rax, 0x10(%rdx)
movq $0x0, 0x8(%r12)
leaq 0x3f3cb(%rip), %rax # 0x52708
movq %rax, (%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x305ba
movq %r14, (%rbx)
leaq 0xd8(%rsp), %rdi
callq 0x302ce
movb $0x1, %al
jmp 0x13523
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x95d0
leaq 0x20(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x13394
movq %rsi, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x1339a
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x2aa07(%rip), %rsi # 0x3ddc5
leaq 0x10(%rsp), %rdi
callq 0x9ac0
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x133ef
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0x133f6
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x30(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x4026f(%rip), %rdi # 0x53688
callq 0x92c0
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x13435
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x9500
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13450
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9500
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13471
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x13488
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x134a5
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x9500
leaq 0xc8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13521
movq 0xc8(%rsp), %rsi
jmp 0x13519
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x30(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x4019e(%rip), %rdi # 0x53688
callq 0x92c0
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x13506
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x9500
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13521
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9500
xorl %eax, %eax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x302ce
movl $0x40, %esi
jmp 0x13561
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x302ce
movl $0x50, %esi
movq %r14, %rdi
jmp 0x13663
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x13588
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x13588
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13668
movq 0x20(%rsp), %rsi
jmp 0x13660
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x135c3
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x135c3
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x135e3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x135e3
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13609
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x13609
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x13625
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x13625
movq %rax, %rbx
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x13647
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x13647
movq %rax, %rbx
leaq 0xc8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13668
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::FilePath::RemoveDirectoryName() const | FilePath FilePath::RemoveDirectoryName() const {
const char* const last_sep = FindLastPathSeparator();
return last_sep ? FilePath(last_sep + 1) : *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %r15
movq %r15, %rdi
movl $0x2f, %esi
callq 0x95a0
movq %rax, %r14
testq %rax, %rax
setne %bpl
je 0x13c84
leaq 0x1(%r14), %r15
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r15, %rdi
callq 0x9230
leaq (%r14,%rax), %rdx
incq %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x37c48
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xc86c
movq %rbx, %rdi
callq 0x14890
jmp 0x13c9e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%r12), %rdx
addq %r15, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc86c
testq %r14, %r14
je 0x13cbe
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13cbe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %bpl
jmp 0x13cfc
movq %rax, %rbx
testq %r14, %r14
je 0x13cfc
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
movb $0x1, %bpl
cmpq %rax, %rdi
je 0x13cfc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
testb %bpl, %bpl
movq %rbx, %rdi
callq 0x99e0
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-filepath.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3db42(%rip), %r14 # 0x52738
movq %r14, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xc86c
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xc86c
leaq 0x3dea9(%rip), %rax # 0x52ae8
movq %rax, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
leaq 0x3df9d(%rip), %rax # 0x52bf0
movq %rax, 0x48(%rsp)
movl $0x28, %edi
callq 0x94d0
movl $0x1, (%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq (%rsp), %rdx
cmpq %r12, %rdx
je 0x14c8b
movq %rdx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x14c93
movups (%r12), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %r12, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rsi
movq %rax, 0x10(%rsi)
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x34974
leaq 0x40(%rsp), %rdi
callq 0x37f58
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x14ce2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x14cf9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x9500
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x37f58
jmp 0x14d17
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x14d32
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x14d32
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x14d4e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x14d4e
movq %rax, %r14
movq %rbx, %rdi
callq 0x37f58
movq %r14, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::Matcher(char const*) | Matcher<const internal::StringView&>::Matcher(const char* s) {
*this = Eq(std::string(s));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3d6f0(%rip), %r14 # 0x52768
movq %r14, (%rdi)
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30290
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xc86c
leaq 0x3da67(%rip), %rax # 0x52b18
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsp)
leaq 0x3db4b(%rip), %rax # 0x52c10
movq %rax, 0x30(%rsp)
movl $0x28, %edi
callq 0x94d0
movl $0x1, (%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdx
cmpq %r15, %rdx
je 0x150fe
movq %rdx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x15105
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %r15, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x28(%rsp), %rsi
movq %rax, 0x10(%rsi)
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x349ca
leaq 0x28(%rsp), %rdi
callq 0x37faa
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x15156
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15171
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x9500
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x37faa
jmp 0x1518d
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x151a9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x151a9
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x151c9
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x151c9
movq %rax, %r14
movq %rbx, %rdi
callq 0x37faa
movq %r14, %rdi
callq 0x99e0
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::Matcher(std::basic_string_view<char, std::char_traits<char>>) | Matcher<const internal::StringView&>::Matcher(internal::StringView s) {
*this = Eq(std::string(s));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3d572(%rip), %r14 # 0x52768
movq %r14, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq (%rsi,%rdx), %rax
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x37c48
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xc86c
leaq 0x3d8dc(%rip), %rax # 0x52b18
movq %rax, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
leaq 0x3d9c0(%rip), %rax # 0x52c10
movq %rax, 0x48(%rsp)
movl $0x28, %edi
callq 0x94d0
movl $0x1, (%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq (%rsp), %rdx
cmpq %r12, %rdx
je 0x15288
movq %rdx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x15290
movups (%r12), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %r12, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rsi
movq %rax, 0x10(%rsi)
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x349ca
leaq 0x40(%rsp), %rdi
callq 0x37faa
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x152df
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x152f6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x9500
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x37faa
jmp 0x15314
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1532f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x1532f
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1534b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x1534b
movq %rax, %r14
movq %rbx, %rdi
callq 0x37faa
movq %r14, %rdi
callq 0x99e0
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3d420(%rip), %r14 # 0x52798
movq %r14, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xc86c
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xc86c
leaq 0x3d787(%rip), %rax # 0x52b48
movq %rax, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
leaq 0x3d85b(%rip), %rax # 0x52c30
movq %rax, 0x48(%rsp)
movl $0x28, %edi
callq 0x94d0
movl $0x1, (%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq (%rsp), %rdx
cmpq %r12, %rdx
je 0x1540d
movq %rdx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x15415
movups (%r12), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %r12, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rsi
movq %rax, 0x10(%rsi)
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x34a20
leaq 0x40(%rsp), %rdi
callq 0x37ffc
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x15464
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1547b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x9500
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x37ffc
jmp 0x15499
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x154b4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x154b4
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x154d0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x154d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x37ffc
movq %r14, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::internal::GetBoolAssertionFailureMessage[abi:cxx11](testing::AssertionResult const&, char const*, char const*, char const*) | std::string GetBoolAssertionFailureMessage(
const AssertionResult& assertion_result, const char* expression_text,
const char* actual_predicate_value, const char* expected_predicate_value) {
const char* actual_message = assertion_result.message();
Message msg;
msg << "Value of: " << expression_text
<< "\n Actual: " << actual_predicate_value;
if (actual_message[0] != '\0') msg << " (" << actual_message << ")";
msg << "\nExpected: " << expected_predicate_value;
return msg.GetString();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x15ab1
movq (%rax), %r13
jmp 0x15ab8
leaq 0x284f1(%rip), %r13 # 0x3dfa9
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1bce0
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x27d24(%rip), %rsi # 0x3d7f7
movl $0xa, %edx
movq %r12, %rdi
callq 0x95f0
testq %rbx, %rbx
je 0x15af2
movq %rbx, %rdi
callq 0x9230
movq %rax, %rdx
jmp 0x15afe
movl $0x6, %edx
leaq 0x27e9e(%rip), %rbx # 0x3d99c
movq %r12, %rdi
movq %rbx, %rsi
callq 0x95f0
leaq 0x27cf2(%rip), %rsi # 0x3d802
movl $0xb, %edx
movq %r12, %rdi
callq 0x95f0
testq %rbp, %rbp
je 0x15b2f
movq %rbp, %rdi
callq 0x9230
movq %rax, %rdx
jmp 0x15b3b
movl $0x6, %edx
leaq 0x27e61(%rip), %rbp # 0x3d99c
movq %r12, %rdi
movq %rbp, %rsi
callq 0x95f0
cmpb $0x0, (%r13)
je 0x15b8b
leaq 0x27e06(%rip), %rsi # 0x3d95a
movl $0x2, %edx
movq %r12, %rdi
callq 0x95f0
movq %r13, %rdi
callq 0x9230
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x95f0
leaq 0x28247(%rip), %rsi # 0x3ddc5
movl $0x1, %edx
movq %r12, %rdi
callq 0x95f0
leaq 0x27c7c(%rip), %rsi # 0x3d80e
movl $0xb, %edx
movq %r12, %rdi
callq 0x95f0
testq %r15, %r15
je 0x15bb1
movq %r15, %rdi
callq 0x9230
movq %rax, %rdx
jmp 0x15bbd
movl $0x6, %edx
leaq 0x27ddf(%rip), %r15 # 0x3d99c
movq %r12, %rdi
movq %r15, %rsi
callq 0x95f0
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1bf43
testq %r14, %r14
je 0x15be3
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0x15c08
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::ReadEntireFile[abi:cxx11](_IO_FILE*) | std::string ReadEntireFile(FILE* file) {
const size_t file_size = GetFileSize(file);
char* const buffer = new char[file_size];
size_t bytes_last_read = 0; // # of bytes read in the last fread()
size_t bytes_read = 0; // # of bytes read so far
fseek(file, 0, SEEK_SET);
// Keeps reading the file until we cannot read further or the
// pre-determined file size is reached.
do {
bytes_last_read =
fread(buffer + bytes_read, 1, file_size - bytes_read, file);
bytes_read += bytes_last_read;
} while (bytes_last_read > 0 && bytes_read < file_size);
const std::string content(buffer, bytes_read);
delete[] buffer;
return content;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x95b0
movq %r14, %rdi
callq 0x9030
movq %rax, %r12
movq %rax, %rdi
callq 0x9050
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x95b0
leaq (%r15,%r13), %rdi
movq %r12, %rdx
subq %r13, %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x9890
addq %rax, %r13
testq %rax, %rax
je 0x16546
cmpq %r12, %r13
jb 0x16522
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r15, %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37c48
movq %r15, %rdi
callq 0x9740
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc |
testing::internal::FlagToEnvVar[abi:cxx11](char const*) | static std::string FlagToEnvVar(const char* flag) {
const std::string full_flag =
(Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
Message env_var;
for (size_t i = 0; i != full_flag.length(); i++) {
env_var << ToUpper(full_flag.c_str()[i]);
}
return env_var.GetString();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1bce0
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x265d9(%rip), %rsi # 0x3cf08
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
callq 0x95f0
testq %r15, %r15
je 0x16954
movq %r15, %rdi
callq 0x9230
movq %rax, %r13
jmp 0x1695b
leaq 0x27041(%rip), %r15 # 0x3d99c
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x95f0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x1bf43
testq %r14, %r14
je 0x16984
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x1bce0
cmpq $0x0, 0x18(%rsp)
je 0x169d4
movq 0x8(%rsp), %r14
addq $0x10, %r14
xorl %r12d, %r12d
leaq 0x7(%rsp), %r15
movq 0x10(%rsp), %rax
movzbl (%rax,%r12), %edi
callq 0x9a60
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x95f0
incq %r12
cmpq 0x18(%rsp), %r12
jne 0x169a7
movq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1bf43
testq %r14, %r14
je 0x169f2
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16a0d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x16a38
movq %rax, %rbx
jmp 0x16a54
movq %rax, %rbx
testq %r14, %r14
je 0x16a6f
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x16a6f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x16a4b
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16a6f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc |
testing::internal::PrintBytesInObjectTo(unsigned char const*, unsigned long, std::ostream*) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
ostream* os) {
PrintBytesInObjectToImpl(obj_bytes, count, os);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x9340
leaq 0x27e3f(%rip), %rsi # 0x3eb9f
movl $0xe, %edx
movq %rax, %rdi
callq 0x95f0
cmpq $0x83, %r14
ja 0x16d7d
movq %r15, %rdi
xorl %esi, %esi
jmp 0x16db1
movl $0x40, %edx
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x2ee7a
leaq 0x27e18(%rip), %rsi # 0x3ebae
movl $0x5, %edx
movq %rbx, %rdi
callq 0x95f0
leaq -0x3f(%r14), %rsi
andq $-0x2, %rsi
subq %rsi, %r14
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2ee7a
leaq 0x27472(%rip), %rsi # 0x3e235
movl $0x1, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x95f0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(char32_t, std::ostream*) | void PrintTo(char32_t c, ::std::ostream* os) {
*os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4)
<< static_cast<uint32_t>(c);
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rsi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rsi,%rax)
leaq 0x26399(%rip), %rsi # 0x3d1a2
movl $0x2, %edx
movq %rbx, %rdi
callq 0x95f0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
orl $0x4000, 0x18(%rbx,%rcx) # imm = 0x4000
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r14
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0x16e53
movq %r14, %rdi
movl $0x20, %esi
callq 0x94b0
movb %al, 0xe0(%r14)
movb $0x1, 0xe1(%r14)
movb $0x30, 0xe0(%r14)
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x4, 0x10(%rbx,%rax)
movl %ebp, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9340
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(char32_t const*, std::ostream*) | void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x171b9
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x93e0
leaq 0x28207(%rip), %rsi # 0x3f38e
movl $0xd, %edx
movq %rax, %rdi
callq 0x95f0
movq $-0x1, %rsi
cmpl $0x0, 0x4(%r14,%rsi,4)
leaq 0x1(%rsi), %rsi
jne 0x1719b
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1764f
leaq 0x280cd(%rip), %rsi # 0x3f28d
movl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x95f0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(wchar_t const*, std::ostream*) | void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x1721f
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x93e0
leaq 0x28199(%rip), %rsi # 0x3f38e
movl $0xd, %edx
movq %rax, %rdi
callq 0x95f0
movq %r14, %rdi
callq 0x9430
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1773f
leaq 0x28067(%rip), %rsi # 0x3f28d
movl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x95f0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::operator<<(std::ostream&, testing::TestPartResult const&) | std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
return os << internal::FormatFileLocation(result.file_name(),
result.line_number())
<< " "
<< (result.type() == TestPartResult::kSuccess ? "Success"
: result.type() == TestPartResult::kSkip ? "Skipped"
: result.type() == TestPartResult::kFatalFailure
? "Fatal failure"
: "Non-fatal failure")
<< ":\n"
<< result.message() << std::endl;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x178a6
movq 0x8(%r14), %rsi
movl 0x28(%r14), %edx
movq %rsp, %r15
movq %r15, %rdi
callq 0x15d01
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x95f0
movq %rax, %rbx
leaq 0x25efb(%rip), %rsi # 0x3d7c9
movl $0x1, %edx
movq %rax, %rdi
callq 0x95f0
movl (%r14), %eax
testl %eax, %eax
je 0x178f0
cmpl $0x3, %eax
jne 0x178f9
leaq 0x258bf(%rip), %r15 # 0x3d1ad
jmp 0x1790e
leaq 0x258ae(%rip), %r15 # 0x3d1a5
jmp 0x1790e
cmpl $0x2, %eax
leaq 0x258b2(%rip), %rax # 0x3d1b5
leaq 0x258b9(%rip), %r15 # 0x3d1c3
cmoveq %rax, %r15
movq %r15, %rdi
callq 0x9230
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x95f0
leaq 0x25500(%rip), %rsi # 0x3ce2b
movl $0x2, %edx
movq %rbx, %rdi
callq 0x95f0
movq 0x50(%r14), %r14
testq %r14, %r14
je 0x17959
movq %r14, %rdi
callq 0x9230
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x95f0
jmp 0x17972
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x9980
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x94b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9350
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x179b7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x179e2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-test-part.cc |
testing::internal::HasNewFatalFailureHelper::~HasNewFatalFailureHelper() | HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
original_reporter_);
} | pushq %rbx
movq %rdi, %rbx
leaq 0x3a313(%rip), %rax # 0x51dd8
movq %rax, (%rdi)
callq 0x1832e
movq 0x10(%rbx), %rbx
movl $0x90, %edi
addq 0x3bd13(%rip), %rdi # 0x537f0
callq 0x38e58
movq %rbx, (%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x30730
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-test-part.cc |
testing::internal::AssertHelper::~AssertHelper() | AssertHelper::~AssertHelper() { delete data_; } | pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x1832b
movq 0x18(%rbx), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x1831d
movq (%rax), %rsi
incq %rsi
callq 0x9500
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x9500
popq %rbx
retq
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop[abi:cxx11](int) | std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
return os_stack_trace_getter()->CurrentStackTrace(
static_cast<int>(GTEST_FLAG_GET(stack_trace_depth)), skip_count + 1
// Skips the user-specified number of frames plus this function
// itself.
); // NOLINT
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x210(%rsi)
jne 0x188d7
movl $0x8, %edi
callq 0x94d0
leaq 0x39833(%rip), %rcx # 0x52100
movq %rcx, (%rax)
movq %rax, 0x210(%r14)
movq 0x210(%r14), %rsi
movl 0x3ae5c(%rip), %edx # 0x53740
incl %ebp
movq (%rsi), %rax
movq %rbx, %rdi
movl %ebp, %ecx
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestOptions::MatchesFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | bool UnitTestOptions::MatchesFilter(const std::string& name_str,
const char* filter) {
return UnitTestFilter(filter).MatchesName(name_str);
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x30290
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x1a786
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x1a894
movl %eax, %ebx
leaq 0x40(%rsp), %rdi
callq 0x35678
leaq 0x28(%rsp), %rdi
callq 0x30492
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a73d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x35678
leaq 0x28(%rsp), %rdi
callq 0x30492
jmp 0x1a763
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a77e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestSuite::successful_test_count() const | void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
TestPartResultReporterInterface* reporter) {
per_thread_test_part_result_reporter_.set(reporter);
} | pushq %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %r14
cmpq 0x38(%rdi), %r14
je 0x1b858
movq %rdi, %rbx
xorl %ebp, %ebp
movq (%r14), %rdi
callq 0x32bea
movzbl %al, %eax
addl %eax, %ebp
addq $0x8, %r14
cmpq 0x38(%rbx), %r14
jne 0x1b83f
jmp 0x1b85a
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestSuite::failed_test_count() const | void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
TestPartResultReporterInterface* reporter) {
per_thread_test_part_result_reporter_.set(reporter);
} | pushq %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %r14
cmpq 0x38(%rdi), %r14
je 0x1b98d
movq %rdi, %rbx
xorl %ebp, %ebp
movq (%r14), %rdi
cmpb $0x1, 0x80(%rdi)
movl $0x0, %eax
jne 0x1b97f
addq $0x90, %rdi
callq 0x1f248
movzbl %al, %eax
addl %eax, %ebp
addq $0x8, %r14
cmpq 0x38(%rbx), %r14
jne 0x1b95f
jmp 0x1b98f
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::edit_distance::CreateUnifiedDiff(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, unsigned long) | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
const std::vector<std::string>& right,
size_t context) {
const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
size_t l_i = 0, r_i = 0, edit_i = 0;
std::stringstream ss;
while (edit_i < edits.size()) {
// Find first edit.
while (edit_i < edits.size() && edits[edit_i] == kMatch) {
++l_i;
++r_i;
++edit_i;
}
// Find the first line to include in the hunk.
const size_t prefix_context = std::min(l_i, context);
Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);
for (size_t i = prefix_context; i > 0; --i) {
hunk.PushLine(' ', left[l_i - i].c_str());
}
// Iterate the edits until we found enough suffix for the hunk or the input
// is over.
size_t n_suffix = 0;
for (; edit_i < edits.size(); ++edit_i) {
if (n_suffix >= context) {
// Continue only if the next hunk is very close.
auto it = edits.begin() + static_cast<int>(edit_i);
while (it != edits.end() && *it == kMatch) ++it;
if (it == edits.end() ||
static_cast<size_t>(it - edits.begin()) - edit_i >= context) {
// There is no next edit or it is too far away.
break;
}
}
EditType edit = edits[edit_i];
// Reset count when a non match is found.
n_suffix = edit == kMatch ? n_suffix + 1 : 0;
if (edit == kMatch || edit == kRemove || edit == kReplace) {
hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str());
}
if (edit == kAdd || edit == kReplace) {
hunk.PushLine('+', right[r_i].c_str());
}
// Advance indices, depending on edit type.
l_i += edit != kAdd;
r_i += edit != kRemove;
}
if (!hunk.has_edits()) {
// We are done. We don't want this hunk.
break;
}
hunk.PrintTo(&ss);
}
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rcx, 0x8(%rsp)
movq %rdi, 0xa0(%rsp)
leaq 0x10(%rsp), %rdi
movq %rsi, 0x98(%rsp)
movq %rdx, 0xa8(%rsp)
callq 0x1c48a
leaq 0xb0(%rsp), %rdi
callq 0x9370
leaq 0x50(%rsp), %r12
leaq 0x68(%rsp), %rbp
xorl %ebx, %ebx
xorl %r13d, %r13d
xorl %r14d, %r14d
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %rax, %r13
jae 0x1cb55
leaq (%rbx,%rax), %rdx
subq %r13, %rdx
leaq (%r14,%rax), %rsi
subq %r13, %rsi
cmpl $0x0, (%rcx,%r13,4)
jne 0x1c733
incq %rbx
incq %r14
incq %r13
cmpq %r13, %rax
jne 0x1c715
movq %rdx, %rbx
movq %rax, %r13
movq %rsi, %r14
movq 0x8(%rsp), %r15
cmpq %r15, %rbx
cmovbq %rbx, %r15
movq %rbx, %rax
subq %r15, %rax
incq %rax
movq %r14, %rcx
subq %r15, %rcx
incq %rcx
movq %rax, 0x28(%rsp)
movq %rcx, 0x30(%rsp)
leaq 0x38(%rsp), %rax
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r12, 0x58(%rsp)
movq %r12, 0x50(%rsp)
movq %rcx, 0x60(%rsp)
movq %rbp, 0x70(%rsp)
movq %rbp, 0x68(%rsp)
movq %rcx, 0x78(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, 0x88(%rsp)
movq %rax, 0x80(%rsp)
movq %rcx, 0x90(%rsp)
testq %r15, %r15
je 0x1c7e7
movq %rbx, %r12
shlq $0x5, %r12
movq %r15, %rax
shlq $0x5, %rax
subq %rax, %r12
movq 0x98(%rsp), %rax
movq (%rax), %rax
movq (%rax,%r12), %rdx
leaq 0x28(%rsp), %rdi
movl $0x20, %esi
callq 0x1cc18
addq $0x20, %r12
decq %r15
jne 0x1c7c0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rdx, %r13
jae 0x1c912
xorl %r15d, %r15d
cmpq 0x8(%rsp), %r15
jb 0x1c843
movslq %r13d, %rdx
leaq (%rax,%rdx,4), %rdx
cmpq %rcx, %rdx
je 0x1c825
cmpl $0x0, (%rdx)
jne 0x1c825
addq $0x4, %rdx
jmp 0x1c815
cmpq %rcx, %rdx
je 0x1c912
subq %rax, %rdx
sarq $0x2, %rdx
subq %r13, %rdx
cmpq 0x8(%rsp), %rdx
jae 0x1c912
movl (%rax,%r13,4), %ebp
incq %r15
testl %ebp, %ebp
movl $0x0, %eax
cmovneq %rax, %r15
cmpl $0x3, %ebp
ja 0x1c88e
cmpl $0x1, %ebp
je 0x1c88e
movq %rbx, %rax
shlq $0x5, %rax
testl %ebp, %ebp
movq 0x98(%rsp), %rcx
movq (%rcx), %rcx
movq (%rcx,%rax), %rdx
movl $0x2d, %esi
movl $0x20, %eax
cmovel %eax, %esi
leaq 0x28(%rsp), %rdi
callq 0x1cc18
movl %ebp, %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x1c8d7
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq %r14, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %r12
incq 0x38(%rsp)
movl $0x20, %edi
callq 0x94d0
movb $0x2b, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rax, %rdi
leaq 0x68(%rsp), %rsi
callq 0x90c0
incq 0x78(%rsp)
xorl %eax, %eax
cmpl $0x1, %ebp
setne %al
addq %rax, %rbx
xorl %eax, %eax
cmpl $0x2, %ebp
setne %al
addq %rax, %r14
incq %r13
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rdx, %r13
leaq 0x68(%rsp), %rbp
jb 0x1c807
movq 0x40(%rsp), %rax
orq 0x38(%rsp), %rax
setne 0x6(%rsp)
je 0x1cadd
movl $0x3, %edx
leaq 0xc0(%rsp), %rdi
leaq 0x223fe(%rip), %rsi # 0x3ed39
callq 0x95f0
cmpq $0x0, 0x40(%rsp)
je 0x1c99c
movl $0x1, %edx
leaq 0xc0(%rsp), %rdi
leaq 0x21e06(%rip), %rsi # 0x3e762
callq 0x95f0
movq 0x28(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x9340
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0x223b8(%rip), %rsi # 0x3ed3d
callq 0x95f0
movq 0x48(%rsp), %rsi
addq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x9340
cmpq $0x0, 0x40(%rsp)
je 0x1c9c5
cmpq $0x0, 0x38(%rsp)
je 0x1c9c5
movl $0x1, %edx
leaq 0xc0(%rsp), %rdi
leaq 0x20e09(%rip), %rsi # 0x3d7c9
callq 0x95f0
cmpq $0x0, 0x38(%rsp)
je 0x1ca21
movl $0x1, %edx
leaq 0xc0(%rsp), %rdi
leaq 0x207c2(%rip), %rsi # 0x3d1a3
callq 0x95f0
movq 0x30(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x9340
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0x22333(%rip), %rsi # 0x3ed3d
callq 0x95f0
movq 0x48(%rsp), %rsi
addq 0x38(%rsp), %rsi
movq %r15, %rdi
callq 0x9340
movl $0x4, %edx
leaq 0xc0(%rsp), %rdi
leaq 0x2230a(%rip), %rsi # 0x3ed3f
callq 0x95f0
leaq 0x28(%rsp), %rdi
callq 0x2f0cc
movq 0x50(%rsp), %r12
leaq 0x50(%rsp), %rax
cmpq %rax, %r12
je 0x1cadd
movb 0x10(%r12), %al
movb %al, 0x7(%rsp)
movl $0x1, %edx
leaq 0xc0(%rsp), %rdi
leaq 0x7(%rsp), %rsi
callq 0x95f0
movq %rax, %r15
movq 0x18(%r12), %rbp
testq %rbp, %rbp
je 0x1caa1
movq %rbp, %rdi
callq 0x9230
movq %r15, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x95f0
leaq 0x68(%rsp), %rbp
jmp 0x1cac0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x9980
leaq 0x68(%rsp), %rbp
movl $0x1, %edx
movq %r15, %rdi
leaq 0x214d9(%rip), %rsi # 0x3dfa8
callq 0x95f0
movq (%r12), %r12
jmp 0x1ca49
movq 0x80(%rsp), %rdi
leaq 0x80(%rsp), %r12
cmpq %r12, %rdi
je 0x1cb07
movq (%rdi), %r15
movl $0x20, %esi
callq 0x9500
movq %r15, %rdi
cmpq %r12, %r15
jne 0x1caf2
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
leaq 0x50(%rsp), %r12
je 0x1cb2b
movq (%rdi), %r15
movl $0x20, %esi
callq 0x9500
movq %r15, %rdi
cmpq %rbp, %r15
jne 0x1cb16
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x1cb4a
movq (%rdi), %r15
movl $0x20, %esi
callq 0x9500
movq %r15, %rdi
cmpq %r12, %r15
jne 0x1cb35
cmpb $0x0, 0x6(%rsp)
jne 0x1c6ed
leaq 0xc8(%rsp), %rsi
movq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0x9920
movq 0x36424(%rip), %rsi # 0x52f98
leaq 0xb0(%rsp), %rdi
callq 0x93c0
leaq 0x130(%rsp), %rdi
callq 0x91c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1cba5
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x9500
movq %rbx, %rax
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1cbd7
movq %rax, %rbx
jmp 0x1cbf8
jmp 0x1cbca
jmp 0x1cbca
jmp 0x1cbca
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1cca0
movq 0x363ba(%rip), %rsi # 0x52f98
leaq 0xb0(%rsp), %rdi
callq 0x93c0
leaq 0x130(%rsp), %rdi
callq 0x91c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1cc0f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x99e0
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::SplitEscapedString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::vector<std::string> SplitEscapedString(const std::string& str) {
std::vector<std::string> lines;
size_t start = 0, end = str.size();
if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
++start;
--end;
}
bool escaped = false;
for (size_t i = start; i + 1 < end; ++i) {
if (escaped) {
escaped = false;
if (str[i] == 'n') {
lines.push_back(str.substr(start, i - start - 1));
start = i + 1;
}
} else {
escaped = str[i] == '\\';
}
}
lines.push_back(str.substr(start, end - start));
return lines;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
cmpq $0x3, %r15
jb 0x1d079
movq (%r14), %rax
cmpb $0x22, (%rax)
jne 0x1d079
xorl %edx, %edx
cmpb $0x22, -0x1(%rax,%r15)
leaq -0x1(%r15), %rax
sete %dl
cmoveq %rax, %r15
jmp 0x1d07b
xorl %edx, %edx
leaq 0x1(%rdx), %rbp
cmpq %r15, %rbp
jae 0x1d0f0
leaq 0x18(%rsp), %r13
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movq (%r14), %rcx
movb -0x1(%rcx,%rbp), %cl
testb $0x1, %al
je 0x1d0de
cmpb $0x6e, %cl
jne 0x1d0e6
movq %rbp, %rcx
subq %rdx, %rcx
addq $-0x2, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x9540
movq %rbx, %rdi
movq %r12, %rsi
callq 0x387f6
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d0d7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
xorl %eax, %eax
movq %rbp, %rdx
jmp 0x1d0e8
cmpb $0x5c, %cl
sete %al
jmp 0x1d0e8
xorl %eax, %eax
incq %rbp
cmpq %rbp, %r15
jne 0x1d090
subq %rdx, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x9540
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x387f6
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d12b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x1d15f
jmp 0x1d171
jmp 0x1d16e
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d171
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x1d171
movq %rax, %r14
movq %rbx, %rdi
callq 0x30492
movq %r14, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<wchar_t const*>(bool, char const*, char const*, wchar_t const* const&, wchar_t const* const&) | AssertionResult IsSubstringImpl(bool expected_to_be_substring,
const char* needle_expr,
const char* haystack_expr,
const StringType& needle,
const StringType& haystack) {
if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
return AssertionSuccess();
const bool is_wide_string = sizeof(needle[0]) > 1;
const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
return AssertionFailure()
<< "Value of: " << needle_expr << "\n"
<< " Actual: " << begin_string_quote << needle << "\"\n"
<< "Expected: " << (expected_to_be_substring ? "" : "not ")
<< "a substring of " << haystack_expr << "\n"
<< "Which is: " << begin_string_quote << haystack << "\"";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r9, %r15
movq %r8, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq (%r8), %rsi
movq (%r9), %rdi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %cl, %al
jne 0x1dc3a
cmpq %rdi, %rsi
sete %al
jmp 0x1dc45
callq 0x9680
testq %rax, %rax
setne %al
cmpb %bpl, %al
je 0x1dd7d
leaq 0x2176d(%rip), %rax # 0x3f3c2
movq %rax, (%rsp)
leaq 0x10(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x1fb86(%rip), %rsi # 0x3d7f7
leaq 0x8(%rsp), %rdi
callq 0x35726
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x3124a
leaq 0x20319(%rip), %rsi # 0x3dfa8
movq %rax, %rdi
callq 0x31838
leaq 0x1fb65(%rip), %rsi # 0x3d803
movq %rax, %rdi
callq 0x35726
movq %rsp, %rsi
movq %rax, %rdi
callq 0x3124a
movq %rax, %rdi
movq %r12, %rsi
callq 0x395ec
leaq 0x206e7(%rip), %rsi # 0x3e3aa
movq %rax, %rdi
callq 0x31544
leaq 0x1fb3d(%rip), %rsi # 0x3d80f
movq %rax, %rdi
callq 0x35726
leaq 0x202c8(%rip), %rcx # 0x3dfa9
leaq 0x216c5(%rip), %rdx # 0x3f3ad
testb %bpl, %bpl
cmovneq %rcx, %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0x3124a
leaq 0x216ac(%rip), %rsi # 0x3f3b2
movq %rax, %rdi
callq 0x3956e
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x3124a
leaq 0x20286(%rip), %rsi # 0x3dfa8
movq %rax, %rdi
callq 0x31838
leaq 0x1fa9f(%rip), %rsi # 0x3d7d0
movq %rax, %rdi
callq 0x35726
movq %rsp, %rsi
movq %rax, %rdi
callq 0x3124a
movq %rax, %rdi
movq %r15, %rsi
callq 0x395ec
leaq 0x20641(%rip), %rsi # 0x3e397
movq %rax, %rdi
callq 0x31838
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd074
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x1dd88
movq %r14, %rdi
callq 0xc94c
jmp 0x1dd88
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1dd9a
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x1ddaf
movq %r14, %rdi
callq 0xc94c
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestResult::GetTestPartResult(int) const | const TestPartResult& TestResult::GetTestPartResult(int i) const {
if (i < 0 || i >= total_part_count()) internal::posix::Abort();
return test_part_results_.at(static_cast<size_t>(i));
} | pushq %rax
testl %esi, %esi
js 0x1eb63
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
imull $0xb6db6db7, %ecx, %ecx # imm = 0xB6DB6DB7
cmpl %esi, %ecx
jle 0x1eb63
movl %esi, %esi
movq 0x40(%rdi), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x1eb68
imulq $0x70, %rsi, %rcx
addq %rcx, %rax
popq %rcx
retq
callq 0x3073b
leaq 0x20856(%rip), %rdi # 0x3f3c5
xorl %eax, %eax
callq 0x98b0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestResult::Clear() | void TestResult::Clear() {
test_part_results_.clear();
test_properties_.clear();
death_test_count_ = 0;
elapsed_time_ = 0;
} | pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x38(%rbx), %rsi
callq 0x3971c
leaq 0x50(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x39c5c
movl $0x0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
popq %rbx
retq
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::ReportFailureInUnknownLocation(testing::TestPartResult::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
const std::string& message) {
// This function is a friend of UnitTest and as such has access to
// AddTestPartResult.
UnitTest::GetInstance()->AddTestPartResult(
result_type,
nullptr, // No info about the source file where the exception occurred.
-1, // We have no info on which line caused the exception.
message,
""); // No stack trace, either.
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
callq 0x1832e
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ea6d(%rip), %rdx # 0x3dfa9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x37c48
leaq 0x3425d(%rip), %rdi # 0x537b0
movl %ebp, %esi
xorl %edx, %edx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movq %rbx, %r8
movq %r14, %r9
callq 0x1839e
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1f57e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1f5a3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x99e0
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void PrettyUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
switch (result.type()) {
// If the test part succeeded, we don't need to do anything.
case TestPartResult::kSuccess:
return;
default:
// Print failure message from the assertion
// (e.g. expected this and got that).
PrintTestPartResult(result);
fflush(stdout);
}
} | cmpl $0x0, (%rsi)
je 0x21e58
pushq %rax
movq %rsi, %rdi
callq 0x21e59
movq 0x31141(%rip), %rax # 0x52f90
movq (%rax), %rdi
popq %rax
jmp 0x9640
retq
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&) | void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
if (test_info.result()->Passed()) {
ColoredPrintf(GTestColor::kGreen, "[ OK ] ");
} else if (test_info.result()->Skipped()) {
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
} else {
ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
}
PrintTestName(test_info.test_suite_name(), test_info.name());
if (test_info.result()->Failed()) PrintFullTestCommentIfPresent(test_info);
if (GTEST_FLAG_GET(print_time)) {
printf(" (%s ms)\n",
internal::StreamableToString(test_info.result()->elapsed_time())
.c_str());
} else {
printf("\n");
}
fflush(stdout);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %r14
movq %r14, %rdi
callq 0x1f20c
testb %al, %al
jne 0x21ecd
movq %r14, %rdi
callq 0x1f248
testb %al, %al
je 0x21ef0
movq %r14, %rdi
callq 0x1f20c
testb %al, %al
je 0x21ee2
leaq 0x1c089(%rip), %rsi # 0x3df69
jmp 0x21ef7
leaq 0x1c08e(%rip), %rsi # 0x3df77
movl $0x1, %edi
jmp 0x21efc
leaq 0x1c064(%rip), %rsi # 0x3df5b
movl $0x2, %edi
xorl %eax, %eax
callq 0x21426
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x1c0ac(%rip), %rdi # 0x3dfbd
xorl %eax, %eax
callq 0x90a0
movq %r14, %rdi
callq 0x1f248
testb %al, %al
je 0x21f2c
movq %rbx, %rdi
callq 0x21f9d
cmpb $0x1, 0x317fe(%rip) # 0x53731
jne 0x21f7c
movq 0x108(%rbx), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x32dba
movq (%rbx), %rsi
leaq 0x1c02c(%rip), %rdi # 0x3df85
xorl %eax, %eax
callq 0x90a0
movq (%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x21f86
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x21f86
movl $0xa, %edi
callq 0x97e0
movq 0x31003(%rip), %rax # 0x52f90
movq (%rax), %rdi
callq 0x9640
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::~TestEventRepeater() | TestEventRepeater::~TestEventRepeater() {
ForEach(listeners_, Delete<TestEventListener>);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2f201(%rip), %rax # 0x51ed8
movq %rax, (%rdi)
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x22cfb
movq (%r14), %rdi
testq %rdi, %rdi
je 0x22cf5
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x22ce2
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x22d15
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x9500
popq %rbx
popq %r14
popq %r15
retq
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::ListTestsMatchingFilter(std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
const std::vector<TestSuite*>& test_suites) {
FILE* xmlout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintXmlTestsList(&stream, test_suites);
fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
fclose(xmlout);
} | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x23380
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9370
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x23c2e
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x1bf43
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x95c0
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x23bd2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x94c0
movq 0x2f3b7(%rip), %rsi # 0x52f98
leaq 0x20(%rsp), %rdi
callq 0x93c0
leaq 0xa0(%rsp), %rdi
callq 0x91c0
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x23c05
movq %rax, %rbx
movq 0x2f389(%rip), %rsi # 0x52f98
leaq 0x20(%rsp), %rdi
callq 0x93c0
leaq 0xa0(%rsp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestsList(std::ostream*, std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void XmlUnitTestResultPrinter::PrintXmlTestsList(
std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
const std::string kTestsuites = "testsuites";
*stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
*stream << "<" << kTestsuites;
int total_tests = 0;
for (auto test_suite : test_suites) {
total_tests += test_suite->total_test_count();
}
OutputXmlAttribute(stream, kTestsuites, "tests",
StreamableToString(total_tests));
OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
*stream << ">\n";
for (auto test_suite : test_suites) {
PrintXmlTestSuite(stream, *test_suite);
}
*stream << "</" << kTestsuites << ">\n";
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a628(%rip), %rsi # 0x3e279
leaq 0x1a62b(%rip), %rdx # 0x3e283
leaq 0x50(%rsp), %rdi
callq 0x37c48
leaq 0x1a61b(%rip), %rsi # 0x3e284
movl $0x27, %edx
movq %rbx, %rdi
callq 0x95f0
leaq 0x1a654(%rip), %rsi # 0x3e2d1
movl $0x1, %edx
movq %rbx, %rdi
callq 0x95f0
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x95f0
movl $0x0, 0xc(%rsp)
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x23cd0
xorl %edx, %edx
movq (%rax), %rsi
movq 0x38(%rsi), %rdi
subq 0x30(%rsi), %rdi
shrq $0x3, %rdi
addl %edi, %edx
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x23cb2
movl %edx, 0xc(%rsp)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x195b2(%rip), %rsi # 0x3d293
leaq 0x195b0(%rip), %rdx # 0x3d298
leaq 0x10(%rsp), %rdi
callq 0x37c48
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x30307
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %rbx, %rdi
callq 0x24fce
leaq 0x40(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x23d33
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x23d4a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9500
leaq 0x10(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x1a472(%rip), %rsi # 0x3e1cb
leaq 0x1a46f(%rip), %rdx # 0x3e1cf
callq 0x37c48
leaq 0x30(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x1a538(%rip), %rsi # 0x3e2ac
leaq 0x1a539(%rip), %rdx # 0x3e2b4
callq 0x37c48
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %rbx, %rdi
callq 0x24fce
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x23dae
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x23dc5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9500
leaq 0x1a432(%rip), %rsi # 0x3e1fe
movl $0x2, %edx
movq %rbx, %rdi
callq 0x95f0
movq (%r14), %r12
movq 0x8(%r14), %r14
cmpq %r14, %r12
je 0x23df7
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x26ea6
addq $0x8, %r12
jmp 0x23de0
leaq 0x1a4ec(%rip), %rsi # 0x3e2ea
movl $0x2, %edx
movq %rbx, %rdi
callq 0x95f0
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x95f0
leaq 0x1a3da(%rip), %rsi # 0x3e1fe
movl $0x2, %edx
movq %rax, %rdi
callq 0x95f0
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x23e48
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x9500
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
jne 0x23e7a
jmp 0x23e8c
jmp 0x23e89
jmp 0x23eab
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23e8c
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x23e8c
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x23eae
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x23eae
jmp 0x23eab
jmp 0x23eab
jmp 0x23eab
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x23ec5
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x99e0
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestProperties(std::ostream*, testing::TestResult const&) | void XmlUnitTestResultPrinter::OutputXmlTestProperties(
std::ostream* stream, const TestResult& result) {
const std::string kProperties = "properties";
const std::string kProperty = "property";
if (result.test_property_count() <= 0) {
return;
}
*stream << " <" << kProperties << ">\n";
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
*stream << " <" << kProperty;
*stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\"";
*stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\"";
*stream << "/>\n";
}
*stream << " </" << kProperties << ">\n";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1774a(%rip), %rsi # 0x3e2b5
leaq 0x1774d(%rip), %rdx # 0x3e2bf
leaq 0x48(%rsp), %rdi
callq 0x37c48
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x17734(%rip), %rsi # 0x3e2c0
leaq 0x17735(%rip), %rdx # 0x3e2c8
leaq 0x68(%rsp), %rdi
callq 0x37c48
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
testl %eax, %eax
jle 0x26dc7
leaq 0x17713(%rip), %rsi # 0x3e2cb
movl $0x7, %edx
movq %rbx, %rdi
callq 0x95f0
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x95f0
leaq 0x17620(%rip), %rsi # 0x3e1fe
movl $0x2, %edx
movq %rax, %rdi
callq 0x95f0
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
testl %eax, %eax
jle 0x26d8d
xorl %ebp, %ebp
leaq 0x28(%rsp), %r13
leaq 0x1778a(%rip), %r15 # 0x3e397
movq %r14, %rdi
movl %ebp, %esi
callq 0x1eb8a
movq %rax, %r12
movl $0x9, %edx
movq %rbx, %rdi
leaq 0x176a0(%rip), %rsi # 0x3e2c9
callq 0x95f0
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq %rbx, %rdi
callq 0x95f0
movl $0x7, %edx
movq %rbx, %rdi
leaq 0x17684(%rip), %rsi # 0x3e2d3
callq 0x95f0
movq (%r12), %rsi
movq %r13, %rdi
leaq 0x7(%rsp), %rdx
callq 0x30290
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x23ece
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x95f0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x95f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x26cb5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x26cd1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9500
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x175fb(%rip), %rsi # 0x3e2db
callq 0x95f0
movq 0x20(%r12), %rsi
movq %r13, %rdi
leaq 0x7(%rsp), %rdx
callq 0x30290
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x23ece
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x95f0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x95f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x26d47
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x26d63
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9500
movl $0x3, %edx
movq %rbx, %rdi
leaq 0x1748b(%rip), %rsi # 0x3e1fd
callq 0x95f0
incl %ebp
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jl 0x26c0d
leaq 0x17550(%rip), %rsi # 0x3e2e4
movl $0x8, %edx
movq %rbx, %rdi
callq 0x95f0
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x95f0
leaq 0x17444(%rip), %rsi # 0x3e1fe
movl $0x2, %edx
movq %rax, %rdi
callq 0x95f0
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x26de3
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x26dff
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9500
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x26e81
jmp 0x26e62
jmp 0x26e62
jmp 0x26e1e
jmp 0x26e62
movq %rax, %rbx
jmp 0x26e44
jmp 0x26e25
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x26e44
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x26e65
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x26e65
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x26e81
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x26e9d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x99e0
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes[abi:cxx11](testing::TestResult const&) | std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
const TestResult& result) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << " " << property.key() << "="
<< "\"" << EscapeXmlAttribute(property.value()) << "\"";
}
return attributes.GetString();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x1bce0
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
testl %eax, %eax
jle 0x2764f
movq 0x8(%rsp), %r15
addq $0x10, %r15
xorl %ebp, %ebp
leaq 0x38(%rsp), %r12
movq %r14, %rdi
movl %ebp, %esi
callq 0x1eb8a
movq %rax, %r13
movl $0x1, %edx
movq %r15, %rdi
leaq 0x1626b(%rip), %rsi # 0x3d7c9
callq 0x95f0
movq (%r13), %rbx
testq %rbx, %rbx
je 0x27579
movq %rbx, %rdi
callq 0x9230
movq %rax, %rdx
jmp 0x27585
movl $0x6, %edx
leaq 0x16417(%rip), %rbx # 0x3d99c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x95f0
movl $0x1, %edx
movq %r15, %rdi
leaq 0x17c3f(%rip), %rsi # 0x3f1de
callq 0x95f0
movl $0x1, %edx
movq %r15, %rdi
leaq 0x16de4(%rip), %rsi # 0x3e397
callq 0x95f0
movq 0x20(%r13), %rsi
movq %r12, %rdi
leaq 0x7(%rsp), %rdx
callq 0x30290
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x23ece
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r15, %rdi
callq 0x95f0
movl $0x1, %edx
movq %r15, %rdi
leaq 0x16d9b(%rip), %rsi # 0x3e397
callq 0x95f0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x2761d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x27639
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x9500
incl %ebp
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jl 0x27542
movq 0x8(%rsp), %rbx
movq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1bf43
testq %rbx, %rbx
je 0x27672
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x276cc
jmp 0x276cc
movq %rax, %rbx
jmp 0x276ae
jmp 0x276cc
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x276ae
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x276cf
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x276cf
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x276df
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x99e0
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* jsonout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintJsonUnitTest(&stream, unit_test);
fprintf(jsonout, "%s", StringStreamToString(&stream).c_str());
fclose(jsonout);
} | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x23380
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9370
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x27866
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x1bf43
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x95c0
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x2780a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x94c0
movq 0x2b77f(%rip), %rsi # 0x52f98
leaq 0x20(%rsp), %rdi
callq 0x93c0
leaq 0xa0(%rsp), %rdi
callq 0x91c0
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x2783d
movq %rax, %rbx
movq 0x2b751(%rip), %rsi # 0x52f98
leaq 0x20(%rsp), %rdi
callq 0x93c0
leaq 0xa0(%rsp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.