name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
QArrayDataPointer<QList<unsigned short>>::relocate(long long, QList<unsigned short> const**) | void relocate(qsizetype offset, const T **data = nullptr)
{
T *res = this->ptr + offset;
QtPrivate::q_relocate_overlap_n(this->ptr, this->size, res);
// first update data pointer, then this->ptr
if (data && QtPrivate::q_points_into_range(*data, *this))
*data += offset;
this->ptr = res;
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq (%rsi,%rsi,2), %r12
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rsi
leaq (%rdi,%r12,8), %r15
movq %r15, %rdx
callq 0x573839
testq %r14, %r14
je 0x573829
movq (%r14), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jb 0x573829
movq 0x10(%rbx), %rdx
leaq (%rdx,%rdx,2), %rdx
leaq (%rcx,%rdx,8), %rcx
cmpq %rax, %rcx
jbe 0x573829
leaq (%rax,%r12,8), %rax
movq %rax, (%r14)
movq %r15, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QList<unsigned short>>::allocateGrow(QArrayDataPointer<QList<unsigned short>> const&, long long, QArrayData::GrowthPosition) | static QArrayDataPointer allocateGrow(const QArrayDataPointer &from, qsizetype n, QArrayData::GrowthPosition position)
{
// calculate new capacity. We keep the free capacity at the side that does not have to grow
// to avoid quadratic behavior with mixed append/prepend cases
// use qMax below, because constAllocatedCapacity() can be 0 when using fromRawData()
qsizetype minimalCapacity = qMax(from.size, from.constAllocatedCapacity()) + n;
// subtract the free space at the side we want to allocate. This ensures that the total size requested is
// the existing allocation at the other side + size + n.
minimalCapacity -= (position == QArrayData::GrowsAtEnd) ? from.freeSpaceAtEnd() : from.freeSpaceAtBegin();
qsizetype capacity = from.detachCapacity(minimalCapacity);
const bool grows = capacity > from.constAllocatedCapacity();
auto [header, dataPtr] = Data::allocate(capacity, grows ? QArrayData::Grow : QArrayData::KeepSize);
const bool valid = header != nullptr && dataPtr != nullptr;
if (!valid)
return QArrayDataPointer(header, dataPtr);
// Idea: * when growing backwards, adjust pointer to prepare free space at the beginning
// * when growing forward, adjust by the previous data pointer offset
dataPtr += (position == QArrayData::GrowsAtBeginning)
? n + qMax(0, (header->alloc - from.size - n) / 2)
: from.freeSpaceAtBegin();
header->flags = from.flags();
return QArrayDataPointer(header, dataPtr);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x5738d9
movq 0x8(%rdx), %rax
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rsi
movq %rsi, %rcx
subq %rax, %rcx
cmovleq %rax, %rsi
addq %r15, %rsi
leaq 0x1f(%rdx), %r8
andq $-0x10, %r8
subq %r8, %rdi
sarq $0x3, %rdi
testl %ebp, %ebp
je 0x5738eb
movabsq $0x5555555555555555, %rcx # imm = 0x5555555555555555
imulq %rdi, %rcx
jmp 0x5738fc
movq 0x10(%r14), %rcx
xorl %eax, %eax
testq %rcx, %rcx
cmovleq %rax, %rcx
addq %r15, %rcx
jmp 0x573911
movabsq $-0x5555555555555555, %r8 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %r8
addq %r8, %rcx
addq %rcx, %rsi
cmpq %rsi, %rax
movq %rsi, %rcx
cmovgq %rax, %rcx
testb $0x1, 0x4(%rdx)
cmoveq %rsi, %rcx
xorl %r8d, %r8d
cmpq %rax, %rcx
setle %r8b
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %r12
movq %rax, (%r12)
movl $0x18, %esi
movl $0x10, %edx
movq %r12, %rdi
callq 0x138b60
movq (%r12), %rcx
testq %rcx, %rcx
sete %dl
testq %rax, %rax
sete %sil
orb %dl, %sil
jne 0x5739bb
cmpl $0x1, %ebp
jne 0x573997
movq 0x8(%rcx), %rdx
movq 0x10(%r14), %rsi
addq %r15, %rsi
subq %rsi, %rdx
movq %rdx, %rdi
shrq $0x3f, %rdi
addq %rdx, %rdi
sarq %rdi
xorl %esi, %esi
testq %rdi, %rdi
cmovleq %rsi, %rdi
movq (%r14), %rdx
leaq (%rdi,%rdi,2), %rdi
leaq (%rax,%rdi,8), %rax
leaq (%r15,%r15,2), %rdi
leaq (%rax,%rdi,8), %rax
testq %rdx, %rdx
jne 0x5739b1
jmp 0x5739b8
movq (%r14), %rdx
testq %rdx, %rdx
je 0x5739b6
movq 0x8(%r14), %rsi
leaq 0x1f(%rdx), %rdi
andq $-0x10, %rdi
subq %rdi, %rsi
addq %rsi, %rax
movl 0x4(%rdx), %esi
jmp 0x5739b8
xorl %esi, %esi
movl %esi, 0x4(%rcx)
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq %fs:0x28, %rax
cmpq 0x8(%rsp), %rax
jne 0x5739ea
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
CppEphem::StrOpt::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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>>>>*) | void CppEphem::StrOpt::split(const std::string& s,
const char& delim,
std::vector<std::string>* elems)
{
std::stringstream ss(s);
std::string item=std::string();
while (std::getline(ss, item, delim)) {
elems->push_back(item);
}
} | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x21c90
movq 0x10(%rsp), %rsi
movl %eax, %edx
leaq 0x48(%rsp), %rdi
callq 0x1c650
leaq 0x28(%rsp), %rdi
callq 0x1c570
movq 0x1d8(%rsp), %rax
movsbl (%rax), %edx
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1c780
movq %rax, 0x8(%rsp)
jmp 0x217d7
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x1c4e0
movb %al, 0x7(%rsp)
jmp 0x217f1
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x217fb
jmp 0x21835
movq 0x1d0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x21cb0
jmp 0x2180f
jmp 0x217b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1c230
leaq 0x48(%rsp), %rdi
callq 0x1c2b0
jmp 0x21851
leaq 0x28(%rsp), %rdi
callq 0x1c230
leaq 0x48(%rsp), %rdi
callq 0x1c2b0
addq $0x1e8, %rsp # imm = 0x1E8
retq
movq 0x20(%rsp), %rdi
callq 0x1c730
nopl (%rax,%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CENamespace.cpp |
CppEphem::StrOpt::join_angle[abi:cxx11](std::vector<double, std::allocator<double>> const&, char const&) | std::string CppEphem::StrOpt::join_angle(const std::vector<double>& values,
const char& delim)
{
// Make sure there are only three values
double sec = values[2];
if (values.size() == 4) {
sec += values[3];
}
// Assemble the string using the specified delimiter
std::ostringstream ss;
ss << std::setfill('0') << std::setw(2) << int(values[0]);
ss << delim;
ss << std::setfill('0') << std::setw(2) << int(values[1]);
ss << delim;
ss << std::setfill('0') << std::setw(11) << std::fixed
<< std::setprecision(8) << sec;
return std::string(ss.str());
} | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x80(%rsp)
movq %rdi, %rax
movq %rax, 0x88(%rsp)
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq 0x248(%rsp), %rdi
movl $0x2, %esi
callq 0x22000
movsd (%rax), %xmm0
movsd %xmm0, 0x238(%rsp)
movq 0x248(%rsp), %rdi
callq 0x21fe0
cmpq $0x4, %rax
jne 0x2197c
movq 0x248(%rsp), %rdi
movl $0x3, %esi
callq 0x22000
movsd (%rax), %xmm0
addsd 0x238(%rsp), %xmm0
movsd %xmm0, 0x238(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x1c540
movl $0x30, %edi
callq 0x22020
movb %al, 0x7f(%rsp)
jmp 0x21999
movb 0x7f(%rsp), %al
movb %al, 0xbf(%rsp)
movzbl 0xbf(%rsp), %esi
leaq 0xc0(%rsp), %rdi
callq 0x1c630
movq %rax, 0x70(%rsp)
jmp 0x219c0
movl $0x2, %edi
callq 0x22040
movl %eax, 0x6c(%rsp)
jmp 0x219d0
movq 0x70(%rsp), %rdi
movl 0x6c(%rsp), %eax
movl %eax, 0xa8(%rsp)
movl 0xa8(%rsp), %esi
callq 0x1c490
movq %rax, 0x60(%rsp)
jmp 0x219f3
movq 0x248(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22000
movq 0x60(%rsp), %rdi
cvttsd2si (%rax), %esi
callq 0x1c710
jmp 0x21a14
movq 0x240(%rsp), %rax
movsbl (%rax), %esi
leaq 0xc0(%rsp), %rdi
callq 0x1c4a0
jmp 0x21a2e
movl $0x30, %edi
callq 0x22020
movb %al, 0x5f(%rsp)
jmp 0x21a3e
movb 0x5f(%rsp), %al
movb %al, 0xa7(%rsp)
movzbl 0xa7(%rsp), %esi
leaq 0xc0(%rsp), %rdi
callq 0x1c630
movq %rax, 0x50(%rsp)
jmp 0x21a65
movl $0x2, %edi
callq 0x22040
movl %eax, 0x4c(%rsp)
jmp 0x21a75
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %eax
movl %eax, 0xa0(%rsp)
movl 0xa0(%rsp), %esi
callq 0x1c490
movq %rax, 0x40(%rsp)
jmp 0x21a98
movq 0x248(%rsp), %rdi
movl $0x1, %esi
callq 0x22000
movq 0x40(%rsp), %rdi
cvttsd2si (%rax), %esi
callq 0x1c710
jmp 0x21aba
movq 0x240(%rsp), %rax
movsbl (%rax), %esi
leaq 0xc0(%rsp), %rdi
callq 0x1c4a0
jmp 0x21ad4
movl $0x30, %edi
callq 0x22020
movb %al, 0x3f(%rsp)
jmp 0x21ae4
movb 0x3f(%rsp), %al
movb %al, 0x9f(%rsp)
movzbl 0x9f(%rsp), %esi
leaq 0xc0(%rsp), %rdi
callq 0x1c630
movq %rax, 0x30(%rsp)
jmp 0x21b0b
movl $0xb, %edi
callq 0x22040
movl %eax, 0x2c(%rsp)
jmp 0x21b1b
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x98(%rsp)
movl 0x98(%rsp), %esi
callq 0x1c490
movq %rax, 0x20(%rsp)
jmp 0x21b3e
movq 0x20(%rsp), %rdi
leaq 0x516(%rip), %rsi # 0x22060
callq 0x1c140
movq %rax, 0x18(%rsp)
jmp 0x21b56
movl $0x8, %edi
callq 0x22080
movl %eax, 0x14(%rsp)
jmp 0x21b66
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %esi
callq 0x1c640
movq %rax, 0x8(%rsp)
jmp 0x21b89
movq 0x8(%rsp), %rdi
movsd 0x238(%rsp), %xmm0
callq 0x1c7c0
jmp 0x21b9e
movq 0x80(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x1c3c0
jmp 0x21bb5
leaq 0xc0(%rsp), %rdi
callq 0x1c0c0
movq 0x88(%rsp), %rax
addq $0x258, %rsp # imm = 0x258
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x1c0c0
movq 0xb0(%rsp), %rdi
callq 0x1c730
| /Jvinniec[P]CppEphem/cppephem/src/CENamespace.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> CppEphem::StrOpt::join<double>(std::vector<double, std::allocator<double>> const&, char const&) | std::string CppEphem::StrOpt::join(const std::vector<T>& values,
const char& delim)
{
// Assemble the first value in the string
std::ostringstream ss;
if (values.size() > 0) {
ss << values[0];
}
// Now append the rest
for (int i=1; i<values.size(); i++) {
ss << delim << values[i];
}
return ss.str();
} | subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq %rdx, 0x1b0(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1c540
movq 0x1b8(%rsp), %rdi
callq 0x21fe0
cmpq $0x0, %rax
jbe 0x21f29
movq 0x1b8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22000
movsd (%rax), %xmm0
leaq 0x38(%rsp), %rdi
callq 0x1c7c0
jmp 0x21f0a
jmp 0x21f29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1c0c0
jmp 0x21fca
movl $0x1, 0x28(%rsp)
movslq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x1b8(%rsp), %rdi
callq 0x21fe0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x21fa2
movq 0x1b0(%rsp), %rax
movsbl (%rax), %esi
leaq 0x38(%rsp), %rdi
callq 0x1c4a0
movq %rax, 0x8(%rsp)
jmp 0x21f71
movq 0x1b8(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x22000
movq 0x8(%rsp), %rdi
movsd (%rax), %xmm0
callq 0x1c7c0
jmp 0x21f93
jmp 0x21f95
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x21f31
movq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1c3c0
jmp 0x21fb3
leaq 0x38(%rsp), %rdi
callq 0x1c0c0
movq 0x20(%rsp), %rax
addq $0x1c8, %rsp # imm = 0x1C8
retq
movq 0x30(%rsp), %rdi
callq 0x1c730
nopw %cs:(%rax,%rax)
nop
| /Jvinniec[P]CppEphem/cppephem/src/CENamespace.cpp |
CEAngle::SetAngle(char const*, CEAngleType const&, char const&) | void CEAngle::SetAngle(const char* angle_str,
const CEAngleType& angle_type,
const char& delim)
{
// Angle is a degree or radian
if ((angle_type == CEAngleType::DEGREES) || (angle_type == CEAngleType::RADIANS)) {
SetAngle(std::stod(angle_str), angle_type);
}
// Otherwise the angle is a delimited string (i.e. something like HH:MM:SS)
else {
// Create a string vector to hold the parsed values
std::vector<std::string> angle_vec;
angle_vec.reserve(4);
// Handle specific delimitors
if (delim != 0) {
// Split the string
CppEphem::StrOpt::split(angle_str, delim, &angle_vec);
// Throw an error if the string was not properly split
if (angle_vec.size() < 3) {
throw CEException::invalid_delimiter(
"CEAngle::SetAngle(const string&, const CEAngleType&, const char&)",
"Could not find specified delimiter: " + std::string(1,delim));
}
// Now format the string in the appropriate way
std::vector<double> angle_dbl;
for (auto& ang : angle_vec) {
angle_dbl.push_back(std::stod(ang));
}
SetAngle(angle_dbl, angle_type);
}
// Handle delimiter agnostic format
else if (delim == 0) {
// Create vector of delimiters to be tried
std::vector<char> delim_list = {':', ' '};
// Loop through the list of delimiters
for (char d : delim_list) {
// Check if the delimiter is in the string
if (std::string(angle_str).find(d) != std::string::npos) {
// Try to set the angle
SetAngle(angle_str, angle_type, d);
}
}
}
}
return;
} | subq $0x248, %rsp # imm = 0x248
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movq %rdx, 0x230(%rsp)
movq %rcx, 0x228(%rsp)
movq 0x240(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x230(%rsp), %rax
cmpl $0x0, (%rax)
je 0x22df2
movq 0x230(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x22ed6
movq 0x238(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x1ff(%rsp), %rdi
movq %rdi, 0x70(%rsp)
callq 0x1c740
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x200(%rsp), %rdi
callq 0x1c560
jmp 0x22e2a
xorl %eax, %eax
movl %eax, %esi
leaq 0x200(%rsp), %rdi
callq 0x25290
movsd %xmm0, 0x60(%rsp)
jmp 0x22e43
movq 0x78(%rsp), %rdi
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x220(%rsp)
movq 0x230(%rsp), %rdx
leaq 0x220(%rsp), %rsi
callq 0x229d0
jmp 0x22e6e
leaq 0x200(%rsp), %rdi
callq 0x1c230
leaq 0x1ff(%rsp), %rdi
callq 0x1c420
jmp 0x234ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x22ec4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
leaq 0x200(%rsp), %rdi
callq 0x1c230
leaq 0x1ff(%rsp), %rdi
callq 0x1c420
jmp 0x234f5
leaq 0x1d0(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x20110
movq 0x58(%rsp), %rdi
movl $0x4, %esi
callq 0x252d0
jmp 0x22ef9
movq 0x228(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x232ab
movq 0x238(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x1af(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x1c740
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x1b0(%rsp), %rdi
callq 0x1c560
jmp 0x22f45
movq 0x228(%rsp), %rsi
leaq 0x1b0(%rsp), %rdi
leaq 0x1d0(%rsp), %rdx
callq 0x21760
jmp 0x22f64
leaq 0x1b0(%rsp), %rdi
callq 0x1c230
leaq 0x1af(%rsp), %rdi
callq 0x1c420
leaq 0x1d0(%rsp), %rdi
callq 0x21e60
cmpq $0x3, %rax
jae 0x2318a
movb $0x1, 0x13e(%rsp)
movl $0xa8, %edi
callq 0x1c1c0
movq %rax, 0x38(%rsp)
leaq 0x187(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x1c740
movq 0x40(%rsp), %rdx
leaq 0x22339(%rip), %rsi # 0x45303
leaq 0x188(%rsp), %rdi
callq 0x1c560
jmp 0x22fd9
movq 0x228(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x2c(%rsp)
leaq 0x13f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x1c740
movl 0x2c(%rsp), %edx
movq 0x30(%rsp), %rcx
leaq 0x140(%rsp), %rdi
movl $0x1, %esi
callq 0x1c240
jmp 0x23017
leaq 0x22327(%rip), %rsi # 0x45345
leaq 0x160(%rsp), %rdi
leaq 0x140(%rsp), %rdx
callq 0x253e0
jmp 0x23035
movq 0x38(%rsp), %rdi
leaq 0x188(%rsp), %rsi
leaq 0x160(%rsp), %rdx
callq 0x379e0
jmp 0x23051
movq 0x38(%rsp), %rdi
movb $0x0, 0x13e(%rsp)
leaq 0x2f63b(%rip), %rsi # 0x526a0
leaq 0x23c4(%rip), %rdx # 0x25430
callq 0x1c6f0
jmp 0x23502
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x234de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x230c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
leaq 0x1b0(%rsp), %rdi
callq 0x1c230
leaq 0x1af(%rsp), %rdi
callq 0x1c420
jmp 0x234de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x23162
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x23148
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x2313b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
leaq 0x160(%rsp), %rdi
callq 0x1c230
leaq 0x140(%rsp), %rdi
callq 0x1c230
leaq 0x13f(%rsp), %rdi
callq 0x1c420
leaq 0x188(%rsp), %rdi
callq 0x1c230
leaq 0x187(%rsp), %rdi
callq 0x1c420
testb $0x1, 0x13e(%rsp)
jne 0x2317b
jmp 0x23185
movq 0x38(%rsp), %rdi
callq 0x1c2a0
jmp 0x234de
leaq 0x120(%rsp), %rdi
callq 0x25440
leaq 0x1d0(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x118(%rsp), %rdi
callq 0x22620
movq %rax, 0x110(%rsp)
movq 0x118(%rsp), %rdi
callq 0x22490
movq %rax, 0x108(%rsp)
leaq 0x110(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0x25450
testb $0x1, %al
jne 0x231ef
jmp 0x2327d
leaq 0x110(%rsp), %rdi
callq 0x25490
movq %rax, 0x100(%rsp)
movq 0x100(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25290
movsd %xmm0, 0x20(%rsp)
jmp 0x2321d
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0xf8(%rsp)
leaq 0x120(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x254a0
jmp 0x23243
jmp 0x23245
leaq 0x110(%rsp), %rdi
callq 0x254d0
jmp 0x231d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
leaq 0x120(%rsp), %rdi
callq 0x201d0
jmp 0x234de
movq 0x78(%rsp), %rdi
movq 0x230(%rsp), %rdx
leaq 0x120(%rsp), %rsi
callq 0x235a0
jmp 0x23299
leaq 0x120(%rsp), %rdi
callq 0x201d0
jmp 0x234cf
movq 0x228(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x234cd
movb $0x3a, 0xce(%rsp)
movb $0x20, 0xcf(%rsp)
leaq 0xce(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq $0x2, 0xd8(%rsp)
leaq 0xcd(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1c740
movq 0x18(%rsp), %rcx
movq 0xd0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
leaq 0xe0(%rsp), %rdi
callq 0x254f0
jmp 0x23321
leaq 0xcd(%rsp), %rdi
callq 0x1c420
leaq 0xe0(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x25580
movq %rax, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x255b0
movq %rax, 0xb0(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x255e0
testb $0x1, %al
jne 0x23386
jmp 0x234af
leaq 0xb8(%rsp), %rdi
callq 0x25620
movb (%rax), %al
movb %al, 0xaf(%rsp)
movq 0x238(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1c740
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x88(%rsp), %rdi
callq 0x1c560
jmp 0x233d4
leaq 0x88(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl 0xaf(%rsp), %esi
callq 0x1c520
movq %rax, (%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1c230
leaq 0x87(%rsp), %rdi
callq 0x1c420
movq (%rsp), %rax
cmpq $-0x1, %rax
je 0x2349b
movq 0x78(%rsp), %rdi
movq 0x238(%rsp), %rsi
movq 0x230(%rsp), %rdx
leaq 0xaf(%rsp), %rcx
callq 0x22da0
jmp 0x2343d
jmp 0x2349b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
leaq 0xcd(%rsp), %rdi
callq 0x1c420
jmp 0x234de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
leaq 0x87(%rsp), %rdi
callq 0x1c420
jmp 0x234be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1f0(%rsp)
movl %eax, 0x1ec(%rsp)
jmp 0x234be
jmp 0x2349d
leaq 0xb8(%rsp), %rdi
callq 0x25630
jmp 0x23368
leaq 0xe0(%rsp), %rdi
callq 0x25650
jmp 0x234cd
leaq 0xe0(%rsp), %rdi
callq 0x25650
jmp 0x234de
jmp 0x234cf
leaq 0x1d0(%rsp), %rdi
callq 0x200a0
jmp 0x234ed
leaq 0x1d0(%rsp), %rdi
callq 0x200a0
jmp 0x234f5
addq $0x248, %rsp # imm = 0x248
retq
movq 0x1f0(%rsp), %rdi
callq 0x1c730
nopw %cs:(%rax,%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CEAngle.cpp |
CEAngle::HmsVect() const | std::vector<double> CEAngle::HmsVect(void) const
{
// Stores the resulting values
std::vector<int> HMS_i(4);
// Stores the sign
char pm;
iauA2tf(9, angle_, &pm, &HMS_i[0]);
// Convert the values into doubles
std::vector<double> HMS_d(HMS_i.size());
// Scale the fraction to be a true fraction
HMS_d[0] = double(HMS_i[0]);
HMS_d[1] = double(HMS_i[1]);
HMS_d[2] = double(HMS_i[2]);
HMS_d[3] = double(HMS_i[3])/1.0e9;
// Multiply the degree by a negative
if (pm == '-') HMS_d[0] *= -1;
return HMS_d;
} | subq $0x98, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x25010
movq 0x50(%rsp), %rdx
leaq 0x70(%rsp), %rdi
movl $0x4, %esi
callq 0x25020
jmp 0x23806
leaq 0x6f(%rsp), %rdi
callq 0x204d0
movq 0x48(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
xorl %eax, %eax
movl %eax, %esi
leaq 0x70(%rsp), %rdi
callq 0x250a0
movsd 0x30(%rsp), %xmm0
movq %rax, %rdx
movl $0x9, %edi
leaq 0x5b(%rsp), %rsi
callq 0x1c470
jmp 0x23848
movb $0x0, 0x5a(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x250c0
movq %rax, 0x20(%rsp)
leaq 0x59(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x20120
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x250e0
jmp 0x23881
leaq 0x59(%rsp), %rdi
callq 0x201c0
leaq 0x70(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x250a0
movq 0x38(%rsp), %rdi
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, (%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x25160
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0x70(%rsp), %rdi
movl $0x1, %esi
callq 0x250a0
movq 0x38(%rsp), %rdi
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x1, %esi
callq 0x25160
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0x70(%rsp), %rdi
movl $0x2, %esi
callq 0x250a0
movq 0x38(%rsp), %rdi
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x2, %esi
callq 0x25160
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0x70(%rsp), %rdi
movl $0x3, %esi
callq 0x250a0
movq 0x38(%rsp), %rdi
cvtsi2sdl (%rax), %xmm0
movsd 0x21913(%rip), %xmm1 # 0x45250
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x3, %esi
callq 0x25160
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movsbl 0x5b(%rsp), %eax
cmpl $0x2d, %eax
jne 0x239c9
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25160
movsd 0x218dd(%rip), %xmm0 # 0x45258
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x239c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x6f(%rsp), %rdi
callq 0x204d0
jmp 0x23a00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x239f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x59(%rsp), %rdi
callq 0x201c0
jmp 0x239f6
movb $0x1, 0x5a(%rsp)
testb $0x1, 0x5a(%rsp)
jne 0x239df
movq 0x38(%rsp), %rdi
callq 0x201d0
leaq 0x70(%rsp), %rdi
callq 0x202c0
movq 0x40(%rsp), %rax
addq $0x98, %rsp
retq
leaq 0x70(%rsp), %rdi
callq 0x202c0
movq 0x60(%rsp), %rdi
callq 0x1c730
nopw (%rax,%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CEAngle.cpp |
CEAngle::SetAngle_DmsVect(std::vector<double, std::allocator<double>> const&) | void CEAngle::SetAngle_DmsVect(const std::vector<double>& angle)
{
// Get the angle's sign
char sign = (angle[0] < 0.0) ? '-' : '+';
// Convert the values to an angle in degrees
double ang(0.0);
double sec = (angle.size() == 4) ? angle[2]+angle[3] : angle[2];
// Pass the values to the appropriate SOFA algorithm
int err = iauAf2a(sign, int(angle[0]), int(angle[1]), sec, &ang);
// Handle the error
if (err) {
std::string msg = "[ERROR] ";
switch(err) {
// Hours out of bounds
case 1:
msg += "Degree value \'" + std::to_string(angle[0]) + "\' not in range 0-359";
throw CEException::invalid_value("CEAngle::SetAngle_DmsVect", msg);
// Minutes out of bounds
case 2:
msg += "Arcmin value \'" + std::to_string(angle[1]) + "\' not in range 0-59";
throw CEException::invalid_value("CEAngle::SetAngle_DmsVect", msg);
// Seconds out of bounds
case 3:
msg += "Arcsec value \'" + std::to_string(sec) + "\' not in range 0-59.999...";
throw CEException::invalid_value("CEAngle::SetAngle_DmsVect", msg);
}
}
// Set the angle
SetAngle(ang, CEAngleType::RADIANS);
return;
} | subq $0x268, %rsp # imm = 0x268
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq 0x260(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x258(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22000
movsd (%rax), %xmm1
xorps %xmm0, %xmm0
movb $0x2d, %al
movb $0x2b, %cl
movb %cl, 0x66(%rsp)
ucomisd %xmm1, %xmm0
movb %al, 0x67(%rsp)
ja 0x24866
movb 0x66(%rsp), %al
movb %al, 0x67(%rsp)
movb 0x67(%rsp), %al
movb %al, 0x257(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x248(%rsp)
movq 0x258(%rsp), %rdi
callq 0x21fe0
cmpq $0x4, %rax
jne 0x248d0
movq 0x258(%rsp), %rdi
movl $0x2, %esi
callq 0x22000
movsd (%rax), %xmm0
movsd %xmm0, 0x48(%rsp)
movq 0x258(%rsp), %rdi
movl $0x3, %esi
callq 0x22000
movsd 0x48(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x248ec
movq 0x258(%rsp), %rdi
movl $0x2, %esi
callq 0x22000
movsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x240(%rsp)
movb 0x257(%rsp), %al
movb %al, 0x47(%rsp)
movq 0x258(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22000
cvttsd2si (%rax), %eax
movl %eax, 0x40(%rsp)
movq 0x258(%rsp), %rdi
movl $0x1, %esi
callq 0x22000
movl 0x40(%rsp), %esi
movq %rax, %rcx
movb 0x47(%rsp), %al
cvttsd2si (%rcx), %edx
movsd 0x240(%rsp), %xmm0
leaq 0x248(%rsp), %rcx
movsbl %al, %edi
callq 0x1c480
movl %eax, 0x23c(%rsp)
cmpl $0x0, 0x23c(%rsp)
je 0x24fd5
leaq 0x217(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x1c740
movq 0x38(%rsp), %rdx
leaq 0x20a3b(%rip), %rsi # 0x453c7
leaq 0x218(%rsp), %rdi
callq 0x1c560
jmp 0x2499b
leaq 0x217(%rsp), %rdi
callq 0x1c420
movl 0x23c(%rsp), %eax
movl %eax, 0x34(%rsp)
subl $0x1, %eax
je 0x24a01
jmp 0x249ba
movl 0x34(%rsp), %eax
subl $0x2, %eax
je 0x24c08
jmp 0x249c9
movl 0x34(%rsp), %eax
subl $0x3, %eax
je 0x24df7
jmp 0x24fb7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
leaq 0x217(%rsp), %rdi
callq 0x1c420
jmp 0x24ffc
movq 0x258(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22000
movsd (%rax), %xmm0
leaq 0x1a0(%rsp), %rdi
callq 0x25720
jmp 0x24a25
leaq 0x20a2e(%rip), %rsi # 0x4545a
leaq 0x1c0(%rsp), %rdi
leaq 0x1a0(%rsp), %rdx
callq 0x253e0
jmp 0x24a43
leaq 0x20a1f(%rip), %rdx # 0x45469
leaq 0x1e0(%rsp), %rdi
leaq 0x1c0(%rsp), %rsi
callq 0x256d0
jmp 0x24a61
leaq 0x218(%rsp), %rdi
leaq 0x1e0(%rsp), %rsi
callq 0x1c500
jmp 0x24a78
leaq 0x1e0(%rsp), %rdi
callq 0x1c230
leaq 0x1c0(%rsp), %rdi
callq 0x1c230
leaq 0x1a0(%rsp), %rdi
callq 0x1c230
movb $0x1, 0x17e(%rsp)
movl $0xa8, %edi
callq 0x1c1c0
movq %rax, 0x20(%rsp)
leaq 0x17f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1c740
movq 0x28(%rsp), %rdx
leaq 0x209aa(%rip), %rsi # 0x4547e
leaq 0x180(%rsp), %rdi
callq 0x1c560
jmp 0x24ae3
movq 0x20(%rsp), %rdi
leaq 0x180(%rsp), %rsi
leaq 0x218(%rsp), %rdx
callq 0x37900
jmp 0x24aff
movq 0x20(%rsp), %rdi
movb $0x0, 0x17e(%rsp)
leaq 0x2db75(%rip), %rsi # 0x52688
leaq 0x766(%rip), %rdx # 0x25280
callq 0x1c6f0
jmp 0x25009
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0x24fc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0x24b97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0x24b8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
leaq 0x1e0(%rsp), %rdi
callq 0x1c230
leaq 0x1c0(%rsp), %rdi
callq 0x1c230
leaq 0x1a0(%rsp), %rdi
callq 0x1c230
jmp 0x24fc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0x24be0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
leaq 0x180(%rsp), %rdi
callq 0x1c230
leaq 0x17f(%rsp), %rdi
callq 0x1c420
testb $0x1, 0x17e(%rsp)
jne 0x24bf9
jmp 0x24c03
movq 0x20(%rsp), %rdi
callq 0x1c2a0
jmp 0x24fc6
movq 0x258(%rsp), %rdi
movl $0x1, %esi
callq 0x22000
movsd (%rax), %xmm0
leaq 0x118(%rsp), %rdi
callq 0x25720
jmp 0x24c2d
leaq 0x20864(%rip), %rsi # 0x45498
leaq 0x138(%rsp), %rdi
leaq 0x118(%rsp), %rdx
callq 0x253e0
jmp 0x24c4b
leaq 0x207c9(%rip), %rdx # 0x4541b
leaq 0x158(%rsp), %rdi
leaq 0x138(%rsp), %rsi
callq 0x256d0
jmp 0x24c69
leaq 0x218(%rsp), %rdi
leaq 0x158(%rsp), %rsi
callq 0x1c500
jmp 0x24c80
leaq 0x158(%rsp), %rdi
callq 0x1c230
leaq 0x138(%rsp), %rdi
callq 0x1c230
leaq 0x118(%rsp), %rdi
callq 0x1c230
movb $0x1, 0xf6(%rsp)
movl $0xa8, %edi
callq 0x1c1c0
movq %rax, 0x10(%rsp)
leaq 0xf7(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1c740
movq 0x18(%rsp), %rdx
leaq 0x207a2(%rip), %rsi # 0x4547e
leaq 0xf8(%rsp), %rdi
callq 0x1c560
jmp 0x24ceb
movq 0x10(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
leaq 0x218(%rsp), %rdx
callq 0x37900
jmp 0x24d07
movq 0x10(%rsp), %rdi
movb $0x0, 0xf6(%rsp)
leaq 0x2d96d(%rip), %rsi # 0x52688
leaq 0x55e(%rip), %rdx # 0x25280
callq 0x1c6f0
jmp 0x25009
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0x24d86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0x24d79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
leaq 0x158(%rsp), %rdi
callq 0x1c230
leaq 0x138(%rsp), %rdi
callq 0x1c230
leaq 0x118(%rsp), %rdi
callq 0x1c230
jmp 0x24fc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0x24dcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0x1c230
leaq 0xf7(%rsp), %rdi
callq 0x1c420
testb $0x1, 0xf6(%rsp)
jne 0x24de8
jmp 0x24df2
movq 0x10(%rsp), %rdi
callq 0x1c2a0
jmp 0x24fc6
movsd 0x240(%rsp), %xmm0
leaq 0x90(%rsp), %rdi
callq 0x25720
jmp 0x24e0f
leaq 0x20691(%rip), %rsi # 0x454a7
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x253e0
jmp 0x24e2d
leaq 0x2060b(%rip), %rdx # 0x4543f
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x256d0
jmp 0x24e4b
leaq 0x218(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x1c500
jmp 0x24e62
leaq 0xd0(%rsp), %rdi
callq 0x1c230
leaq 0xb0(%rsp), %rdi
callq 0x1c230
leaq 0x90(%rsp), %rdi
callq 0x1c230
movb $0x1, 0x6e(%rsp)
movl $0xa8, %edi
callq 0x1c1c0
movq %rax, (%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1c740
movq 0x8(%rsp), %rdx
leaq 0x205c7(%rip), %rsi # 0x4547e
leaq 0x70(%rsp), %rdi
callq 0x1c560
jmp 0x24ec3
movq (%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x218(%rsp), %rdx
callq 0x37900
jmp 0x24edb
movq (%rsp), %rdi
movb $0x0, 0x6e(%rsp)
leaq 0x2d79d(%rip), %rsi # 0x52688
leaq 0x38e(%rip), %rdx # 0x25280
callq 0x1c6f0
jmp 0x25009
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0x24f56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0x24f49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x1c230
leaq 0xb0(%rsp), %rdi
callq 0x1c230
leaq 0x90(%rsp), %rdi
callq 0x1c230
jmp 0x24fc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0x24f99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1c230
leaq 0x6f(%rsp), %rdi
callq 0x1c420
testb $0x1, 0x6e(%rsp)
jne 0x24fac
jmp 0x24fb5
movq (%rsp), %rdi
callq 0x1c2a0
jmp 0x24fc6
leaq 0x218(%rsp), %rdi
callq 0x1c230
jmp 0x24fd5
leaq 0x218(%rsp), %rdi
callq 0x1c230
jmp 0x24ffc
movq 0x58(%rsp), %rdi
movl $0x1, 0x68(%rsp)
leaq 0x248(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x229d0
addq $0x268, %rsp # imm = 0x268
retq
movq 0x208(%rsp), %rdi
callq 0x1c730
nopl (%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CEAngle.cpp |
CEBody::operator=(CEBody const&) | CEBody& CEBody::operator=(const CEBody& other)
{
if (this != &other) {
// Copy parent class parameters
this->CESkyCoord::operator=(other);
// Reset this object and copy values from 'other'
free_members();
init_members();
copy_members(other);
}
return *this;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq 0x8(%rsp), %rax
je 0x27abc
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3fa00
movq (%rsp), %rdi
callq 0x27a30
movq (%rsp), %rdi
callq 0x27770
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x27900
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CEBody.cpp |
CECoordinates::CIRS2ICRS(double, double, double*, double*, CEDate const&, CEAngleType const&) | void CECoordinates::CIRS2ICRS(double input_ra, double input_dec,
double *return_ra, double *return_dec,
const CEDate& date, const CEAngleType& angle_type)
{
// Convert to radians if that's what is passed
if (angle_type==CEAngleType::DEGREES) {
input_ra *= DD2R ;
input_dec *= DD2R ;
}
// Use the sofa library to convert these coordinates
double eo ; // Equation of the origins
double tdb1(0.0);
double tdb2(0.0);
CEDate::UTC2TDB(date.MJD(), &tdb1, &tdb2);
iauAtic13(input_ra, input_dec, tdb1, tdb2, return_ra, return_dec, &eo) ;
// Subtract the eo from RA if J2000 coordinates are desired
//*return_ra -= eo ;
// Return the coordinates in the requested units
if (angle_type == CEAngleType::DEGREES) {
*return_ra *= DR2D ;
*return_dec *= DR2D ;
}
} | subq $0x58, %rsp
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x283b6
movsd 0x1ceb2(%rip), %xmm0 # 0x45248
mulsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x1ce9e(%rip), %xmm0 # 0x45248
mulsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movsd %xmm0, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x36f90
movsd 0x50(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x1c720
movq 0x28(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x2844d
movq 0x40(%rsp), %rax
movsd 0x1ce40(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0x38(%rsp), %rax
movsd 0x1ce2b(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CECoordinates.cpp |
CECoordinates::CIRS2Observed(double, double, double*, double*, CEDate const&, CEObserver const&, CEAngleType const&, double, double*, double*, double*) | int CECoordinates::CIRS2Observed(double ra, double dec,
double *az, double *zen,
const CEDate& date,
const CEObserver& observer,
const CEAngleType& angle_type,
double wavelength,
double *observed_ra,
double *observed_dec,
double *hour_angle)
{
// If we've passed in angles that are in degrees we need to convert to radians
if (angle_type == CEAngleType::DEGREES) {
ra *= DD2R ;
dec *= DD2R ;
}
// Setup the observed RA, Dec and hour_angle variables
double temp_ra, temp_dec, temp_hour_angle ;
// If values were passed, point these variables at the passed ones
if (observed_ra == nullptr) observed_ra = &temp_ra;
if (observed_dec == nullptr) observed_dec = &temp_dec;
if (hour_angle == nullptr) hour_angle = &temp_hour_angle;
int err_code = CIRS2Observed(ra, dec,
az, zen,
date.JD(),
observer.Longitude_Rad(),
observer.Latitude_Rad(),
observer.Elevation_m(),
observer.Pressure_hPa(),
observer.Temperature_C(),
observer.RelativeHumidity(),
date.dut1(),
date.xpolar(),
date.ypolar(),
wavelength,
observed_ra,
observed_dec,
hour_angle) ;
// Now convert back to degrees if that's what we were passed
if (angle_type == CEAngleType::DEGREES) {
*az *= DR2D;
*zen *= DR2D;
*observed_ra *= DR2D;
*observed_dec *= DR2D;
*hour_angle *= DR2D;
}
return err_code ;
} | subq $0xf8, %rsp
movq 0x108(%rsp), %rax
movq 0x100(%rsp), %rax
movsd %xmm0, 0xf0(%rsp)
movsd %xmm1, 0xe8(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq %r8, 0xc0(%rsp)
movsd %xmm2, 0xb8(%rsp)
movq %r9, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x286b3
movsd 0x1cbc1(%rip), %xmm0 # 0x45248
mulsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0x1cba7(%rip), %xmm0 # 0x45248
mulsd 0xe8(%rsp), %xmm0
movsd %xmm0, 0xe8(%rsp)
cmpq $0x0, 0xb0(%rsp)
jne 0x286ce
leaq 0xa8(%rsp), %rax
movq %rax, 0xb0(%rsp)
cmpq $0x0, 0x100(%rsp)
jne 0x286e9
leaq 0xa0(%rsp), %rax
movq %rax, 0x100(%rsp)
cmpq $0x0, 0x108(%rsp)
jne 0x28704
leaq 0x98(%rsp), %rax
movq %rax, 0x108(%rsp)
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x88(%rsp)
movsd 0xe8(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xd0(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movsd %xmm0, 0x40(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x2d9e0
movsd %xmm0, 0x48(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x2d9f0
movsd %xmm0, 0x50(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x2da00
movsd %xmm0, 0x58(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x2da10
movsd %xmm0, 0x60(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x2da20
movsd %xmm0, 0x68(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x2da30
movsd %xmm0, 0x70(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x37060
movsd %xmm0, 0x78(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x37120
movsd %xmm0, 0x80(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x371e0
movsd 0x28(%rsp), %xmm1
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movsd 0x40(%rsp), %xmm2
movsd 0x48(%rsp), %xmm3
movsd 0x50(%rsp), %xmm4
movsd 0x58(%rsp), %xmm5
movsd 0x60(%rsp), %xmm6
movsd 0x68(%rsp), %xmm7
movsd 0x70(%rsp), %xmm12
movsd 0x78(%rsp), %xmm11
movsd 0x80(%rsp), %xmm10
movaps %xmm0, %xmm9
movsd 0x88(%rsp), %xmm0
movsd 0xb8(%rsp), %xmm8
movq 0xb0(%rsp), %rdx
movq 0x100(%rsp), %rcx
movq 0x108(%rsp), %r8
movsd %xmm12, (%rsp)
movsd %xmm11, 0x8(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm8, 0x20(%rsp)
callq 0x28940
movl %eax, 0x94(%rsp)
movq 0xc0(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x28929
movq 0xe0(%rsp), %rax
movsd 0x1c9af(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0xd8(%rsp), %rax
movsd 0x1c997(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0xb0(%rsp), %rax
movsd 0x1c97f(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0x100(%rsp), %rax
movsd 0x1c967(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0x108(%rsp), %rax
movsd 0x1c94f(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl 0x94(%rsp), %eax
addq $0xf8, %rsp
retq
nopl (%rax,%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CECoordinates.cpp |
CECoordinates::ICRS2CIRS(double, double, double*, double*, CEDate const&, CEAngleType const&) | void CECoordinates::ICRS2CIRS(double input_ra, double input_dec,
double *return_ra, double *return_dec,
const CEDate& date, const CEAngleType& angle_type)
{
// Convert to radians if necessary
if (angle_type==CEAngleType::DEGREES) {
input_ra *= DD2R ;
input_dec *= DD2R ;
}
// Store the equation of the origins
double eo ; // Equation of the origins
// Use the sofa library to convert these coordinates
try {
double tdb1(0.0);
double tdb2(0.0);
CEDate::UTC2TDB(date.MJD(), &tdb1, &tdb2);
iauAtci13(input_ra, input_dec,
0.0, 0.0, 0.0, 0.0,
tdb1, tdb2,
return_ra, return_dec, &eo) ;
// Subtract the equation of the origins if J2000 coordinates are desired
//*return_ra -= eo ;
} catch (std::exception &e) {
throw CEException::sofa_exception("CECoordinates::ICRS2CIRS",
"iauAtci13",
"Exception thrown");
}
// Convert the returned coordinates to the correct angle type
if (angle_type == CEAngleType::DEGREES) {
*return_ra *= DR2D ;
*return_dec *= DR2D ;
}
return ;
} | subq $0x108, %rsp # imm = 0x108
movsd %xmm0, 0x100(%rsp)
movsd %xmm1, 0xf8(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rcx, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x28e7a
movsd 0x1c3fa(%rip), %xmm0 # 0x45248
mulsd 0x100(%rsp), %xmm0
movsd %xmm0, 0x100(%rsp)
movsd 0x1c3e0(%rip), %xmm0 # 0x45248
mulsd 0xf8(%rsp), %xmm0
movsd %xmm0, 0xf8(%rsp)
movq $0x0, 0xc8(%rsp)
movq $0x0, 0xc0(%rsp)
movq 0xe0(%rsp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movsd %xmm0, 0x20(%rsp)
jmp 0x28eab
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0xb8(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x36f90
jmp 0x28ed9
movsd 0x100(%rsp), %xmm0
movsd 0xf8(%rsp), %xmm1
movsd 0xc8(%rsp), %xmm6
movsd 0xc0(%rsp), %xmm7
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
xorps %xmm5, %xmm5
leaq 0xd0(%rsp), %rdx
movaps %xmm5, %xmm2
movaps %xmm5, %xmm3
movaps %xmm5, %xmm4
callq 0x1c410
jmp 0x28f28
jmp 0x290e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
movl 0xac(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2912a
movq 0xb0(%rsp), %rdi
callq 0x1c170
movq %rax, 0xa0(%rsp)
movb $0x1, 0x2e(%rsp)
movl $0xa8, %edi
callq 0x1c1c0
movq %rax, 0x10(%rsp)
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1c740
movq 0x18(%rsp), %rdx
leaq 0x1c5d7(%rip), %rsi # 0x45570
leaq 0x80(%rsp), %rdi
callq 0x1c560
jmp 0x28fa8
leaq 0x57(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1c740
movq 0x8(%rsp), %rdx
leaq 0x1c5c6(%rip), %rsi # 0x45589
leaq 0x58(%rsp), %rdi
callq 0x1c560
jmp 0x28fcf
leaq 0x2f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x1c740
movq (%rsp), %rdx
leaq 0x1c5ab(%rip), %rsi # 0x45593
leaq 0x30(%rsp), %rdi
callq 0x1c560
jmp 0x28ff4
movq 0x10(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x58(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0x37ba0
jmp 0x29012
movq 0x10(%rsp), %rdi
movb $0x0, 0x2e(%rsp)
leaq 0x2978d(%rip), %rsi # 0x527b0
leaq 0x4a16(%rip), %rdx # 0x2da40
callq 0x1c6f0
jmp 0x2913f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x290bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x290a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x29094
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1c230
leaq 0x2f(%rsp), %rdi
callq 0x1c420
leaq 0x58(%rsp), %rdi
callq 0x1c230
leaq 0x57(%rsp), %rdi
callq 0x1c420
leaq 0x80(%rsp), %rdi
callq 0x1c230
leaq 0x7f(%rsp), %rdi
callq 0x1c420
testb $0x1, 0x2e(%rsp)
jne 0x290d2
jmp 0x290dc
movq 0x10(%rsp), %rdi
callq 0x1c2a0
callq 0x1c6c0
jmp 0x290e3
jmp 0x2912a
movq 0xd8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x29122
movq 0xf0(%rsp), %rax
movsd 0x1c16e(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0xe8(%rsp), %rax
movsd 0x1c156(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0x108, %rsp # imm = 0x108
retq
movq 0xb0(%rsp), %rdi
callq 0x1c730
movq %rax, %rdi
callq 0x20390
nop
| /Jvinniec[P]CppEphem/cppephem/src/CECoordinates.cpp |
CECoordinates::ICRS2Observed(double, double, double*, double*, CEDate const&, CEObserver const&, CEAngleType const&, double, double*, double*, double*) | int CECoordinates::ICRS2Observed(double ra, double dec,
double *az, double *zen,
const CEDate& date,
const CEObserver& observer,
const CEAngleType& angle_type,
double wavelength,
double *observed_ra,
double *observed_dec,
double *hour_angle)
{
// Setup the observed RA, Dec and hour_angle variables
double temp_ra(0.0);
double temp_dec(0.0);
double temp_hour_angle(0.0);
// If values were not passed, point them at the temporary ones
if (observed_ra == nullptr) observed_ra = &temp_ra;
if (observed_dec == nullptr) observed_dec = &temp_dec;
if (hour_angle == nullptr) hour_angle = &temp_hour_angle;
// If we've passed in angles that are in degrees we need to convert to radians
if (angle_type == CEAngleType::DEGREES) {
ra *= DD2R ;
dec *= DD2R ;
}
// Call the necessary sofa method
int err_code = ICRS2Observed(ra, dec,
az, zen,
date.JD(),
observer.Longitude_Rad(),
observer.Latitude_Rad(),
observer.Elevation_m(),
observer.Pressure_hPa(),
observer.Temperature_C(),
observer.RelativeHumidity(),
date.dut1(),
date.xpolar(),
date.ypolar(),
wavelength,
observed_ra, observed_dec, hour_angle) ;
// Now convert back to degrees if that's what we were passed
if (angle_type == CEAngleType::DEGREES) {
*az *= DR2D ;
*zen *= DR2D ;
*observed_ra *= DR2D ;
*observed_dec *= DR2D ;
*hour_angle *= DR2D ;
}
return err_code ;
} | subq $0xf8, %rsp
movq 0x108(%rsp), %rax
movq 0x100(%rsp), %rax
movsd %xmm0, 0xf0(%rsp)
movsd %xmm1, 0xe8(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq %r8, 0xc0(%rsp)
movsd %xmm2, 0xb8(%rsp)
movq %r9, 0xb0(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0xa8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0xa0(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x98(%rsp)
cmpq $0x0, 0xb0(%rsp)
jne 0x291e1
leaq 0xa8(%rsp), %rax
movq %rax, 0xb0(%rsp)
cmpq $0x0, 0x100(%rsp)
jne 0x291fc
leaq 0xa0(%rsp), %rax
movq %rax, 0x100(%rsp)
cmpq $0x0, 0x108(%rsp)
jne 0x29217
leaq 0x98(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0xc0(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x29258
movsd 0x1c01c(%rip), %xmm0 # 0x45248
mulsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0x1c002(%rip), %xmm0 # 0x45248
mulsd 0xe8(%rsp), %xmm0
movsd %xmm0, 0xe8(%rsp)
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x88(%rsp)
movsd 0xe8(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xd0(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movsd %xmm0, 0x40(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x2d9e0
movsd %xmm0, 0x48(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x2d9f0
movsd %xmm0, 0x50(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x2da00
movsd %xmm0, 0x58(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x2da10
movsd %xmm0, 0x60(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x2da20
movsd %xmm0, 0x68(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x2da30
movsd %xmm0, 0x70(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x37060
movsd %xmm0, 0x78(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x37120
movsd %xmm0, 0x80(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x371e0
movsd 0x28(%rsp), %xmm1
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movsd 0x40(%rsp), %xmm2
movsd 0x48(%rsp), %xmm3
movsd 0x50(%rsp), %xmm4
movsd 0x58(%rsp), %xmm5
movsd 0x60(%rsp), %xmm6
movsd 0x68(%rsp), %xmm7
movsd 0x70(%rsp), %xmm12
movsd 0x78(%rsp), %xmm11
movsd 0x80(%rsp), %xmm10
movaps %xmm0, %xmm9
movsd 0x88(%rsp), %xmm0
movsd 0xb8(%rsp), %xmm8
movq 0xb0(%rsp), %rdx
movq 0x100(%rsp), %rcx
movq 0x108(%rsp), %r8
movsd %xmm12, (%rsp)
movsd %xmm11, 0x8(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm8, 0x20(%rsp)
callq 0x29490
movl %eax, 0x94(%rsp)
movq 0xc0(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x2947d
movq 0xe0(%rsp), %rax
movsd 0x1be5b(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0xd8(%rsp), %rax
movsd 0x1be43(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0xb0(%rsp), %rax
movsd 0x1be2b(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0x100(%rsp), %rax
movsd 0x1be13(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0x108(%rsp), %rax
movsd 0x1bdfb(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl 0x94(%rsp), %eax
addq $0xf8, %rsp
retq
nopl (%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CECoordinates.cpp |
CECoordinates::ICRS2Observed(double, double, double*, double*, double, double, double, double, double, double, double, double, double, double, double, double*, double*, double*) | int CECoordinates::ICRS2Observed(double ra, double dec,
double *az, double *zen,
double julian_date,
double longitude,
double latitude,
double elevation_m,
double pressure_hPa,
double temperature_celsius,
double relative_humidity,
double dut1,
double xp, double yp,
double wavelength_um,
double *observed_ra,
double *observed_dec,
double *hour_angle)
{
// Setup the observed RA, Dec and hour_angle variables
double temp_ra(0.0);
double temp_dec(0.0);
double temp_hour_angle(0.0);
// If values were passed, point these variables at the passed ones
if (observed_ra == nullptr) observed_ra = &temp_ra;
if (observed_dec == nullptr) observed_dec = &temp_dec;
if (hour_angle == nullptr) hour_angle = &temp_hour_angle;
// First convert the ICRS coordinates to CIRS coordinates
CEDate date(julian_date, CEDateType::JD) ;
ICRS2CIRS(ra, dec, &ra, &dec, date) ;
// Call the necessary sofa method
int err_code = CIRS2Observed(ra, dec,
az, zen,
julian_date,
longitude,
latitude,
elevation_m,
pressure_hPa,
temperature_celsius,
relative_humidity,
dut1, xp, yp,
wavelength_um,
observed_ra,
observed_dec,
hour_angle) ;
// Convert the apparent CIRS RA,Dec to ICRS RA,Dec
CIRS2ICRS(*observed_ra, *observed_dec, observed_ra, observed_dec,
date, CEAngleType::RADIANS) ;
return err_code ;
} | subq $0x118, %rsp # imm = 0x118
movsd 0x140(%rsp), %xmm8
movsd 0x138(%rsp), %xmm8
movsd 0x130(%rsp), %xmm8
movsd 0x128(%rsp), %xmm8
movsd 0x120(%rsp), %xmm8
movsd %xmm0, 0x110(%rsp)
movsd %xmm1, 0x108(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movsd %xmm2, 0xf0(%rsp)
movsd %xmm3, 0xe8(%rsp)
movsd %xmm4, 0xe0(%rsp)
movsd %xmm5, 0xd8(%rsp)
movsd %xmm6, 0xd0(%rsp)
movsd %xmm7, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0xa8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0xa0(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x98(%rsp)
cmpq $0x0, 0xc0(%rsp)
jne 0x29578
leaq 0xa8(%rsp), %rax
movq %rax, 0xc0(%rsp)
cmpq $0x0, 0xb8(%rsp)
jne 0x29593
leaq 0xa0(%rsp), %rax
movq %rax, 0xb8(%rsp)
cmpq $0x0, 0xb0(%rsp)
jne 0x295ae
leaq 0x98(%rsp), %rax
movq %rax, 0xb0(%rsp)
movsd 0xf0(%rsp), %xmm0
leaq 0x58(%rsp), %rdi
movq %rdi, 0x30(%rsp)
xorl %esi, %esi
callq 0x358e0
movq 0x30(%rsp), %rdx
movsd 0x110(%rsp), %xmm0
movsd 0x108(%rsp), %xmm1
movl $0x1, 0x54(%rsp)
leaq 0x110(%rsp), %rdi
leaq 0x108(%rsp), %rsi
leaq 0x54(%rsp), %rcx
callq 0x28e00
jmp 0x29603
movsd 0x110(%rsp), %xmm0
movsd 0x108(%rsp), %xmm1
movq 0x100(%rsp), %rdi
movq 0xf8(%rsp), %rsi
movsd 0xf0(%rsp), %xmm2
movsd 0xe8(%rsp), %xmm3
movsd 0xe0(%rsp), %xmm4
movsd 0xd8(%rsp), %xmm5
movsd 0xd0(%rsp), %xmm6
movsd 0xc8(%rsp), %xmm7
movsd 0x120(%rsp), %xmm8
movsd 0x128(%rsp), %xmm9
movsd 0x130(%rsp), %xmm10
movsd 0x138(%rsp), %xmm11
movsd 0x140(%rsp), %xmm12
movq 0xc0(%rsp), %rdx
movq 0xb8(%rsp), %rcx
movq 0xb0(%rsp), %r8
movq %rsp, %rax
movsd %xmm12, 0x20(%rax)
movsd %xmm11, 0x18(%rax)
movsd %xmm10, 0x10(%rax)
movsd %xmm9, 0x8(%rax)
movsd %xmm8, (%rax)
callq 0x28940
movl %eax, 0x2c(%rsp)
jmp 0x296d0
movl 0x2c(%rsp), %eax
movl %eax, 0x40(%rsp)
movq 0xc0(%rsp), %rdi
movsd (%rdi), %xmm0
movq 0xb8(%rsp), %rsi
movsd (%rsi), %xmm1
movl $0x1, 0x3c(%rsp)
leaq 0x58(%rsp), %rdx
leaq 0x3c(%rsp), %rcx
callq 0x28360
jmp 0x29709
movl 0x40(%rsp), %eax
movl %eax, 0x28(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x36030
movl 0x28(%rsp), %eax
addq $0x118, %rsp # imm = 0x118
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x36030
movq 0x48(%rsp), %rdi
callq 0x1c730
nopl (%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CECoordinates.cpp |
CECoordinates::Galactic2CIRS(double, double, double*, double*, CEDate const&, CEAngleType const&) | void CECoordinates::Galactic2CIRS(double glon, double glat, double *ra, double *dec,
const CEDate& date, const CEAngleType& angle_type)
{
// Check for degrees
if (angle_type == CEAngleType::DEGREES) {
glon *= DD2R ;
glat *= DD2R ;
}
// Do the Galactic -> ICRS converstion
Galactic2ICRS(glon, glat, ra, dec, CEAngleType::RADIANS) ;
// Now convert ICRS -> CIRS
double tmp_ra(*ra);
double tmp_dec(*dec);
ICRS2CIRS(tmp_ra, tmp_dec, ra, dec, date, CEAngleType::RADIANS) ;
// Now make sure to return the coordinates in the correct format
if (angle_type == CEAngleType::DEGREES) {
*ra *= DR2D ;
*dec *= DR2D ;
}
} | subq $0x58, %rsp
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x297a6
movsd 0x1bac2(%rip), %xmm0 # 0x45248
mulsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x1baae(%rip), %xmm0 # 0x45248
mulsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0x1, 0x24(%rsp)
leaq 0x24(%rsp), %rdx
callq 0x29860
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl $0x1, 0xc(%rsp)
leaq 0xc(%rsp), %rcx
callq 0x28e00
movq 0x28(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x2984d
movq 0x40(%rsp), %rax
movsd 0x1ba40(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0x38(%rsp), %rax
movsd 0x1ba2b(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CECoordinates.cpp |
CECoordinates::Galactic2Observed(double, double, double*, double*, CEDate const&, CEObserver const&, CEAngleType const&, double, double*, double*, double*) | int CECoordinates::Galactic2Observed(double glon, double glat,
double *az, double *zen,
const CEDate& date,
const CEObserver& observer,
const CEAngleType& angle_type,
double wavelength,
double *observed_glon,
double *observed_glat,
double *hour_angle)
{
// Convert angles to radians if necessary
if (angle_type == CEAngleType::DEGREES) {
glon *= DD2R ;
glat *= DD2R ;
}
// Do the conversion
int error_code = Galactic2Observed(glon, glat,
az, zen,
date.JD(),
observer.Longitude_Rad(),
observer.Latitude_Rad(),
observer.Elevation_m(),
observer.Pressure_hPa(),
observer.Temperature_C(),
observer.RelativeHumidity(),
date.dut1(),
date.xpolar(),
date.ypolar(),
wavelength,
observed_glon, observed_glat, hour_angle) ;
// Convert back to degrees if necessary
if (angle_type == CEAngleType::DEGREES) {
*az *= DR2D ;
*zen *= DR2D ;
if (observed_glon != nullptr) *observed_glon *= DR2D ;
if (observed_glat != nullptr) *observed_glat *= DR2D ;
if (hour_angle != nullptr) *hour_angle *= DR2D ;
}
return error_code;
} | subq $0xe8, %rsp
movq 0xf8(%rsp), %rax
movq 0xf0(%rsp), %rax
movsd %xmm0, 0xe0(%rsp)
movsd %xmm1, 0xd8(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
movsd %xmm2, 0xa8(%rsp)
movq %r9, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x299b3
movsd 0x1b8c1(%rip), %xmm0 # 0x45248
mulsd 0xe0(%rsp), %xmm0
movsd %xmm0, 0xe0(%rsp)
movsd 0x1b8a7(%rip), %xmm0 # 0x45248
mulsd 0xd8(%rsp), %xmm0
movsd %xmm0, 0xd8(%rsp)
movsd 0xe0(%rsp), %xmm0
movsd %xmm0, 0x90(%rsp)
movsd 0xd8(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0xc0(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movsd %xmm0, 0x48(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x2d9e0
movsd %xmm0, 0x50(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x2d9f0
movsd %xmm0, 0x58(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x2da00
movsd %xmm0, 0x60(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x2da10
movsd %xmm0, 0x68(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x2da20
movsd %xmm0, 0x70(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x2da30
movsd %xmm0, 0x78(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x37060
movsd %xmm0, 0x80(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x37120
movsd %xmm0, 0x88(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x371e0
movsd 0x30(%rsp), %xmm1
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movsd 0x48(%rsp), %xmm2
movsd 0x50(%rsp), %xmm3
movsd 0x58(%rsp), %xmm4
movsd 0x60(%rsp), %xmm5
movsd 0x68(%rsp), %xmm6
movsd 0x70(%rsp), %xmm7
movsd 0x78(%rsp), %xmm12
movsd 0x80(%rsp), %xmm11
movsd 0x88(%rsp), %xmm10
movaps %xmm0, %xmm9
movsd 0x90(%rsp), %xmm0
movsd 0xa8(%rsp), %xmm8
movq 0xa0(%rsp), %rdx
movq 0xf0(%rsp), %rcx
movq 0xf8(%rsp), %r8
movsd %xmm12, (%rsp)
movsd %xmm11, 0x8(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm8, 0x20(%rsp)
callq 0x29c20
movl %eax, 0x9c(%rsp)
movq 0xb0(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x29c05
movq 0xd0(%rsp), %rax
movsd 0x1b6f6(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0xc8(%rsp), %rax
movsd 0x1b6de(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
cmpq $0x0, 0xa0(%rsp)
je 0x29bbd
movq 0xa0(%rsp), %rax
movsd 0x1b6bb(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
cmpq $0x0, 0xf0(%rsp)
je 0x29be0
movq 0xf0(%rsp), %rax
movsd 0x1b698(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
cmpq $0x0, 0xf8(%rsp)
je 0x29c03
movq 0xf8(%rsp), %rax
movsd 0x1b675(%rip), %xmm0 # 0x45270
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x29c05
movl 0x9c(%rsp), %eax
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CECoordinates.cpp |
CECoordinates::Galactic2Observed(double, double, double*, double*, double, double, double, double, double, double, double, double, double, double, double, double*, double*, double*) | int CECoordinates::Galactic2Observed(double glon, double glat,
double *az, double *zen,
double julian_date,
double longitude,
double latitude,
double elevation_m,
double pressure_hPa,
double temperature_celsius,
double relative_humidity,
double dut1,
double xp, double yp,
double wavelength,
double *observed_glon,
double *observed_glat,
double *hour_angle)
{
// Setup the observed RA, Dec and hour_angle variables
double temp_glon(0.0);
double temp_glat(0.0);
double temp_ra(0.0);
double temp_dec(0.0);
double temp_hour_angle(0.0);
// If values were passed, point these variables at the passed ones
if (observed_glon == nullptr) observed_glon = &temp_glon;
if (observed_glat == nullptr) observed_glat = &temp_glat;
if (hour_angle == nullptr) hour_angle = &temp_hour_angle;
// Convert GALACTIC to ICRS
double ra(0.0);
double dec(0.0);
CEDate date(julian_date, CEDateType::JD) ;
Galactic2CIRS(glon, glat, &ra, &dec, date) ;
// Call the necessary sofa method
int err_code = CIRS2Observed(ra, dec,
az, zen,
julian_date,
longitude,
latitude,
elevation_m,
pressure_hPa,
temperature_celsius,
relative_humidity,
dut1, xp, yp,
wavelength,
&temp_ra,
&temp_dec,
&temp_hour_angle) ;
// Convert the apparent RA,Dec to galactic longitude,latitude
CIRS2Galactic(temp_ra, temp_dec, observed_glon, observed_glat, date) ;
return err_code ;
} | subq $0x138, %rsp # imm = 0x138
movsd 0x160(%rsp), %xmm8
movsd 0x158(%rsp), %xmm8
movsd 0x150(%rsp), %xmm8
movsd 0x148(%rsp), %xmm8
movsd 0x140(%rsp), %xmm8
movsd %xmm0, 0x130(%rsp)
movsd %xmm1, 0x128(%rsp)
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movsd %xmm2, 0x110(%rsp)
movsd %xmm3, 0x108(%rsp)
movsd %xmm4, 0x100(%rsp)
movsd %xmm5, 0xf8(%rsp)
movsd %xmm6, 0xf0(%rsp)
movsd %xmm7, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rcx, 0xd8(%rsp)
movq %r8, 0xd0(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0xc8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0xb8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0xb0(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0xa8(%rsp)
cmpq $0x0, 0xe0(%rsp)
jne 0x29d20
leaq 0xc8(%rsp), %rax
movq %rax, 0xe0(%rsp)
cmpq $0x0, 0xd8(%rsp)
jne 0x29d3b
leaq 0xc0(%rsp), %rax
movq %rax, 0xd8(%rsp)
cmpq $0x0, 0xd0(%rsp)
jne 0x29d56
leaq 0xa8(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq $0x0, 0xa0(%rsp)
movq $0x0, 0x98(%rsp)
movsd 0x110(%rsp), %xmm0
leaq 0x58(%rsp), %rdi
movq %rdi, 0x30(%rsp)
xorl %esi, %esi
callq 0x358e0
movq 0x30(%rsp), %rdx
movsd 0x130(%rsp), %xmm0
movsd 0x128(%rsp), %xmm1
movl $0x1, 0x54(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x54(%rsp), %rcx
callq 0x29750
jmp 0x29dc3
movsd 0xa0(%rsp), %xmm0
movsd 0x98(%rsp), %xmm1
movq 0x120(%rsp), %rdi
movq 0x118(%rsp), %rsi
movsd 0x110(%rsp), %xmm2
movsd 0x108(%rsp), %xmm3
movsd 0x100(%rsp), %xmm4
movsd 0xf8(%rsp), %xmm5
movsd 0xf0(%rsp), %xmm6
movsd 0xe8(%rsp), %xmm7
movsd 0x140(%rsp), %xmm8
movsd 0x148(%rsp), %xmm9
movsd 0x150(%rsp), %xmm10
movsd 0x158(%rsp), %xmm11
movsd 0x160(%rsp), %xmm12
movq %rsp, %rax
movsd %xmm12, 0x20(%rax)
movsd %xmm11, 0x18(%rax)
movsd %xmm10, 0x10(%rax)
movsd %xmm9, 0x8(%rax)
movsd %xmm8, (%rax)
leaq 0xb8(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
leaq 0xa8(%rsp), %r8
callq 0x28940
movl %eax, 0x2c(%rsp)
jmp 0x29e90
movl 0x2c(%rsp), %eax
movl %eax, 0x40(%rsp)
movsd 0xb8(%rsp), %xmm0
movsd 0xb0(%rsp), %xmm1
movq 0xe0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
movl $0x1, 0x3c(%rsp)
leaq 0x58(%rsp), %rdx
leaq 0x3c(%rsp), %rcx
callq 0x28460
jmp 0x29ed3
movl 0x40(%rsp), %eax
movl %eax, 0x28(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x36030
movl 0x28(%rsp), %eax
addq $0x138, %rsp # imm = 0x138
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x36030
movq 0x48(%rsp), %rdi
callq 0x1c730
nopw %cs:(%rax,%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CECoordinates.cpp |
CECoordinates::Observed2ICRS(double, double, double*, double*, double, double, double, double, double, double, double, double, double, double, double) | int CECoordinates::Observed2ICRS(double az, double zen,
double *ra, double *dec,
double julian_date,
double longitude,
double latitude,
double elevation_m,
double pressure_hPa,
double temperature_celsius,
double relative_humidity,
double dut1,
double xp, double yp,
double wavelength_um)
{
// Convert from Observed -> CIRS
int err_code = Observed2CIRS(az, zen,
ra, dec,
julian_date,
longitude, latitude,
elevation_m, pressure_hPa,
temperature_celsius, relative_humidity,
dut1, xp, yp, wavelength_um) ;
if (err_code == 0) {
// Convert from CIRS -> ICRS
CIRS2ICRS(*ra, *dec, ra, dec,
CEDate(julian_date,CEDateType::JD),
CEAngleType::RADIANS) ;
}
return err_code ;
} | subq $0x108, %rsp # imm = 0x108
movsd 0x130(%rsp), %xmm8
movsd 0x128(%rsp), %xmm8
movsd 0x120(%rsp), %xmm8
movsd 0x118(%rsp), %xmm8
movsd 0x110(%rsp), %xmm8
movsd %xmm0, 0x100(%rsp)
movsd %xmm1, 0xf8(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movsd %xmm2, 0xe0(%rsp)
movsd %xmm3, 0xd8(%rsp)
movsd %xmm4, 0xd0(%rsp)
movsd %xmm5, 0xc8(%rsp)
movsd %xmm6, 0xc0(%rsp)
movsd %xmm7, 0xb8(%rsp)
movsd 0x100(%rsp), %xmm0
movsd 0xf8(%rsp), %xmm1
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movsd 0xe0(%rsp), %xmm2
movsd 0xd8(%rsp), %xmm3
movsd 0xd0(%rsp), %xmm4
movsd 0xc8(%rsp), %xmm5
movsd 0xc0(%rsp), %xmm6
movsd 0xb8(%rsp), %xmm7
movsd 0x110(%rsp), %xmm12
movsd 0x118(%rsp), %xmm11
movsd 0x120(%rsp), %xmm10
movsd 0x128(%rsp), %xmm9
movsd 0x130(%rsp), %xmm8
movsd %xmm12, (%rsp)
movsd %xmm11, 0x8(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm8, 0x20(%rsp)
callq 0x2a190
movl %eax, 0xb4(%rsp)
cmpl $0x0, 0xb4(%rsp)
jne 0x2a7e4
movq 0xf0(%rsp), %rax
movq %rax, 0x40(%rsp)
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x48(%rsp)
movsd (%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0xe0(%rsp), %xmm0
leaq 0x70(%rsp), %rdi
movq %rdi, 0x50(%rsp)
xorl %esi, %esi
callq 0x358e0
movsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movl $0x1, 0x6c(%rsp)
leaq 0x6c(%rsp), %rcx
callq 0x28360
jmp 0x2a7be
leaq 0x70(%rsp), %rdi
callq 0x36030
jmp 0x2a7e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x36030
jmp 0x2a7f3
movl 0xb4(%rsp), %eax
addq $0x108, %rsp # imm = 0x108
retq
movq 0x60(%rsp), %rdi
callq 0x1c730
nopl (%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CECoordinates.cpp |
CECoordinates::ConvertTo(CECoordinateType, double, double, double, double, double, double, double, double, double, double, double) | CECoordinates CECoordinates::ConvertTo(CECoordinateType output_coord_type,
double jd,
double longitude,
double latitude,
double elevation_m,
double pressure_hPa,
double temperature_celsius,
double relative_humidity,
double dut1,
double xp, double yp,
double wavelength_um)
{
// Create return coordinate object
CECoordinates out_coord;
// Do conversion to CIRS
if (output_coord_type == CECoordinateType::CIRS) {
out_coord = ConvertToCIRS(jd, longitude, latitude,
elevation_m, pressure_hPa,
temperature_celsius, relative_humidity,
dut1, xp, yp, wavelength_um) ;
} else if (output_coord_type == CECoordinateType::ICRS) {
out_coord = ConvertToICRS(jd, longitude, latitude,
elevation_m, pressure_hPa,
temperature_celsius, relative_humidity,
dut1, xp, yp, wavelength_um) ;
} else if (output_coord_type == CECoordinateType::GALACTIC) {
out_coord = ConvertToGalactic(jd, longitude, latitude,
elevation_m, pressure_hPa,
temperature_celsius, relative_humidity,
dut1, xp, yp, wavelength_um) ;
} else if (output_coord_type == CECoordinateType::OBSERVED) {
out_coord = ConvertToObserved(jd, longitude, latitude,
elevation_m, pressure_hPa,
temperature_celsius, relative_humidity,
dut1, xp, yp, wavelength_um) ;
}
return out_coord;
} | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movsd 0x180(%rsp), %xmm8
movsd 0x178(%rsp), %xmm8
movsd 0x170(%rsp), %xmm8
movq %rdi, 0x160(%rsp)
movq %rsi, 0x158(%rsp)
movl %edx, 0x154(%rsp)
movsd %xmm0, 0x148(%rsp)
movsd %xmm1, 0x140(%rsp)
movsd %xmm2, 0x138(%rsp)
movsd %xmm3, 0x130(%rsp)
movsd %xmm4, 0x128(%rsp)
movsd %xmm5, 0x120(%rsp)
movsd %xmm6, 0x118(%rsp)
movsd %xmm7, 0x110(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0x30(%rsp)
movb $0x0, 0x10f(%rsp)
callq 0x27c70
cmpl $0x0, 0x154(%rsp)
jne 0x2bc1c
movq 0x30(%rsp), %rsi
movsd 0x148(%rsp), %xmm0
movsd 0x140(%rsp), %xmm1
movsd 0x138(%rsp), %xmm2
movsd 0x130(%rsp), %xmm3
movsd 0x128(%rsp), %xmm4
movsd 0x120(%rsp), %xmm5
movsd 0x118(%rsp), %xmm6
movsd 0x110(%rsp), %xmm7
movsd 0x170(%rsp), %xmm8
movsd 0x178(%rsp), %xmm9
movsd 0x180(%rsp), %xmm10
movq %rsp, %rax
movsd %xmm10, 0x10(%rax)
movsd %xmm9, 0x8(%rax)
movsd %xmm8, (%rax)
leaq 0xd8(%rsp), %rdi
callq 0x2bf00
jmp 0x2bbb7
movq 0x20(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x28310
jmp 0x2bbcb
leaq 0xd8(%rsp), %rdi
callq 0x282a0
jmp 0x2bebc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x2bee5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0x282a0
jmp 0x2bee5
cmpl $0x1, 0x154(%rsp)
jne 0x2bd04
movq 0x30(%rsp), %rsi
movsd 0x148(%rsp), %xmm0
movsd 0x140(%rsp), %xmm1
movsd 0x138(%rsp), %xmm2
movsd 0x130(%rsp), %xmm3
movsd 0x128(%rsp), %xmm4
movsd 0x120(%rsp), %xmm5
movsd 0x118(%rsp), %xmm6
movsd 0x110(%rsp), %xmm7
movsd 0x170(%rsp), %xmm8
movsd 0x178(%rsp), %xmm9
movsd 0x180(%rsp), %xmm10
movq %rsp, %rax
movsd %xmm10, 0x10(%rax)
movsd %xmm9, 0x8(%rax)
movsd %xmm8, (%rax)
leaq 0x98(%rsp), %rdi
callq 0x2c350
jmp 0x2bcb8
movq 0x20(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x28310
jmp 0x2bccc
leaq 0x98(%rsp), %rdi
callq 0x282a0
jmp 0x2beba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x282a0
jmp 0x2bee5
cmpl $0x2, 0x154(%rsp)
jne 0x2bde0
movq 0x30(%rsp), %rsi
movsd 0x148(%rsp), %xmm0
movsd 0x140(%rsp), %xmm1
movsd 0x138(%rsp), %xmm2
movsd 0x130(%rsp), %xmm3
movsd 0x128(%rsp), %xmm4
movsd 0x120(%rsp), %xmm5
movsd 0x118(%rsp), %xmm6
movsd 0x110(%rsp), %xmm7
movsd 0x170(%rsp), %xmm8
movsd 0x178(%rsp), %xmm9
movsd 0x180(%rsp), %xmm10
movq %rsp, %rax
movsd %xmm10, 0x10(%rax)
movsd %xmm9, 0x8(%rax)
movsd %xmm8, (%rax)
leaq 0x68(%rsp), %rdi
callq 0x2c720
jmp 0x2bd9d
movq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x28310
jmp 0x2bdae
leaq 0x68(%rsp), %rdi
callq 0x282a0
jmp 0x2beb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x282a0
jmp 0x2bee5
cmpl $0x3, 0x154(%rsp)
jne 0x2beb6
movq 0x30(%rsp), %rsi
movsd 0x148(%rsp), %xmm0
movsd 0x140(%rsp), %xmm1
movsd 0x138(%rsp), %xmm2
movsd 0x130(%rsp), %xmm3
movsd 0x128(%rsp), %xmm4
movsd 0x120(%rsp), %xmm5
movsd 0x118(%rsp), %xmm6
movsd 0x110(%rsp), %xmm7
movsd 0x170(%rsp), %xmm8
movsd 0x178(%rsp), %xmm9
movsd 0x180(%rsp), %xmm10
movq %rsp, %rax
movsd %xmm10, 0x10(%rax)
movsd %xmm9, 0x8(%rax)
movsd %xmm8, (%rax)
leaq 0x38(%rsp), %rdi
callq 0x2caf0
jmp 0x2be79
movq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x28310
jmp 0x2be8a
leaq 0x38(%rsp), %rdi
callq 0x282a0
jmp 0x2beb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x282a0
jmp 0x2bee5
jmp 0x2beb8
jmp 0x2beba
jmp 0x2bebc
movb $0x1, 0x10f(%rsp)
testb $0x1, 0x10f(%rsp)
jne 0x2bed8
movq 0x20(%rsp), %rdi
callq 0x282a0
movq 0x28(%rsp), %rax
addq $0x168, %rsp # imm = 0x168
retq
movq 0x20(%rsp), %rdi
callq 0x282a0
movq 0xd0(%rsp), %rdi
callq 0x1c730
nopl (%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CECoordinates.cpp |
CECoordinates::ConvertToObserved(double, double, double, double, double, double, double, double, double, double, double) | CECoordinates CECoordinates::ConvertToObserved(double jd,
double longitude,
double latitude,
double elevation_m,
double pressure_hPa,
double temperature_celsius,
double relative_humidity,
double dut1,
double xp, double yp,
double wavelength_um)
{
double xcoord_new(0.0);
double ycoord_new(0.0);
double apparent_x, apparent_y, apparent_hourangle;
if (coord_type_ == CECoordinateType::CIRS) {
CIRS2Observed(XCoordinate_Rad(), YCoordinate_Rad(),
&xcoord_new, &ycoord_new,
jd,
longitude, latitude,
elevation_m, pressure_hPa,
temperature_celsius,
relative_humidity,
dut1, xp, yp,
wavelength_um,
&apparent_x, &apparent_y, &apparent_hourangle) ;
} else if (coord_type_ == CECoordinateType::ICRS) {
ICRS2Observed(XCoordinate_Rad(), YCoordinate_Rad(),
&xcoord_new, &ycoord_new,
jd,
longitude, latitude,
elevation_m, pressure_hPa,
temperature_celsius,
relative_humidity,
dut1, xp, yp,
wavelength_um,
&apparent_x, &apparent_y, &apparent_hourangle) ;
} else if (coord_type_ == CECoordinateType::GALACTIC) {
Galactic2Observed(XCoordinate_Rad(), YCoordinate_Rad(),
&xcoord_new, &ycoord_new,
jd,
longitude, latitude,
elevation_m, pressure_hPa,
temperature_celsius,
relative_humidity,
dut1, xp, yp,
wavelength_um,
&apparent_x, &apparent_y, &apparent_hourangle) ;
} else {
// Throw an exception
std::string msg = "[ERROR] ";
if (coord_type_ == CECoordinateType::OBSERVED) {
// Cant convert from observed to observed without additional
// observer information
msg += "Unable to convert to OBSERVED from OBSERVED";
}
throw CEException::invalid_value("CECoordinates::ConvertToObserved(long form)",
msg);
}
return CECoordinates(xcoord_new, ycoord_new, CECoordinateType::OBSERVED) ;
} | subq $0x178, %rsp # imm = 0x178
movq %rdi, 0x60(%rsp)
movq %rdi, %rax
movq %rax, 0x68(%rsp)
movsd 0x190(%rsp), %xmm8
movsd 0x188(%rsp), %xmm8
movsd 0x180(%rsp), %xmm8
movq %rdi, 0x170(%rsp)
movq %rsi, 0x168(%rsp)
movsd %xmm0, 0x160(%rsp)
movsd %xmm1, 0x158(%rsp)
movsd %xmm2, 0x150(%rsp)
movsd %xmm3, 0x148(%rsp)
movsd %xmm4, 0x140(%rsp)
movsd %xmm5, 0x138(%rsp)
movsd %xmm6, 0x130(%rsp)
movsd %xmm7, 0x128(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x70(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x120(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x118(%rsp)
cmpl $0x0, 0x28(%rax)
jne 0x2cc94
callq 0x1fd60
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movsd %xmm0, 0x58(%rsp)
callq 0x1fd60
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movaps %xmm0, %xmm1
movsd 0x58(%rsp), %xmm0
movsd 0x160(%rsp), %xmm2
movsd 0x158(%rsp), %xmm3
movsd 0x150(%rsp), %xmm4
movsd 0x148(%rsp), %xmm5
movsd 0x140(%rsp), %xmm6
movsd 0x138(%rsp), %xmm7
movsd 0x130(%rsp), %xmm12
movsd 0x128(%rsp), %xmm11
movsd 0x180(%rsp), %xmm10
movsd 0x188(%rsp), %xmm9
movsd 0x190(%rsp), %xmm8
leaq 0x120(%rsp), %rdi
leaq 0x118(%rsp), %rsi
leaq 0x110(%rsp), %rdx
leaq 0x108(%rsp), %rcx
leaq 0x100(%rsp), %r8
movsd %xmm12, (%rsp)
movsd %xmm11, 0x8(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm8, 0x20(%rsp)
callq 0x28940
jmp 0x2d01b
movq 0x70(%rsp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x2cd8e
callq 0x1fd60
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movsd %xmm0, 0x50(%rsp)
callq 0x1fd60
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movaps %xmm0, %xmm1
movsd 0x50(%rsp), %xmm0
movsd 0x160(%rsp), %xmm2
movsd 0x158(%rsp), %xmm3
movsd 0x150(%rsp), %xmm4
movsd 0x148(%rsp), %xmm5
movsd 0x140(%rsp), %xmm6
movsd 0x138(%rsp), %xmm7
movsd 0x130(%rsp), %xmm12
movsd 0x128(%rsp), %xmm11
movsd 0x180(%rsp), %xmm10
movsd 0x188(%rsp), %xmm9
movsd 0x190(%rsp), %xmm8
leaq 0x120(%rsp), %rdi
leaq 0x118(%rsp), %rsi
leaq 0x110(%rsp), %rdx
leaq 0x108(%rsp), %rcx
leaq 0x100(%rsp), %r8
movsd %xmm12, (%rsp)
movsd %xmm11, 0x8(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm8, 0x20(%rsp)
callq 0x29490
jmp 0x2d019
movq 0x70(%rsp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x2ce88
callq 0x1fd60
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movsd %xmm0, 0x48(%rsp)
callq 0x1fd60
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movaps %xmm0, %xmm1
movsd 0x48(%rsp), %xmm0
movsd 0x160(%rsp), %xmm2
movsd 0x158(%rsp), %xmm3
movsd 0x150(%rsp), %xmm4
movsd 0x148(%rsp), %xmm5
movsd 0x140(%rsp), %xmm6
movsd 0x138(%rsp), %xmm7
movsd 0x130(%rsp), %xmm12
movsd 0x128(%rsp), %xmm11
movsd 0x180(%rsp), %xmm10
movsd 0x188(%rsp), %xmm9
movsd 0x190(%rsp), %xmm8
leaq 0x120(%rsp), %rdi
leaq 0x118(%rsp), %rsi
leaq 0x110(%rsp), %rdx
leaq 0x108(%rsp), %rcx
leaq 0x100(%rsp), %r8
movsd %xmm12, (%rsp)
movsd %xmm11, 0x8(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm8, 0x20(%rsp)
callq 0x29c20
jmp 0x2d017
leaq 0xdf(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x1c740
movq 0x40(%rsp), %rdx
leaq 0x18521(%rip), %rsi # 0x453c7
leaq 0xe0(%rsp), %rdi
callq 0x1c560
jmp 0x2ceb5
leaq 0xdf(%rsp), %rdi
callq 0x1c420
movq 0x70(%rsp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x2cf24
leaq 0x1875d(%rip), %rsi # 0x45631
leaq 0xe0(%rsp), %rdi
callq 0x1c390
jmp 0x2cee3
jmp 0x2cf24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0xdf(%rsp), %rdi
callq 0x1c420
jmp 0x2d0db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x2d005
movb $0x1, 0xa6(%rsp)
movl $0xa8, %edi
callq 0x1c1c0
movq %rax, 0x30(%rsp)
leaq 0xa7(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x1c740
movq 0x38(%rsp), %rdx
leaq 0x18704(%rip), %rsi # 0x4565d
leaq 0xa8(%rsp), %rdi
callq 0x1c560
jmp 0x2cf68
movq 0x30(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0xe0(%rsp), %rdx
callq 0x37900
jmp 0x2cf84
movq 0x30(%rsp), %rdi
movb $0x0, 0xa6(%rsp)
leaq 0x256f0(%rip), %rsi # 0x52688
leaq -0x7d1f(%rip), %rdx # 0x25280
callq 0x1c6f0
jmp 0x2d0e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x2cfe0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x1c230
leaq 0xa7(%rsp), %rdi
callq 0x1c420
testb $0x1, 0xa6(%rsp)
jne 0x2cff9
jmp 0x2d003
movq 0x30(%rsp), %rdi
callq 0x1c2a0
jmp 0x2d005
leaq 0xe0(%rsp), %rdi
callq 0x1c230
jmp 0x2d0db
jmp 0x2d019
jmp 0x2d01b
leaq 0x90(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x22980
leaq 0x80(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0x22980
jmp 0x2d047
movq 0x60(%rsp), %rdi
movl $0x3, 0x7c(%rsp)
leaq 0x90(%rsp), %rsi
leaq 0x80(%rsp), %rdx
leaq 0x7c(%rsp), %rcx
callq 0x27d60
jmp 0x2d070
leaq 0x80(%rsp), %rdi
callq 0x22bd0
leaq 0x90(%rsp), %rdi
callq 0x22bd0
movq 0x68(%rsp), %rax
addq $0x178, %rsp # imm = 0x178
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x2d0ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x22bd0
leaq 0x90(%rsp), %rdi
callq 0x22bd0
movq 0xd0(%rsp), %rdi
callq 0x1c730
nopl (%rax,%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CECoordinates.cpp |
CEDate::SetDate(double const&, CEDateType const&) | void CEDate::SetDate(const double& date,
const CEDateType& time_format)
{
// Fill the internal date storage objects based on the format of the input "date"
if (time_format == CEDateType::JD) {
// Save information based on julian date input
julian_date_ = date ;
mod_julian_date_ = JD2MJD(date) ;
gregorian_date_ = JD2Gregorian(date) ;
gregorian_date_vect_ = JD2GregorianVect(date) ;
} else if (time_format == CEDateType::MJD) {
// Save information based on modified julian date input
julian_date_ = MJD2JD(date) ;
mod_julian_date_ = date ;
gregorian_date_ = MJD2Gregorian(date) ;
gregorian_date_vect_ = MJD2GregorianVect(date) ;
} else if (time_format == CEDateType::GREGORIAN) {
// Save information based on gregorian date input
julian_date_ = Gregorian2JD(date) ;
mod_julian_date_ = Gregorian2MJD(date) ;
gregorian_date_ = date ;
gregorian_date_vect_ = Gregorian2GregorianVect(date) ;
} else {
// Date type is invalid
throw CEException::invalid_value("CEDate::SetDate()",
"Invalid date type");
}
} | subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xd0(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x35afa
movq 0x20(%rsp), %rax
movq 0xd8(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq 0xd8(%rsp), %rax
movsd (%rax), %xmm0
callq 0x36100
movq 0x20(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0xd8(%rsp), %rax
movsd (%rax), %xmm0
callq 0x36130
movq 0x20(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movq 0xd8(%rsp), %rax
movsd (%rax), %xmm0
leaq 0xb8(%rsp), %rdi
callq 0x361d0
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
leaq 0xb8(%rsp), %rsi
callq 0x31c00
leaq 0xb8(%rsp), %rdi
callq 0x201d0
jmp 0x35d35
movq 0xd0(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x35b93
movq 0xd8(%rsp), %rax
movsd (%rax), %xmm0
callq 0x365b0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0xd8(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
movq 0xd8(%rsp), %rax
movsd (%rax), %xmm0
callq 0x365e0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movq 0xd8(%rsp), %rax
movsd (%rax), %xmm0
leaq 0xa0(%rsp), %rdi
callq 0x36610
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
leaq 0xa0(%rsp), %rsi
callq 0x31c00
leaq 0xa0(%rsp), %rdi
callq 0x201d0
jmp 0x35d33
movq 0xd0(%rsp), %rax
cmpl $0x2, (%rax)
jne 0x35c2c
movq 0xd8(%rsp), %rax
movsd (%rax), %xmm0
callq 0x36660
movq 0x20(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0xd8(%rsp), %rax
movsd (%rax), %xmm0
callq 0x36700
movq 0x20(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0xd8(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x18(%rax)
movq 0xd8(%rsp), %rax
movsd (%rax), %xmm0
leaq 0x88(%rsp), %rdi
callq 0x36730
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
leaq 0x88(%rsp), %rsi
callq 0x31c00
leaq 0x88(%rsp), %rdi
callq 0x201d0
jmp 0x35d31
movb $0x1, 0x2e(%rsp)
movl $0xa8, %edi
callq 0x1c1c0
movq %rax, 0x10(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1c740
movq 0x18(%rsp), %rdx
leaq 0xfd8d(%rip), %rsi # 0x459e8
leaq 0x68(%rsp), %rdi
callq 0x1c560
jmp 0x35c67
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1c740
movq 0x8(%rsp), %rdx
leaq 0xfd78(%rip), %rsi # 0x459fa
leaq 0x30(%rsp), %rdi
callq 0x1c560
jmp 0x35c8e
movq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x37900
jmp 0x35ca4
movq 0x10(%rsp), %rdi
movb $0x0, 0x2e(%rsp)
leaq 0x1c9d3(%rip), %rsi # 0x52688
leaq -0x10a3c(%rip), %rdx # 0x25280
callq 0x1c6f0
jmp 0x35d47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x35d12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x35cfe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1c230
leaq 0x2f(%rsp), %rdi
callq 0x1c420
leaq 0x68(%rsp), %rdi
callq 0x1c230
leaq 0x67(%rsp), %rdi
callq 0x1c420
testb $0x1, 0x2e(%rsp)
jne 0x35d25
jmp 0x35d2f
movq 0x10(%rsp), %rdi
callq 0x1c2a0
jmp 0x35d3d
jmp 0x35d33
jmp 0x35d35
addq $0xe8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x1c730
nopw (%rax,%rax)
| /Jvinniec[P]CppEphem/cppephem/src/CEDate.cpp |
CEDate::CEDate(std::vector<double, std::allocator<double>>) | CEDate::CEDate(std::vector<double> date)
{
init_members();
// First get the gregorian date double from the vector, then set the date
CEDate::SetDate(GregorianVect2Gregorian(date), CEDateType::GREGORIAN) ;
} | subq $0x68, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x1ca7c(%rip), %rax # 0x527f0
movq %rax, (%rdi)
addq $0x20, %rdi
movq %rdi, 0x10(%rsp)
callq 0x25440
movq 0x18(%rsp), %rdi
movl $0x0, 0x38(%rdi)
callq 0x35970
jmp 0x35d98
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x32110
jmp 0x35da9
leaq 0x28(%rsp), %rdi
callq 0x35e30
movsd %xmm0, (%rsp)
jmp 0x35dba
movq 0x18(%rsp), %rdi
movsd (%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movl $0x2, 0x24(%rsp)
leaq 0x40(%rsp), %rsi
leaq 0x24(%rsp), %rdx
callq 0x35a30
jmp 0x35de3
leaq 0x28(%rsp), %rdi
callq 0x201d0
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x35e1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x201d0
movq 0x10(%rsp), %rdi
callq 0x201d0
movq 0x50(%rsp), %rdi
callq 0x1c730
nop
| /Jvinniec[P]CppEphem/cppephem/src/CEDate.cpp |
llvm::cl::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::list<char [12], llvm::cl::MiscFlags, llvm::cl::desc, llvm::cl::cat>(char const (&) [12], llvm::cl::MiscFlags const&, llvm::cl::desc const&, llvm::cl::cat const&) | explicit list(const Mods &... Ms)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x453f88
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
movups %xmm0, 0x90(%r14)
movups %xmm0, 0x80(%r14)
movb $0x0, 0xb0(%r14)
leaq 0x14a6a14(%rip), %rax # 0x18f7100
addq $0x10, %rax
movq %rax, (%r14)
movups %xmm0, 0xb8(%r14)
andq $0x0, 0xc8(%r14)
leaq 0x14a6f0e(%rip), %rax # 0x18f7618
addq $0x10, %rax
movq %rax, 0xd0(%r14)
movups %xmm0, 0xd8(%r14)
leaq 0x3c4e(%rip), %rax # 0x454372
movq %rax, 0xf0(%r14)
leaq 0x3c42(%rip), %rax # 0x454374
movq %rax, 0xe8(%r14)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x45432a
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x456a0c
| /llvm/Support/CommandLine.h |
llvm::cl::Option::printHelpStr(llvm::StringRef, unsigned long, unsigned long) | void Option::printHelpStr(StringRef HelpStr, size_t Indent,
size_t FirstLineIndentedBy) {
assert(Indent >= FirstLineIndentedBy);
std::pair<StringRef, StringRef> Split = HelpStr.split('\n');
outs().indent(Indent - FirstLineIndentedBy)
<< ArgHelpPrefix << Split.first << "\n";
while (!Split.second.empty()) {
Split = Split.second.split('\n');
outs().indent(Indent) << Split.first << "\n";
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r15
movq %rdx, %rbx
leaq 0x48(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
movq %rsp, %r14
pushq $0xa
popq %rbp
movq %r14, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x45ac2e
callq 0x47fccb
movl %ebx, %esi
subl %r15d, %esi
movq %rax, %rdi
callq 0x47f636
leaq 0xdb9520(%rip), %rsi # 0x12140b0
pushq $0x3
popq %rdx
movq %rax, %rdi
callq 0x453a5c
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x453a5c
leaq 0xd51d87(%rip), %r14 # 0x11ac938
movq %rax, %rdi
movq %r14, %rsi
callq 0x45143e
leaq 0x10(%rsp), %r15
leaq 0x38(%rsp), %r13
leaq 0x28(%rsp), %r12
cmpq $0x0, 0x18(%rsp)
je 0x45ac1f
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x45ac2e
movups 0x28(%rsp), %xmm0
movaps %xmm0, (%rsp)
movups (%r13), %xmm0
movups %xmm0, (%r15)
callq 0x47fccb
movq %rax, %rdi
movl %ebx, %esi
callq 0x47f636
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0x453a5c
movq %rax, %rdi
movq %r14, %rsi
callq 0x45143e
jmp 0x45abcb
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Support/CommandLine.cpp |
llvm::utostr[abi:cxx11](unsigned long, bool) | inline std::string utostr(uint64_t X, bool isNeg = false) {
char Buffer[21];
char *BufPtr = std::end(Buffer);
if (X == 0) *--BufPtr = '0'; // Handle special case...
while (X) {
*--BufPtr = '0' + char(X % 10);
X /= 10;
}
if (isNeg) *--BufPtr = '-'; // Add negative sign...
return std::string(BufPtr, std::end(Buffer));
} | pushq %rbx
subq $0x20, %rsp
movl %edx, %r8d
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x15(%rsp), %rcx
movq %rcx, %rsi
testq %rax, %rax
jne 0x4658df
leaq 0x14(%rsp), %rsi
movb $0x30, (%rsi)
decq %rsi
pushq $0xa
popq %rdi
testq %rax, %rax
je 0x4658f9
xorl %edx, %edx
divq %rdi
orb $0x30, %dl
movb %dl, (%rsi)
decq %rsi
jmp 0x4658e5
testb %r8b, %r8b
je 0x465903
movb $0x2d, (%rsi)
jmp 0x465906
incq %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x465c56
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
nop
| /llvm/ADT/StringExtras.h |
llvm::PrintStatistics() | void llvm::PrintStatistics() {
#if LLVM_ENABLE_STATS
sys::SmartScopedLock<true> Reader(*StatLock);
StatisticInfo &Stats = *StatInfo;
// Statistics not enabled?
if (Stats.Stats.empty()) return;
// Get the stream to write to.
std::unique_ptr<raw_ostream> OutStream = CreateInfoOutputFile();
if (StatsAsJSON)
PrintStatisticsJSON(*OutStream);
else
PrintStatistics(*OutStream);
#else
// Check if the -stats option is set instead of checking
// !Stats.Stats.empty(). In release builds, Statistics operators
// do nothing, so stats are never Registered.
if (EnableStats) {
// Get the stream to write to.
std::unique_ptr<raw_ostream> OutStream = CreateInfoOutputFile();
(*OutStream) << "Statistics are disabled. "
<< "Build with asserts or with -DLLVM_FORCE_ENABLE_STATS\n";
}
#endif
} | cmpb $0x1, 0x1734cde(%rip) # 0x1b9a778
jne 0x465add
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x46a7c5
movq (%rbx), %rbx
leaq 0xd2ede5(%rip), %rsi # 0x119489d
movq %rbx, %rdi
callq 0x45143e
leaq 0xd2edf1(%rip), %rsi # 0x11948b8
movq %rax, %rdi
callq 0x45143e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
| /Support/Statistic.cpp |
llvm::UniqueStringSaver::save(llvm::StringRef) | StringRef UniqueStringSaver::save(StringRef S) {
auto R = Unique.insert(S);
if (R.second) // cache miss, need to actually save the string
*R.first = Strings.save(S); // safe replacement with equal value
return *R.first;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x8(%rdi), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x46702a
cmpb $0x1, 0x10(%r14)
jne 0x467016
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x466f22
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /Support/StringSaver.cpp |
llvm::SmallVectorImpl<llvm::vfs::RedirectingFileSystem::Entry*>::assignRemote(llvm::SmallVectorImpl<llvm::vfs::RedirectingFileSystem::Entry*>&&) | void assignRemote(SmallVectorImpl &&RHS) {
this->destroy_range(this->begin(), this->end());
if (!this->isSmall())
free(this->begin());
this->BeginX = RHS.BeginX;
this->Size = RHS.Size;
this->Capacity = RHS.Capacity;
RHS.resetToSmall();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x47868f
callq 0x436840
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /llvm/ADT/SmallVector.h |
llvm::yaml::Scanner::peekNext() | Token &Scanner::peekNext() {
// If the current token is a possible simple key, keep parsing until we
// can confirm.
bool NeedMore = false;
while (true) {
if (TokenQueue.empty() || NeedMore) {
if (!fetchMoreTokens()) {
TokenQueue.clear();
SimpleKeys.clear();
TokenQueue.push_back(Token());
return TokenQueue.front();
}
}
assert(!TokenQueue.empty() &&
"fetchMoreTokens lied about getting tokens!");
removeStaleSimpleKeyCandidates();
SimpleKey SK;
SK.Tok = TokenQueue.begin();
if (!is_contained(SimpleKeys, SK))
break;
else
NeedMore = true;
}
return TokenQueue.front();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0xb0(%rdi), %r14
xorl %eax, %eax
pushq $0x18
popq %r15
testb $0x1, %al
jne 0x47a528
cmpq %r14, (%r14)
jne 0x47a538
movq %rbx, %rdi
callq 0x47a64c
testb %al, %al
je 0x47a5e9
movq %rbx, %rdi
callq 0x47a9c4
movq 0xb8(%rbx), %rcx
movq 0xe0(%rbx), %rdx
movl 0xe8(%rbx), %r8d
imulq $0x18, %r8, %rax
leaq (%rdx,%rax), %rsi
shrl $0x2, %r8d
imulq $0x60, %r8, %r9
leaq (%rdx,%r9), %rdi
addq $0x30, %rdx
testq %r8, %r8
jle 0x47a592
cmpq %rcx, -0x30(%rdx)
je 0x47a5c9
cmpq %rcx, -0x18(%rdx)
je 0x47a5cf
cmpq %rcx, (%rdx)
je 0x47a5d9
cmpq %rcx, 0x18(%rdx)
je 0x47a5d5
decq %r8
addq $0x60, %rdx
jmp 0x47a56d
subq %r9, %rax
cqto
idivq %r15
cmpq $0x1, %rax
je 0x47a5c2
cmpq $0x2, %rax
je 0x47a5b9
cmpq $0x3, %rax
jne 0x47a63b
cmpq %rcx, (%rdi)
je 0x47a5dc
addq $0x18, %rdi
cmpq %rcx, (%rdi)
je 0x47a5dc
addq $0x18, %rdi
cmpq %rcx, (%rdi)
je 0x47a5dc
jmp 0x47a63b
addq $-0x30, %rdx
jmp 0x47a5d9
addq $-0x18, %rdx
jmp 0x47a5d9
addq $0x18, %rdx
movq %rdx, %rdi
movb $0x1, %al
cmpq %rsi, %rdi
jne 0x47a51f
jmp 0x47a63b
leaq 0x50(%rbx), %r14
movq %r14, %rdi
callq 0x47a9ac
andl $0x0, 0xe8(%rbx)
leaq 0x18(%rsp), %r15
leaq 0x28(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rax)
andq $0x0, 0x8(%rax)
movaps %xmm0, -0x8(%rax)
movaps %xmm0, -0x28(%rax)
movq %rax, -0x10(%rax)
movb $0x0, (%rax)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x47a9b8
movq %r15, %rdi
callq 0x436d30
movq 0xb8(%rbx), %rcx
addq $0x10, %rcx
movq %rcx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /Support/YAMLParser.cpp |
llvm::yaml::Scanner::setError(llvm::Twine const&, char const*) | void setError(const Twine &Message, StringRef::iterator Position) {
if (Position >= End)
Position = End - 1;
// propagate the error if possible
if (EC)
*EC = make_error_code(std::errc::invalid_argument);
// Don't print out more errors after the first one we encounter. The rest
// are just the result of the first, and have no meaning.
if (!Failed)
printError(SMLoc::getFromPointer(Position), SourceMgr::DK_Error, Message);
Failed = true;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x150(%rdi), %r12
leaq -0x1(%rax), %r15
cmpq %rdx, %rax
cmovaq %rdx, %r15
testq %r12, %r12
je 0x47ada5
callq 0x436570
movl $0x16, (%r12)
movq %rax, 0x8(%r12)
cmpb $0x0, 0x4b(%rbx)
jne 0x47adc1
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x47c638
movb $0x1, 0x4b(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /Support/YAMLParser.cpp |
llvm::yaml::Scanner::scanFlowScalar(bool) | bool Scanner::scanFlowScalar(bool IsDoubleQuoted) {
StringRef::iterator Start = Current;
unsigned ColStart = Column;
if (IsDoubleQuoted) {
do {
++Current;
while (Current != End && *Current != '"')
++Current;
// Repeat until the previous character was not a '\' or was an escaped
// backslash.
} while ( Current != End
&& *(Current - 1) == '\\'
&& wasEscaped(Start + 1, Current));
} else {
skip(1);
while (Current != End) {
// Skip a ' followed by another '.
if (Current + 1 < End && *Current == '\'' && *(Current + 1) == '\'') {
skip(2);
continue;
} else if (*Current == '\'')
break;
StringRef::iterator i = skip_nb_char(Current);
if (i == Current) {
i = skip_b_break(Current);
if (i == Current)
break;
Current = i;
Column = 0;
++Line;
} else {
if (i == End)
break;
Current = i;
++Column;
}
}
}
if (Current == End) {
setError("Expected quote at end of scalar", Current);
return false;
}
skip(1); // Skip ending quote.
Token T;
T.Kind = Token::TK_Scalar;
T.Range = StringRef(Start, Current - Start);
TokenQueue.push_back(T);
saveSimpleKeyCandidate(--TokenQueue.end(), ColStart, false);
IsSimpleKeyAllowed = false;
IsAdjacentValueAllowedInFlow = true;
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %r13
movl 0x3c(%rdi), %r14d
testl %esi, %esi
je 0x47b97e
movq 0x30(%rbx), %rbp
leaq 0x1(%r13), %r12
movq %r12, %r15
movq %r15, 0x28(%rbx)
cmpq %rbp, %r15
je 0x47ba21
cmpb $0x22, (%r15)
jne 0x47b979
cmpb $0x5c, -0x1(%r15)
jne 0x47ba21
movq %r12, %rdi
movq %r15, %rsi
callq 0x47babc
testb %al, %al
je 0x47ba21
incq %r15
jmp 0x47b948
leaq 0x1(%r13), %r12
movq %r12, 0x28(%rbx)
leal 0x1(%r14), %ecx
movl %ecx, 0x3c(%rbx)
movq 0x30(%rbx), %rbp
cmpq %rbp, %r12
je 0x47ba8d
leaq 0x1(%r12), %rax
movb (%r12), %dl
cmpq %rbp, %rax
jae 0x47b9af
cmpb $0x27, %dl
je 0x47b9fe
jmp 0x47b9b4
cmpb $0x27, %dl
je 0x47ba13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x47aad0
movq %rax, %r12
movq 0x28(%rbx), %r15
cmpq %r15, %rax
jne 0x47b9ed
movq %rbx, %rdi
movq %r15, %rsi
callq 0x47ab64
cmpq %r12, %rax
je 0x47ba1d
movq %rax, 0x28(%rbx)
andl $0x0, 0x3c(%rbx)
incl 0x40(%rbx)
xorl %ecx, %ecx
movq %rax, %r12
jmp 0x47b98d
cmpq 0x30(%rbx), %r12
je 0x47ba18
movq %r12, 0x28(%rbx)
movl 0x3c(%rbx), %ecx
incl %ecx
jmp 0x47b98a
cmpb $0x27, (%rax)
jne 0x47ba13
addq $0x2, %r12
movq %r12, 0x28(%rbx)
addl $0x2, %ecx
jmp 0x47b98a
movq %r12, %r15
jmp 0x47ba21
movq %r12, %rbp
jmp 0x47ba21
movq 0x30(%rbx), %rbp
cmpq %rbp, %r15
je 0x47ba8a
incq %r15
movq %r15, 0x28(%rbx)
incl 0x3c(%rbx)
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x18(%rsp), %r12
movb $0x0, (%rax)
movl $0x12, -0x28(%rax)
subq %r13, %r15
movq %r13, -0x20(%rax)
movq %r15, -0x18(%rax)
leaq 0x50(%rbx), %rdi
movq %rsp, %rsi
callq 0x47b03e
movq 0xb0(%rbx), %rsi
movq %rbx, %rdi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x47ae98
movw $0x100, 0x49(%rbx) # imm = 0x100
movq %r12, %rdi
callq 0x436d30
movb $0x1, %al
jmp 0x47baad
movq %r15, %r12
leaq 0xd19c85(%rip), %rax # 0x1195719
movq %rsp, %rsi
movq %rax, (%rsi)
movw $0x103, 0x20(%rsi) # imm = 0x103
movq %rbx, %rdi
movq %r12, %rdx
callq 0x47ad6a
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Support/YAMLParser.cpp |
llvm::detail::IEEEFloat::changeSign() | void IEEEFloat::changeSign() {
// With NaN-as-negative-zero, neither NaN or negative zero can change
// their signs.
if (semantics->nanEncoding == fltNanEncoding::NegativeZero &&
(isZero() || isNaN()))
return;
/* Look mummy, this one's easy. */
sign = !sign;
} | movq (%rdi), %rax
cmpl $0x2, 0x14(%rax)
movzbl 0x14(%rdi), %eax
jne 0x48ab41
movl %eax, %ecx
orl $0x2, %ecx
andl $0x7, %ecx
cmpl $0x3, %ecx
jne 0x48ab41
retq
xorb $0x8, %al
movb %al, 0x14(%rdi)
retq
nop
| /Support/APFloat.cpp |
llvm::lostFractionThroughTruncation(unsigned long const*, unsigned int, unsigned int) | static lostFraction
lostFractionThroughTruncation(const APFloatBase::integerPart *parts,
unsigned int partCount,
unsigned int bits)
{
unsigned int lsb;
lsb = APInt::tcLSB(parts, partCount);
/* Note this is guaranteed true if bits == 0, or LSB == UINT_MAX. */
if (bits <= lsb)
return lfExactlyZero;
if (bits == lsb + 1)
return lfExactlyHalf;
if (bits <= partCount * APFloatBase::integerPartWidth &&
APInt::tcExtractBit(parts, bits - 1))
return lfMoreThanHalf;
return lfLessThanHalf;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x49546e
movl %eax, %ecx
xorl %eax, %eax
cmpl %ebx, %ecx
jae 0x48b1ee
incl %ecx
cmpl %ebx, %ecx
jne 0x48b1d0
pushq $0x2
jmp 0x48b1ed
shll $0x6, %ebp
cmpl %ebx, %ebp
jb 0x48b1eb
decl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x49543a
testl %eax, %eax
je 0x48b1eb
pushq $0x3
jmp 0x48b1ed
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
| /Support/APFloat.cpp |
llvm::detail::IEEEFloat::convertFloat8E5M2APFloatToAPInt() const | APInt IEEEFloat::convertFloat8E5M2APFloatToAPInt() const {
assert(partCount() == 1);
return convertIEEEFloatToAPInt<semFloat8E5M2>();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x14(%rsi), %r15d
testb $0x6, %r15b
sete %cl
movl %r15d, %eax
andl $0x7, %eax
cmpl $0x3, %eax
sete %dl
orb %cl, %dl
jne 0x48cd17
movslq 0x10(%r14), %rax
addq $0xf, %rax
movq (%r14), %rcx
movl 0x8(%rcx), %ecx
addl $-0x40, %ecx
cmpl $-0x80, %ecx
jae 0x48cd27
movq 0x8(%r14), %r14
jmp 0x48cd2b
cmpl $0x3, %eax
je 0x48cd3d
testl %eax, %eax
jne 0x48cd43
pushq $0x1f
popq %rax
xorl %ecx, %ecx
jmp 0x48cd6f
addq $0x8, %r14
movq (%r14), %rcx
cmpl $0x1, %eax
jne 0x48cd6f
movl %ecx, %eax
shrl $0x2, %eax
andl $0x1, %eax
jmp 0x48cd6f
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x48cd6f
leaq 0xd099ce(%rip), %rdi # 0x1196718
callq 0x48f730
addl $0xf, %eax
movq (%r14), %rcx
movl 0x8(%rcx), %ecx
addl $-0x40, %ecx
cmpl $-0x80, %ecx
jae 0x48cd66
movq 0x8(%r14), %r14
jmp 0x48cd6a
addq $0x8, %r14
cltq
movq (%r14), %rcx
andl $0x3, %ecx
andl $0x8, %r15d
shll $0x4, %r15d
orq %rcx, %r15
andl $0x1f, %eax
leaq (%r15,%rax,4), %rax
movl $0x8, 0x8(%rbx)
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x468540
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| /Support/APFloat.cpp |
llvm::APInt::tcAddPart(unsigned long*, unsigned long, unsigned int) | APInt::WordType APInt::tcAddPart(WordType *dst, WordType src,
unsigned parts) {
for (unsigned i = 0; i < parts; ++i) {
dst[i] += src;
if (dst[i] >= src)
return 0; // No need to carry so exit early.
src = 1; // Carry one to next digit.
}
return 1;
} | movl %edx, %ecx
xorl %r8d, %r8d
pushq $0x1
popq %rax
movq %r8, %rdx
cmpq %r8, %rcx
je 0x49220d
leaq 0x1(%rdx), %r8
addq %rsi, (%rdi,%rdx,8)
movq %rax, %rsi
jb 0x4921f8
xorl %eax, %eax
cmpq %rcx, %rdx
setae %al
retq
| /Support/APInt.cpp |
llvm::APInt::extractBitsAsZExtValue(unsigned int, unsigned int) const | bool isSingleWord() const { return BitWidth <= APINT_BITS_PER_WORD; } | cmpl $0x40, 0x8(%rdi)
ja 0x492ab4
movq (%rdi), %rdi
movl %edx, %ecx
shrq %cl, %rdi
jmp 0x492ae5
movl %edx, %ecx
andl $0x3f, %ecx
movl %edx, %r8d
shrl $0x6, %r8d
leal (%rsi,%rdx), %eax
decl %eax
shrl $0x6, %eax
movq (%rdi), %rdx
movq (%rdx,%r8,8), %rdi
shrq %cl, %rdi
cmpl %eax, %r8d
je 0x492ae5
movl %eax, %eax
movq (%rdx,%rax,8), %rax
negb %cl
shlq %cl, %rax
orq %rax, %rdi
movl %esi, %ecx
negb %cl
pushq $-0x1
popq %rdx
shrq %cl, %rdx
xorl %eax, %eax
testl %esi, %esi
cmovneq %rdx, %rax
andq %rdi, %rax
retq
nop
| /llvm/ADT/APInt.h |
llvm::APInt::rotl(unsigned int) const | APInt APInt::rotl(unsigned rotateAmt) const {
if (LLVM_UNLIKELY(BitWidth == 0))
return *this;
rotateAmt %= BitWidth;
if (rotateAmt == 0)
return *this;
return shl(rotateAmt) | lshr(BitWidth - rotateAmt);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %ecx
testl %ecx, %ecx
je 0x492c27
movl %edx, %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x492c27
movl %edx, %ebp
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4936f8
movl 0x8(%r14), %edx
subl %ebp, %edx
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x492c58
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4936c9
movq %r12, %rdi
callq 0x468360
movq %r15, %rdi
callq 0x468360
jmp 0x492c32
movq %rbx, %rdi
movq %r14, %rsi
callq 0x48b344
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /Support/APInt.cpp |
llvm::StringMap<std::unique_ptr<clang::driver::ToolChain, std::default_delete<clang::driver::ToolChain>>, llvm::MallocAllocator>::~StringMap() | ~StringMap() {
// Delete all the elements in the map, but don't reset the elements
// to default values. This is a copy of clear(), but avoids unnecessary
// work not required in the destructor.
if (!empty()) {
for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
StringMapEntryBase *Bucket = TheTable[I];
if (Bucket && Bucket != getTombstoneVal()) {
static_cast<MapEntryTy *>(Bucket)->Destroy(getAllocator());
}
}
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
je 0x49ffd3
movl 0x8(%rbx), %r14d
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x49ffd3
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
cmpq $-0x8, %rdi
je 0x49ffce
testq %rdi, %rdi
je 0x49ffce
movq %rbx, %rsi
callq 0x4a007c
incq %r15
jmp 0x49ffaf
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x454bfc
| /llvm/ADT/StringMap.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, std::pair<unsigned int, unsigned int>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, std::pair<unsigned int, unsigned int>>>, unsigned int, std::pair<unsigned int, unsigned int>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, std::pair<unsigned int, unsigned int>>>::getMinBucketToReserveForEntries(unsigned int) | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + 1);
} | testl %esi, %esi
je 0x4a78ce
pushq %rax
shll $0x2, %esi
pushq $0x3
popq %rcx
movl %esi, %eax
xorl %edx, %edx
divl %ecx
leal 0x1(%rax), %edi
callq 0x45e847
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::Error clang::doc::ClangDocBitcodeReader::readBlock<clang::doc::BaseRecordInfo*>(unsigned int, clang::doc::BaseRecordInfo*) | llvm::Error ClangDocBitcodeReader::readBlock(unsigned ID, T I) {
if (llvm::Error Err = Stream.EnterSubBlock(ID))
return Err;
while (true) {
unsigned BlockOrCode = 0;
Cursor Res = skipUntilRecordOrBlock(BlockOrCode);
switch (Res) {
case Cursor::BadBlock:
return llvm::createStringError(llvm::inconvertibleErrorCode(),
"bad block found");
case Cursor::BlockEnd:
return llvm::Error::success();
case Cursor::BlockBegin:
if (llvm::Error Err = readSubBlock(BlockOrCode, I)) {
if (llvm::Error Skipped = Stream.SkipBlock())
return joinErrors(std::move(Err), std::move(Skipped));
return Err;
}
continue;
case Cursor::Record:
break;
}
if (auto Err = readRecord(BlockOrCode, I))
return Err;
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rsi
xorl %ecx, %ecx
callq 0x115be9a
cmpq $0x0, (%rbx)
je 0x4b141d
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xc(%rsp), %r12
leaq 0x10(%rsp), %r13
andl $0x0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4ab378
cmpl $0x4, %eax
je 0x4b1468
cmpl $0x3, %eax
je 0x4b152c
cmpl $0x1, %eax
je 0x4b1511
movl 0xc(%rsp), %edx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x4b4c5e
cmpq $0x0, (%rbx)
je 0x4b1427
jmp 0x4b140c
movl 0xc(%rsp), %edx
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x4b4786
cmpq $0x0, 0x10(%rsp)
je 0x4b1427
movq (%r15), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x4abe46
movq (%r14), %rax
testq %rax, %rax
je 0x4b1535
movq 0x10(%rsp), %rcx
leaq 0x20(%rsp), %rsi
movq %rcx, (%rsi)
andq $0x0, 0x10(%rsp)
leaq 0x28(%rsp), %r14
movq %rax, (%r14)
andq $0x0, 0x18(%rsp)
movq %rbx, %rdi
movq %r14, %rdx
callq 0x480148
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4b14d8
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x4b14e8
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4b14f8
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4b140c
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4b140c
callq 0x462ecc
leaq 0xce9633(%rip), %rcx # 0x119ab50
movq %rbx, %rdi
movl %eax, %esi
callq 0x45ffe8
jmp 0x4b140c
andq $0x0, (%rbx)
jmp 0x4b140c
movq 0x10(%rsp), %rax
movq %rax, (%rbx)
jmp 0x4b140c
| /BitcodeReader.cpp |
llvm::Error clang::doc::ClangDocBitcodeReader::readRecord<clang::doc::MemberTypeInfo*>(unsigned int, clang::doc::MemberTypeInfo*) | llvm::Error ClangDocBitcodeReader::readRecord(unsigned ID, T I) {
Record R;
llvm::StringRef Blob;
llvm::Expected<unsigned> MaybeRecID = Stream.readRecord(ID, R, &Blob);
if (!MaybeRecID)
return MaybeRecID.takeError();
return parseRecord(R, MaybeRecID.get(), Blob, I);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x2030, %rsp # imm = 0x2030
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x40000000000, %rcx # imm = 0x40000000000
movq %rcx, -0x8(%rax)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r8
movaps %xmm0, (%r8)
movq (%rsi), %rsi
movq %rsp, %r15
leaq 0x20(%rsp), %rcx
movq %r15, %rdi
callq 0x115c83c
testb $0x1, 0x8(%r15)
je 0x4b38d3
movq (%rsp), %rax
andq $0x0, (%rsp)
movq %rax, (%rbx)
jmp 0x4b38f0
movl (%rsp), %edx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %r9
callq 0x4aa9e6
movq %rsp, %rdi
callq 0x484d68
leaq 0x20(%rsp), %rdi
callq 0x491d0a
movq %rbx, %rax
addq $0x2030, %rsp # imm = 0x2030
popq %rbx
popq %r14
popq %r15
retq
| /BitcodeReader.cpp |
llvm::Error clang::doc::ClangDocBitcodeReader::readSubBlock<clang::doc::EnumValueInfo*>(unsigned int, clang::doc::EnumValueInfo*) | llvm::Error ClangDocBitcodeReader::readSubBlock(unsigned ID, T I) {
switch (ID) {
// Blocks can only have certain types of sub blocks.
case BI_COMMENT_BLOCK_ID: {
auto Comment = getCommentInfo(I);
if (!Comment)
return Comment.takeError();
if (auto Err = readBlock(ID, Comment.get()))
return Err;
return llvm::Error::success();
}
case BI_TYPE_BLOCK_ID: {
TypeInfo TI;
if (auto Err = readBlock(ID, &TI))
return Err;
if (auto Err = addTypeInfo(I, std::move(TI)))
return Err;
return llvm::Error::success();
}
case BI_FIELD_TYPE_BLOCK_ID: {
FieldTypeInfo TI;
if (auto Err = readBlock(ID, &TI))
return Err;
if (auto Err = addTypeInfo(I, std::move(TI)))
return Err;
return llvm::Error::success();
}
case BI_MEMBER_TYPE_BLOCK_ID: {
MemberTypeInfo TI;
if (auto Err = readBlock(ID, &TI))
return Err;
if (auto Err = addTypeInfo(I, std::move(TI)))
return Err;
return llvm::Error::success();
}
case BI_REFERENCE_BLOCK_ID: {
Reference R;
if (auto Err = readBlock(ID, &R))
return Err;
if (auto Err = addReference(I, std::move(R), CurrentReferenceField))
return Err;
return llvm::Error::success();
}
case BI_FUNCTION_BLOCK_ID: {
FunctionInfo F;
if (auto Err = readBlock(ID, &F))
return Err;
addChild(I, std::move(F));
return llvm::Error::success();
}
case BI_BASE_RECORD_BLOCK_ID: {
BaseRecordInfo BR;
if (auto Err = readBlock(ID, &BR))
return Err;
addChild(I, std::move(BR));
return llvm::Error::success();
}
case BI_ENUM_BLOCK_ID: {
EnumInfo E;
if (auto Err = readBlock(ID, &E))
return Err;
addChild(I, std::move(E));
return llvm::Error::success();
}
case BI_ENUM_VALUE_BLOCK_ID: {
EnumValueInfo EV;
if (auto Err = readBlock(ID, &EV))
return Err;
addChild(I, std::move(EV));
return llvm::Error::success();
}
case BI_TEMPLATE_BLOCK_ID: {
TemplateInfo TI;
if (auto Err = readBlock(ID, &TI))
return Err;
addTemplate(I, std::move(TI));
return llvm::Error::success();
}
case BI_TEMPLATE_SPECIALIZATION_BLOCK_ID: {
TemplateSpecializationInfo TSI;
if (auto Err = readBlock(ID, &TSI))
return Err;
addTemplateSpecialization(I, std::move(TSI));
return llvm::Error::success();
}
case BI_TEMPLATE_PARAM_BLOCK_ID: {
TemplateParamInfo TPI;
if (auto Err = readBlock(ID, &TPI))
return Err;
addTemplateParam(I, std::move(TPI));
return llvm::Error::success();
}
case BI_TYPEDEF_BLOCK_ID: {
TypedefInfo TI;
if (auto Err = readBlock(ID, &TI))
return Err;
addChild(I, std::move(TI));
return llvm::Error::success();
}
default:
return llvm::createStringError(llvm::inconvertibleErrorCode(),
"invalid subblock type");
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1628, %rsp # imm = 0x1628
movq %rdi, %rbx
addl $-0xa, %edx
cmpl $0xd, %edx
ja 0x4b572a
movq %rcx, %r14
movq %rsi, %r15
leaq 0xce514a(%rip), %rax # 0x119a628
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x90(%rsp), %r12
movq %r12, %rdi
callq 0x4b1560
pushq $0xa
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x4b1606
cmpq $0x0, (%rbx)
jne 0x4b5522
leaq 0x90(%rsp), %rsi
movq %r14, %rdi
callq 0x4b5b00
andq $0x0, (%rbx)
leaq 0x90(%rsp), %rdi
callq 0x4af0c0
jmp 0x4b596b
leaq 0xa8(%rsp), %r12
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
andq $0x0, 0x10(%r12)
pushq $0x15
popq %rdx
leaq 0x90(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b1a9c
cmpq $0x0, (%rbx)
jne 0x4b557a
leaq 0x90(%rsp), %rsi
movq %r14, %rdi
callq 0x4b5b57
andq $0x0, (%rbx)
movq %r12, %rdi
callq 0x4aedc8
jmp 0x4b596b
leaq 0x90(%rsp), %r12
movq %r12, %rdi
callq 0x4b0e1e
pushq $0xe
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x4b0e42
cmpq $0x0, (%rbx)
jne 0x4b55c1
leaq 0x90(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b5a88
leaq 0x90(%rsp), %rdi
callq 0x4adce4
jmp 0x4b596b
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andl $0x0, 0x30(%rsp)
movups %xmm0, (%rsp)
andl $0x0, 0x10(%rsp)
leaq 0x90(%rsp), %r12
movq %r12, %rdi
callq 0x4b1d90
pushq $0x17
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x4b1e10
cmpq $0x0, (%rbx)
jne 0x4b5624
leaq 0x90(%rsp), %rsi
movq %r14, %rdi
callq 0x4b5b91
andq $0x0, (%rbx)
leaq 0x90(%rsp), %rdi
callq 0x4af6c6
jmp 0x4b596b
leaq 0x90(%rsp), %r12
movq %r12, %rdi
callq 0x4d77e2
pushq $0x10
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x4b13e6
cmpq $0x0, (%rbx)
jne 0x4b5671
leaq 0x90(%rsp), %rsi
movq %r14, %rdi
callq 0x4b5ae3
andq $0x0, (%rbx)
leaq 0x90(%rsp), %rdi
callq 0x4afa6c
jmp 0x4b596b
leaq 0xa8(%rsp), %rax
movq %rax, -0x18(%rax)
andq $0x0, -0x10(%rax)
movq $0x10, -0x8(%rax)
pushq $0x16
popq %rdx
leaq 0x90(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b1c16
cmpq $0x0, (%rbx)
jne 0x4b56cc
leaq 0x90(%rsp), %rsi
movq %r14, %rdi
callq 0x4b5b74
andq $0x0, (%rbx)
leaq 0x90(%rsp), %rdi
callq 0x4521fe
jmp 0x4b596b
leaq 0x90(%rsp), %r12
movq %r12, %rdi
callq 0x4b0c5a
pushq $0xd
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x4b0ca2
cmpq $0x0, (%rbx)
jne 0x4b5718
leaq 0x90(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b5a69
leaq 0x90(%rsp), %rdi
callq 0x4adf10
jmp 0x4b596b
callq 0x462ecc
leaq 0xce542a(%rip), %rcx # 0x119ab60
movq %rbx, %rdi
movl %eax, %esi
callq 0x45ffe8
jmp 0x4b596b
leaq 0x90(%rsp), %r12
movq %r12, %rdi
callq 0x4b0ab0
pushq $0xc
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x4b0ade
cmpq $0x0, (%rbx)
jne 0x4b5939
leaq 0x90(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b5a4a
jmp 0x4b5939
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movups %xmm0, (%rsp)
leaq 0xd6d3a6(%rip), %rcx # 0x1222b44
leaq 0x90(%rsp), %r12
pushq $0x1
popq %r8
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4b1762
pushq $0xb
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x4b17a8
cmpq $0x0, (%rbx)
jne 0x4b57e1
leaq 0x90(%rsp), %rsi
movq %r14, %rdi
callq 0x4b5b1d
andq $0x0, (%rbx)
leaq 0x90(%rsp), %rdi
callq 0x4af360
jmp 0x4b596b
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
andl $0x0, 0x50(%rsp)
movups %xmm0, (%rsp)
andl $0x0, 0x10(%rsp)
leaq 0x90(%rsp), %r12
movq %r12, %rdi
callq 0x4b118c
pushq $0x11
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x4b128a
cmpq $0x0, (%rbx)
jne 0x4b5844
leaq 0x90(%rsp), %rsi
movq %r14, %rdi
callq 0x4b5ac6
andq $0x0, (%rbx)
leaq 0x90(%rsp), %rdi
callq 0x4ae444
jmp 0x4b596b
leaq 0x90(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x4b5a15
testb $0x1, 0x8(%r12)
je 0x4b5948
movq 0x90(%rsp), %rax
andq $0x0, 0x90(%rsp)
movq %rax, (%rbx)
jmp 0x4b595e
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
movb $0x0, 0x48(%rcx)
pushq $0x14
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b1922
cmpq $0x0, (%rbx)
jne 0x4b58cd
leaq 0x90(%rsp), %rsi
movq %r14, %rdi
callq 0x4b5b3a
andq $0x0, (%rbx)
leaq 0x90(%rsp), %rdi
callq 0x4aedb2
jmp 0x4b596b
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
andl $0x0, 0x70(%rsp)
movups %xmm0, (%rsp)
andl $0x0, 0x10(%rsp)
leaq 0x90(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4b0fbe
pushq $0x13
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x4b1030
cmpq $0x0, (%rbx)
jne 0x4b5939
movl 0x28(%r15), %ecx
leaq 0x90(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b5aa7
leaq 0x90(%rsp), %rdi
callq 0x453e58
jmp 0x4b596b
movq 0x90(%rsp), %rcx
pushq $0x12
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b0948
leaq 0x90(%rsp), %rdi
callq 0x4b0aa4
movq %rbx, %rax
addq $0x1628, %rsp # imm = 0x1628
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /BitcodeReader.cpp |
clang::doc::genHTML(clang::doc::EnumInfo const&, clang::doc::ClangDocContext const&) | static std::vector<std::unique_ptr<TagNode>>
genHTML(const EnumInfo &I, const ClangDocContext &CDCtx) {
std::vector<std::unique_ptr<TagNode>> Out;
std::string EnumType = I.Scoped ? "enum class " : "enum ";
Out.emplace_back(
std::make_unique<TagNode>(HTMLTag::TAG_H3, EnumType + I.Name));
Out.back()->Attributes.emplace_back("id",
llvm::toHex(llvm::toStringRef(I.USR)));
std::unique_ptr<TagNode> Node = genEnumMembersBlock(I.Members);
if (Node)
Out.emplace_back(std::move(Node));
if (I.DefLoc) {
if (!CDCtx.RepositoryUrl)
Out.emplace_back(writeFileDefinition(*I.DefLoc));
else
Out.emplace_back(writeFileDefinition(
*I.DefLoc, StringRef{*CDCtx.RepositoryUrl}));
}
std::string Description;
if (!I.Description.empty())
Out.emplace_back(genHTML(I.Description));
return Out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0xce18c2(%rip), %rax # 0x119c0aa
leaq 0xdb815a(%rip), %rsi # 0x1272949
cmpb $0x0, 0x618(%r14)
cmovneq %rax, %rsi
leaq 0xe8(%rsp), %r15
leaq 0x38(%rsp), %rdx
movq %r15, %rdi
callq 0x450adc
leaq 0x34(%rsp), %r12
movl $0x5, (%r12)
leaq 0x90(%rsp), %rsi
movw $0x104, 0x20(%rsi) # imm = 0x104
movq %r15, (%rsi)
leaq 0xc0(%rsp), %rdx
movw $0x105, 0x20(%rdx) # imm = 0x105
movq 0x20(%r14), %rax
movq %rax, (%rdx)
movq 0x28(%r14), %rax
movq %rax, 0x8(%rdx)
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x4539cc
leaq 0xb8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4bddbb
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4bb870
movq (%r13), %rdi
testq %rdi, %rdi
je 0x4ba888
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rax
movq -0x8(%rax), %r15
addq $0x28, %r15
leaq 0x8(%r14), %rsi
leaq 0x38(%rsp), %r12
pushq $0x14
popq %rdx
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x4bd85f
leaq 0xcf88e8(%rip), %rsi # 0x11b3199
movq %r15, %rdi
movq %r12, %rdx
callq 0x4bc9d8
movq %r12, %rdi
callq 0x436d30
cmpl $0x0, 0x738(%r14)
je 0x4ba989
movq %rbp, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
leaq 0x38(%rsp), %r12
movl $0x10, (%r12)
leaq 0x90(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x4bc6aa
movq 0x730(%r14), %r13
movl 0x738(%r14), %eax
movq (%r15), %rcx
movq %rcx, 0x18(%rsp)
leaq 0x10(%rcx), %rbp
imulq $0x78, %rax, %rbx
leaq 0xc0(%rsp), %r15
testq %rbx, %rbx
je 0x4ba965
movl $0x7, 0xc0(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4be01e
movq %rbp, %rdi
movq %r12, %rsi
callq 0x4bcc1a
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x4ba95b
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x78, %r13
addq $-0x78, %rbx
jmp 0x4ba922
cmpq $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rbx
movq 0x20(%rsp), %rbp
je 0x4ba992
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x4bb870
jmp 0x4ba992
andq $0x0, 0x90(%rsp)
cmpb $0x1, 0x570(%r14)
jne 0x4baa0f
leaq 0x528(%r14), %rsi
cmpb $0x0, 0x90(%rbp)
je 0x4ba9cb
movups 0x70(%rbp), %xmm0
movups %xmm0, 0x60(%rsp)
movb $0x1, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x60(%rsp), %xmm0
jmp 0x4ba9e5
movb $0x0, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x4bd8d2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4bb870
movq (%r15), %rdi
testq %rdi, %rdi
je 0x4baa0f
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x478(%r14), %rax
cmpq 0x480(%r14), %rax
je 0x4baa63
addq $0x478, %r14 # imm = 0x478
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4bb9dc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4bb870
movq (%r15), %rdi
testq %rdi, %rdi
je 0x4baa63
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rdi
callq 0x436d30
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x4baa80
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xe8(%rsp), %rdi
callq 0x436d30
movq %rbx, %rax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /HTMLGenerator.cpp |
llvm::trailing_objects_internal::TrailingObjectsImpl<8, clang::FunctionProtoType, llvm::TrailingObjects<clang::FunctionProtoType, clang::QualType, clang::SourceLocation, clang::FunctionType::FunctionTypeExtraBitfields, clang::FunctionType::FunctionTypeArmAttributes, clang::FunctionType::ExceptionType, clang::Expr*, clang::FunctionDecl*, clang::FunctionType::ExtParameterInfo, clang::Qualifiers, clang::FunctionEffect, clang::EffectConditionExpr>, clang::FunctionType::FunctionTypeExtraBitfields, clang::FunctionType::FunctionTypeArmAttributes, clang::FunctionType::ExceptionType, clang::Expr*, clang::FunctionDecl*, clang::FunctionType::ExtParameterInfo, clang::Qualifiers, clang::FunctionEffect, clang::EffectConditionExpr>::getTrailingObjectsImpl(clang::FunctionProtoType const*, llvm::trailing_objects_internal::TrailingObjectsBase::OverloadToken<clang::FunctionType::FunctionTypeArmAttributes>) | unsigned getNumParams() const { return FunctionTypeBits.NumParams; } | movq 0x10(%rdi), %rax
movq %rax, %rcx
shrq $0x26, %rcx
movzwl %cx, %ecx
leaq (%rdi,%rcx,8), %rcx
movq %rax, %rdx
shrq $0x3c, %rdx
andl $0x1, %edx
leaq (%rcx,%rdx,4), %rcx
addq $0x37, %rcx
andq $-0x8, %rcx
shrq $0x3b, %rax
andl $0x1, %eax
leaq (%rcx,%rax,8), %rax
retq
| /clang/AST/Type.h |
clang::FunctionProtoType::getNumExceptions() const | ExceptionSpecificationType getExceptionSpecType() const {
return static_cast<ExceptionSpecificationType>(
FunctionTypeBits.ExceptionSpecType);
} | movq 0x10(%rdi), %rcx
movabsq $0x3c0000000000000, %rdx # imm = 0x3C0000000000000
andq %rcx, %rdx
xorl %eax, %eax
movabsq $0x80000000000000, %rsi # imm = 0x80000000000000
cmpq %rsi, %rdx
jne 0x4c5c77
movq %rcx, %rax
shrq $0x26, %rax
movzwl %ax, %eax
leaq (%rdi,%rax,8), %rax
shrq $0x3c, %rcx
andl $0x1, %ecx
leaq (%rax,%rcx,4), %rax
addq $0x37, %rax
andq $-0x8, %rax
movzwl (%rax), %eax
andl $0x3ff, %eax # imm = 0x3FF
retq
| /clang/AST/Type.h |
clang::doc::EnumInfo::merge(clang::doc::EnumInfo&&) | void EnumInfo::merge(EnumInfo &&Other) {
assert(mergeable(Other));
if (!Scoped)
Scoped = Other.Scoped;
if (Members.empty())
Members = std::move(Other.Members);
SymbolInfo::merge(std::move(Other));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x618(%rdi)
jne 0x4d7634
movb 0x618(%rbx), %al
movb %al, 0x618(%r14)
cmpl $0x0, 0x738(%r14)
jne 0x4d764f
movl $0x730, %esi # imm = 0x730
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0x4af136
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4d6ef8
nop
| /Representation.cpp |
clang::doc::Location& llvm::SmallVectorTemplateBase<clang::doc::Location, false>::growAndEmplaceBack<int&, llvm::StringRef&, bool&>(int&, llvm::StringRef&, bool&) | T &growAndEmplaceBack(ArgTypes &&... Args) {
// Grow manually in case one of Args is an internal reference.
size_t NewCapacity;
T *NewElts = mallocForGrow(0, NewCapacity);
::new ((void *)(NewElts + this->size())) T(std::forward<ArgTypes>(Args)...);
moveElementsForGrow(NewElts);
takeAllocationForGrow(NewElts, NewCapacity);
this->set_size(this->size() + 1);
return this->back();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %r13
xorl %esi, %esi
movq %r13, %rdx
callq 0x4ad1c4
movq %rax, %rbp
movl 0x8(%rbx), %eax
imulq $0x48, %rax, %rdi
addq %rbp, %rdi
movl (%r12), %esi
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movzbl (%r14), %r8d
callq 0x4acf5a
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x4ad1d6
movq (%r13), %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x4ad202
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movq (%rbx), %rcx
imulq $0x48, %rax, %rax
addq %rcx, %rax
addq $-0x48, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /llvm/ADT/SmallVector.h |
clang::doc::FieldTypeInfo& llvm::SmallVectorImpl<clang::doc::FieldTypeInfo>::emplace_back<clang::doc::TypeInfo, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(clang::doc::TypeInfo&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | reference emplace_back(ArgTypes &&... Args) {
if (LLVM_UNLIKELY(this->size() >= this->capacity()))
return this->growAndEmplaceBack(std::forward<ArgTypes>(Args)...);
::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
this->set_size(this->size() + 1);
return this->back();
} | pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jae 0x4deeba
imulq $0x158, %rax, %rdi # imm = 0x158
addq (%rbx), %rdi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq %rax, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4def52
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movq (%rbx), %rcx
imulq $0x158, %rax, %rax # imm = 0x158
addq %rcx, %rax
addq $-0x158, %rax # imm = 0xFEA8
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x4deec4
nop
| /llvm/ADT/SmallVector.h |
std::enable_if<has_MappingTraits<clang::doc::RecordInfo, llvm::yaml::EmptyContext>::value, llvm::yaml::Output&>::type llvm::yaml::operator<<<clang::doc::RecordInfo>(llvm::yaml::Output&, clang::doc::RecordInfo&) | inline std::enable_if_t<has_MappingTraits<T, EmptyContext>::value, Output &>
operator<<(Output &yout, T &map) {
EmptyContext Ctx;
yout.beginDocuments();
if ( yout.preflightDocument(0) ) {
yamlize(yout, map, true, Ctx);
yout.postflightDocument();
}
yout.endDocuments();
return yout;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1184ff4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1185004
testb %al, %al
je 0x4dfcc2
pushq $0x1
popq %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e51c9
movq %rbx, %rdi
callq 0x1185020
movq %rbx, %rdi
callq 0x1185022
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /llvm/Support/YAMLTraits.h |
llvm::SmallVectorImpl<clang::doc::Location>::operator==(llvm::SmallVectorImpl<clang::doc::Location> const&) const | size_t size() const { return Size; } | movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x4e31b7
movq (%rdi), %rdi
imulq $0x48, %rax, %rax
addq %rdi, %rax
movq (%rsi), %rdx
movq %rax, %rsi
jmp 0x4e324e
xorl %eax, %eax
retq
| /llvm/ADT/SmallVector.h |
clang::doc::ClangDocBitcodeWriter::emitBlock(clang::doc::TemplateSpecializationInfo const&) | void ClangDocBitcodeWriter::emitBlock(const TemplateSpecializationInfo &T) {
StreamSubBlockGuard Block(Stream, BI_TEMPLATE_SPECIALIZATION_BLOCK_ID);
emitRecord(T.SpecializationOf, TEMPLATE_SPECIALIZATION_OF);
for (const auto &P : T.Params)
emitBlock(P);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
movq 0x90(%rdi), %rbx
pushq $0x15
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x4e78f6
pushq $0x37
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x4e611a
movq 0x18(%r12), %r15
movq 0x20(%r12), %r12
cmpq %r12, %r15
je 0x4e73b9
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e7328
addq $0x28, %r15
jmp 0x4e73a3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4e6466
| /BitcodeWriter.cpp |
clang::ComplexType const* clang::Type::getAs<clang::ComplexType>() const | static bool classof(const Type *T) { return T->getTypeClass() == Complex; } | cmpb $0xe, 0x10(%rdi)
je 0x4ed7ed
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0xe, 0x10(%rax)
je 0xfa2938
xorl %edi, %edi
movq %rdi, %rax
retq
nop
| /clang/AST/Type.h |
std::pair<llvm::StringMapIterator<unsigned int>, bool> llvm::StringMap<unsigned int, llvm::MallocAllocator>::try_emplace_with_hash<>(llvm::StringRef, unsigned int) | std::pair<iterator, bool> try_emplace_with_hash(StringRef Key,
uint32_t FullHashValue,
ArgsTy &&...Args) {
unsigned BucketNo = LookupBucketFor(Key, FullHashValue);
StringMapEntryBase *&Bucket = TheTable[BucketNo];
if (Bucket && Bucket != getTombstoneVal())
return std::make_pair(iterator(TheTable + BucketNo, false),
false); // Already exists in map.
if (Bucket == getTombstoneVal())
--NumTombstones;
Bucket =
MapEntryTy::create(Key, getAllocator(), std::forward<ArgsTy>(Args)...);
++NumItems;
assert(NumItems + NumTombstones <= NumBuckets);
BucketNo = RehashTable(BucketNo);
return std::make_pair(iterator(TheTable + BucketNo, false), true);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x466bea
movl %eax, %ebp
movq (%rbx), %rax
movl %ebp, %ecx
leaq (%rax,%rcx,8), %r12
movq (%r12), %rax
cmpq $-0x8, %rax
je 0x4f2241
testq %rax, %rax
je 0x4f2244
leaq 0x8(%rsp), %rbx
movq %r12, (%rbx)
movq %rbx, %rdi
callq 0x4f2052
movq (%rbx), %rax
xorl %edx, %edx
jmp 0x4f2281
decl 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4f228e
movq %rax, (%r12)
incl 0xc(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x466df2
movl %eax, %eax
shlq $0x3, %rax
addq (%rbx), %rax
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x4f2052
movq (%rbx), %rax
movb $0x1, %dl
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /llvm/ADT/StringMap.h |
clang::Decl* const* llvm::SmallVectorTemplateCommon<clang::Decl*, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<clang::Decl*, true>>(llvm::SmallVectorTemplateBase<clang::Decl*, true>*, clang::Decl* const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | pushq %rbx
movq %rsi, %rbx
movl 0x8(%rdi), %esi
movl 0xc(%rdi), %eax
addq %rdx, %rsi
cmpq %rax, %rsi
ja 0x4f66df
movq %rbx, %rax
popq %rbx
retq
callq 0x4f66e6
jmp 0x4f66da
| /llvm/ADT/SmallVector.h |
clang::CompilerInstance::createSourceManager(clang::FileManager&) | void CompilerInstance::createSourceManager(FileManager &FileMgr) {
SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2b8, %edi # imm = 0x2B8
callq 0x436820
movq %rax, %r15
movq 0x20(%r14), %rsi
movq %rax, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x107da92
incl (%r15)
movq 0x40(%r14), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r15, 0x40(%r14)
callq 0x4f25ba
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /Frontend/CompilerInstance.cpp |
clang::PrintingCodeCompleteConsumer::PrintingCodeCompleteConsumer(clang::CodeCompleteOptions const&, llvm::raw_ostream&) | PrintingCodeCompleteConsumer(const CodeCompleteOptions &CodeCompleteOpts,
raw_ostream &OS)
: CodeCompleteConsumer(CodeCompleteOpts), OS(OS),
CCTUInfo(std::make_shared<GlobalCodeCompletionAllocator>()) {} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x1472065(%rip), %rax # 0x196aa18
addq $0x10, %rax
movq %rax, (%rdi)
movl (%rsi), %eax
movl %eax, 0x8(%rdi)
leaq 0x147209a(%rip), %rax # 0x196aa60
addq $0x10, %rax
movq %rax, (%rdi)
movq %rdx, 0x10(%rdi)
addq $0x18, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4ef626
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ef642
leaq 0x10(%rsp), %rdi
callq 0x452eca
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
| /clang/Sema/CodeCompleteConsumer.h |
clang::CompilerInstance::clearOutputFiles(bool) | void CompilerInstance::clearOutputFiles(bool EraseFiles) {
// The ASTConsumer can own streams that write to the output files.
assert(!hasASTConsumer() && "ASTConsumer should be reset");
// Ignore errors that occur when trying to discard the temp file.
for (OutputFile &OF : OutputFiles) {
if (EraseFiles) {
if (OF.File)
consumeError(OF.File->discard());
if (!OF.Filename.empty())
llvm::sys::fs::remove(OF.Filename);
continue;
}
if (!OF.File)
continue;
if (OF.File->TmpName.empty()) {
consumeError(OF.File->discard());
continue;
}
llvm::Error E = OF.File->keep(OF.Filename);
if (!E)
continue;
getDiagnostics().Report(diag::err_unable_to_rename_temp)
<< OF.File->TmpName << OF.Filename << std::move(E);
llvm::sys::fs::remove(OF.File->TmpName);
}
OutputFiles.clear();
if (DeleteBuiltModules) {
for (auto &Module : BuiltModules)
llvm::sys::fs::remove(Module.second);
BuiltModules.clear();
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, 0x8(%rsp)
leaq 0x140(%rdi), %r15
leaq 0x10(%rsp), %r13
leaq 0x20(%rsp), %r12
movq %r15, %r14
movq (%r14), %r14
cmpq %r15, %r14
je 0x4f8c36
leaq 0x10(%r14), %rbx
testb %bpl, %bpl
je 0x4f8b6d
cmpb $0x1, 0x60(%r14)
jne 0x4f8b4d
leaq 0x30(%r14), %rsi
movq %r13, %rdi
callq 0x484920
movq %r13, %rdi
callq 0x4633a8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4f8b4d
movq (%rdi), %rax
callq *0x8(%rax)
cmpq $0x0, 0x18(%r14)
je 0x4f8b0d
movw $0x104, 0x40(%rsp) # imm = 0x104
movq %rbx, 0x20(%rsp)
movq %r12, %rdi
pushq $0x1
popq %rsi
callq 0x48391d
jmp 0x4f8b0d
cmpb $0x1, 0x60(%r14)
jne 0x4f8b0d
leaq 0x30(%r14), %rsi
cmpq $0x0, 0x40(%r14)
je 0x4f8c08
movw $0x104, 0x40(%rsp) # imm = 0x104
movq %rbx, 0x20(%rsp)
movq %rsp, %rdi
movq %r12, %rdx
callq 0x4849cc
cmpq $0x0, (%rsp)
je 0x4f8b0d
leaq 0x38(%r14), %r13
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rsi
movq %r12, %rdi
pushq $0x51
popq %rdx
callq 0x4a3d40
movq %r12, %rdi
movq %r13, %rsi
callq 0x4f8cb0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4f8cb0
movq %rax, %rdi
movq %rsp, %rsi
callq 0x1062cfa
movq %r12, %rdi
callq 0x4a3d6a
movw $0x104, 0x40(%rsp) # imm = 0x104
movq %r13, 0x20(%rsp)
leaq 0x10(%rsp), %r13
movq %r12, %rdi
pushq $0x1
popq %rsi
callq 0x48391d
movq (%rsp), %rdi
jmp 0x4f8c22
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x484920
movq %rbx, %rdi
callq 0x4633a8
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4f8b0d
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4f8b0d
movq %r15, %rdi
callq 0x4f8cc8
movq 0x8(%rsp), %r12
cmpb $0x0, 0x118(%r12)
je 0x4f8ca1
movq 0x100(%r12), %r14
leaq 0xf0(%r12), %r15
leaq 0x20(%rsp), %rbx
pushq $0x1
popq %rbp
cmpq %r15, %r14
je 0x4f8c92
leaq 0x40(%r14), %rax
movw $0x104, 0x40(%rsp) # imm = 0x104
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x48391d
movq %r14, %rdi
callq 0x436730
movq %rax, %r14
jmp 0x4f8c66
addq $0xe8, %r12
movq %r12, %rdi
callq 0x500a84
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Frontend/CompilerInstance.cpp |
clang::CompilerInstance::InitializeSourceManager(clang::FrontendInputFile const&, clang::DiagnosticsEngine&, clang::FileManager&, clang::SourceManager&) | bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input,
DiagnosticsEngine &Diags,
FileManager &FileMgr,
SourceManager &SourceMgr) {
SrcMgr::CharacteristicKind Kind =
Input.getKind().getFormat() == InputKind::ModuleMap
? Input.isSystem() ? SrcMgr::C_System_ModuleMap
: SrcMgr::C_User_ModuleMap
: Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
if (Input.isBuffer()) {
SourceMgr.setMainFileID(SourceMgr.createFileID(Input.getBuffer(), Kind));
assert(SourceMgr.getMainFileID().isValid() &&
"Couldn't establish MainFileID!");
return true;
}
StringRef InputFile = Input.getFile();
// Figure out where to get and map in the main file.
auto FileOrErr = InputFile == "-"
? FileMgr.getSTDIN()
: FileMgr.getFileRef(InputFile, /*OpenFile=*/true);
if (!FileOrErr) {
auto EC = llvm::errorToErrorCode(FileOrErr.takeError());
if (InputFile != "-")
Diags.Report(diag::err_fe_error_reading) << InputFile << EC.message();
else
Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
return false;
}
SourceMgr.setMainFileID(
SourceMgr.createFileID(*FileOrErr, SourceLocation(), Kind));
assert(SourceMgr.getMainFileID().isValid() &&
"Couldn't establish MainFileID!");
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r15
movl $0x700, %eax # imm = 0x700
andl 0x48(%rdi), %eax
movzbl 0x4c(%rdi), %ecx
movl %ecx, %ebp
andl $0x1, %ebp
addl $0x3, %ebp
cmpl $0x100, %eax # imm = 0x100
cmovnel %ecx, %ebp
cmpb $0x1, 0x40(%rdi)
jne 0x4f96cb
movups 0x20(%rdi), %xmm0
movups 0x30(%rdi), %xmm1
leaq 0x30(%rsp), %rsi
movaps %xmm1, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %r15, %rdi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x107ea78
movl %eax, 0x1c0(%r15)
movb $0x1, %bl
jmp 0x4f9828
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %r12
movq 0x8(%rdi), %r13
movq %r12, 0x18(%rsp)
movq %r13, 0x20(%rsp)
leaq 0xc9ac07(%rip), %rdx # 0x11942f0
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %r13, %rsi
callq 0x450e2d
leaq 0x8(%rsp), %rdi
testb %al, %al
je 0x4f970a
movq %rbx, %rsi
callq 0x106806e
jmp 0x4f971f
pushq $0x1
popq %r8
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %r8d, %r9d
callq 0x1067a04
movb 0x10(%rsp), %bl
xorb $0x1, %bl
testb $0x1, %bl
jne 0x4f97c4
movq 0x8(%rsp), %rax
andq $0x0, 0x8(%rsp)
leaq 0x28(%rsp), %rbp
movq %rax, (%rbp)
movq %rbp, %rdi
callq 0x462fac
movl %eax, 0x4(%rsp)
movq %rdx, %r15
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x4f9761
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xc9ab88(%rip), %rdx # 0x11942f0
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %r13, %rsi
callq 0x476ce5
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
testb %al, %al
je 0x4f97e4
movl $0x2ce, %edx # imm = 0x2CE
callq 0x4a3d40
leaq 0x18(%rsp), %rsi
movq %r12, %rdi
callq 0x4f956c
movq %rax, %r14
movq (%r15), %rax
leaq 0x58(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movl 0x4(%rsp), %edx
callq *0x20(%rax)
movq %r14, %rdi
movq %r13, %rsi
callq 0x4f9584
movq %r13, %rdi
jmp 0x4f9811
movq 0x8(%rsp), %rsi
movq %r15, %rdi
xorl %edx, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x107e7ce
movl %eax, 0x1c0(%r15)
jmp 0x4f981e
movl $0x2cf, %edx # imm = 0x2CF
callq 0x4a3d40
movq (%r15), %rax
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl 0x4(%rsp), %edx
callq *0x20(%rax)
movq %r12, %rdi
movq %r14, %rsi
callq 0x4f9584
movq %r14, %rdi
callq 0x436d30
movq %r12, %rdi
callq 0x4a3d6a
leaq 0x8(%rsp), %rdi
callq 0x4f983c
andb $0x1, %bl
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Frontend/CompilerInstance.cpp |
selectModuleSource(clang::Module*, llvm::StringRef, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, 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<void>, 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&, clang::HeaderSearch&) | static ModuleSource selectModuleSource(
Module *M, StringRef ModuleName, std::string &ModuleFilename,
const std::map<std::string, std::string, std::less<>> &BuiltModules,
HeaderSearch &HS) {
assert(ModuleFilename.empty() && "Already has a module source?");
// Check to see if the module has been built as part of this compilation
// via a module build pragma.
auto BuiltModuleIt = BuiltModules.find(ModuleName);
if (BuiltModuleIt != BuiltModules.end()) {
ModuleFilename = BuiltModuleIt->second;
return MS_ModuleBuildPragma;
}
// Try to load the module from the prebuilt module path.
const HeaderSearchOptions &HSOpts = HS.getHeaderSearchOpts();
if (!HSOpts.PrebuiltModuleFiles.empty() ||
!HSOpts.PrebuiltModulePaths.empty()) {
ModuleFilename = HS.getPrebuiltModuleFileName(ModuleName);
if (HSOpts.EnablePrebuiltImplicitModules && ModuleFilename.empty())
ModuleFilename = HS.getPrebuiltImplicitModuleFileName(M);
if (!ModuleFilename.empty())
return MS_PrebuiltModulePath;
}
// Try to load the module from the module cache.
if (M) {
ModuleFilename = HS.getCachedModuleFileName(M);
return MS_ModuleCache;
}
return MS_ModuleNotFound;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r9, %r14
movq %r8, %r12
movq %rcx, %rbx
movq %rdi, %r15
movq %rsp, %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq %r8, %rdi
movq %rax, %rsi
callq 0x4fe022
addq $0x8, %r12
cmpq %r12, %rax
je 0x4fb40a
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4367b0
pushq $0x3
jmp 0x4fb4d1
movq (%r14), %r13
cmpq $0x0, 0xd8(%r13)
jne 0x4fb427
movq 0xe0(%r13), %rax
cmpq 0xe8(%r13), %rax
je 0x4fb4a4
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0xff6884
movq %rbx, %rdi
movq %r12, %rsi
callq 0x436ae0
movq %r12, %rdi
callq 0x436d30
movb 0x118(%r13), %cl
shrb $0x4, %cl
movq 0x8(%rbx), %rax
testq %rax, %rax
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x4fb49b
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xff6b0c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x436ae0
movq %r12, %rdi
callq 0x436d30
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x4fb4a4
pushq $0x2
jmp 0x4fb4d1
testq %r15, %r15
je 0x4fb4e0
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xff67fe
movq %rbx, %rdi
movq %r12, %rsi
callq 0x436ae0
movq %r12, %rdi
callq 0x436d30
pushq $0x1
popq %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x4fb4d2
| /Frontend/CompilerInstance.cpp |
void llvm::SmallVectorImpl<clang::Module*>::append<__gnu_cxx::__normal_iterator<clang::Module**, std::vector<clang::Module*, std::allocator<clang::Module*>>>, void>(__gnu_cxx::__normal_iterator<clang::Module**, std::vector<clang::Module*, std::allocator<clang::Module*>>>, __gnu_cxx::__normal_iterator<clang::Module**, std::vector<clang::Module*, std::allocator<clang::Module*>>>) | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %r12
subq %rsi, %r12
sarq $0x3, %r12
movl 0x8(%rdi), %esi
addq %r12, %rsi
callq 0x4fd8c6
subq %r15, %r14
je 0x4fd8b6
movl 0x8(%rbx), %edi
shlq $0x3, %rdi
addq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x436140
addl %r12d, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /llvm/ADT/SmallVector.h |
void llvm::Expected<llvm::sys::fs::TempFile>::moveConstruct<llvm::sys::fs::TempFile>(llvm::Expected<llvm::sys::fs::TempFile>&&) | void moveConstruct(Expected<OtherT> &&Other) {
HasError = Other.HasError;
#if LLVM_ENABLE_ABI_BREAKING_CHECKS
Unchecked = true;
Other.Unchecked = false;
#endif
if (!HasError)
new (getStorage()) storage_type(std::move(*Other.getStorage()));
else
new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
} | movb 0x30(%rsi), %al
andb $0x1, %al
movb 0x30(%rdi), %cl
andb $-0x2, %cl
orb %al, %cl
movb %cl, 0x30(%rdi)
testb %al, %al
je 0x4848c8
movq (%rsi), %rax
movq %rax, (%rdi)
andq $0x0, (%rsi)
retq
nop
| /llvm/Support/Error.h |
void llvm::function_ref<void (clang::CompilerInstance&)>::callback_fn<clang::CompilerInstance::createModuleFromSource(clang::SourceLocation, llvm::StringRef, llvm::StringRef)::$_0>(long, clang::CompilerInstance&) | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %r14
movq 0x38(%rsi), %rdi
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x8(%rcx), %rcx
xorl %r8d, %r8d
callq 0x1068162
movq %rax, %r12
movq 0x40(%rbx), %r13
movq 0x8(%r15), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0xd8172b(%rip), %rcx # 0x12826c7
leaq 0x8(%rsp), %r15
pushq $0x1
popq %r9
movq %r15, %rdi
xorl %r8d, %r8d
callq 0x496c0c
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x107f0e4
movq (%r15), %rdi
testq %rdi, %rdi
je 0x500fcc
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rsp)
movl $0xe8, %edi
addq %rdi, %r14
addq %rbx, %rdi
movq %r14, %rsi
callq 0x500ffa
movb $0x0, 0x118(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /llvm/ADT/STLFunctionalExtras.h |
clang::CompilerInvocationBase::deep_copy_assign(clang::CompilerInvocationBase const&) | CompilerInvocationBase &
CompilerInvocationBase::deep_copy_assign(const CompilerInvocationBase &X) {
if (this != &X) {
LangOpts = make_shared_copy(X.getLangOpts());
TargetOpts = make_shared_copy(X.getTargetOpts());
DiagnosticOpts = makeIntrusiveRefCntCopy(X.getDiagnosticOpts());
HSOpts = make_shared_copy(X.getHeaderSearchOpts());
PPOpts = make_shared_copy(X.getPreprocessorOpts());
AnalyzerOpts = makeIntrusiveRefCntCopy(X.getAnalyzerOpts());
MigratorOpts = make_shared_copy(X.getMigratorOpts());
APINotesOpts = make_shared_copy(X.getAPINotesOpts());
CodeGenOpts = make_shared_copy(X.getCodeGenOpts());
FSOpts = make_shared_copy(X.getFileSystemOpts());
FrontendOpts = make_shared_copy(X.getFrontendOpts());
DependencyOutputOpts = make_shared_copy(X.getDependencyOutputOpts());
PreprocessorOutputOpts = make_shared_copy(X.getPreprocessorOutputOpts());
}
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x501731
movq %rsi, %r14
movq (%rsi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x536916
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f2f2e
leaq 0x8(%rsp), %rdi
callq 0x452eca
movq 0x10(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x4f400c
leaq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4f44d8
leaq 0x8(%rsp), %rdi
callq 0x452eca
movq 0x20(%r14), %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x536d6b
movq (%r15), %rax
movq 0x20(%rbx), %rcx
movq %rcx, (%r15)
movq %rax, 0x20(%rbx)
movq %r15, %rdi
callq 0x49f934
movq 0x28(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x536e3a
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x4f365c
leaq 0x8(%rsp), %rdi
callq 0x452eca
movq 0x38(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x5371a3
leaq 0x38(%rbx), %rdi
movq %r15, %rsi
callq 0x4f39e2
leaq 0x8(%rsp), %rdi
callq 0x452eca
movq 0x48(%r14), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x537625
movq (%r15), %rax
movq 0x48(%rbx), %rcx
movq %rcx, (%r15)
movq %rax, 0x48(%rbx)
movq %r15, %rdi
callq 0x4a5e4a
movq 0x50(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x5377de
leaq 0x50(%rbx), %rdi
movq %r15, %rsi
callq 0x537880
leaq 0x8(%rsp), %rdi
callq 0x452eca
movq 0x60(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x5378ae
leaq 0x60(%rbx), %rdi
movq %r15, %rsi
callq 0x537988
leaq 0x8(%rsp), %rdi
callq 0x452eca
movq 0x70(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x5379b6
leaq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x538410
leaq 0x8(%rsp), %rdi
callq 0x452eca
movq 0x80(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x53843e
leaq 0x80(%rbx), %rdi
movq %r15, %rsi
callq 0x538504
leaq 0x8(%rsp), %rdi
callq 0x452eca
movq 0x90(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x538532
leaq 0x90(%rbx), %rdi
movq %r15, %rsi
callq 0x538c1c
leaq 0x8(%rsp), %rdi
callq 0x452eca
movq 0xa0(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x538c4a
leaq 0xa0(%rbx), %rdi
movq %r15, %rsi
callq 0x538e4a
leaq 0x8(%rsp), %rdi
callq 0x452eca
movq 0xb0(%r14), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x538e78
leaq 0xb0(%rbx), %rdi
movq %r14, %rsi
callq 0x538f1a
leaq 0x8(%rsp), %rdi
callq 0x452eca
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /Frontend/CompilerInvocation.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<clang::FileEntryRef, llvm::SmallVector<clang::FileEntryRef, 2u>, llvm::DenseMapInfo<clang::FileEntryRef, void>, llvm::detail::DenseMapPair<clang::FileEntryRef, llvm::SmallVector<clang::FileEntryRef, 2u>>>, clang::FileEntryRef, llvm::SmallVector<clang::FileEntryRef, 2u>, llvm::DenseMapInfo<clang::FileEntryRef, void>, llvm::detail::DenseMapPair<clang::FileEntryRef, llvm::SmallVector<clang::FileEntryRef, 2u>>>::LookupBucketFor<clang::FileEntryRef>(clang::FileEntryRef const&, llvm::detail::DenseMapPair<clang::FileEntryRef, llvm::SmallVector<clang::FileEntryRef, 2u>> const*&) const | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of whether we find a tombstone while probing.
const BucketT *FoundTombstone = nullptr;
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
!KeyInfoT::isEqual(Val, TombstoneKey) &&
"Empty/Tombstone value shouldn't be inserted into map!");
unsigned BucketNo = getHashValue(Val) & (NumBuckets-1);
unsigned ProbeAmt = 1;
while (true) {
const BucketT *ThisBucket = BucketsPtr + BucketNo;
// Found Val's bucket? If so, return it.
if (LLVM_LIKELY(KeyInfoT::isEqual(Val, ThisBucket->getFirst()))) {
FoundBucket = ThisBucket;
return true;
}
// If we found an empty bucket, the key doesn't exist in the set.
// Insert it and return the default value.
if (LLVM_LIKELY(KeyInfoT::isEqual(ThisBucket->getFirst(), EmptyKey))) {
// If we've already seen a tombstone while probing, fill it in instead
// of the empty bucket we eventually probed to.
FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
return false;
}
// If this is a tombstone, remember it. If Val ends up not in the map, we
// prefer to return it than something that would require more probing.
if (KeyInfoT::isEqual(ThisBucket->getFirst(), TombstoneKey) &&
!FoundTombstone)
FoundTombstone = ThisBucket; // Remember the first tombstone found.
// Otherwise, it's a hash collision or a tombstone, continue quadratic
// probing.
BucketNo += ProbeAmt++;
BucketNo &= (NumBuckets-1);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl 0x10(%rdi), %ebp
testl %ebp, %ebp
je 0x53bb8f
movq %rsi, %r14
movq (%rdi), %r12
movq %rsi, %rdi
callq 0x53bbb4
movl %eax, %r15d
decl %ebp
pushq $0x1
popq %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
andl %ebp, %r15d
imulq $0x28, %r15, %rax
leaq (%r12,%rax), %r13
movq (%r14), %rdi
movq (%r12,%rax), %rsi
callq 0x53b8e8
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x53bb94
movq (%r13), %rdi
movq $-0x1000, %rsi # imm = 0xF000
callq 0x53b8e8
testb %al, %al
jne 0x53bba6
movq (%r13), %rdi
movq $-0x2000, %rsi # imm = 0xE000
callq 0x53b8e8
cmpq $0x0, 0x8(%rsp)
je 0x53bb6e
movq 0x8(%rsp), %r13
testb %al, %al
movq 0x8(%rsp), %rax
cmovneq %r13, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addl %eax, %r15d
incl %eax
movq %rax, 0x10(%rsp)
jmp 0x53bb1e
xorl %r13d, %r13d
xorl %eax, %eax
movq %r13, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
testq %rax, %rax
cmovneq %rax, %r13
jmp 0x53bb92
| /llvm/ADT/DenseMap.h |
clang::FrontendOptions::getInputKindForExtension(llvm::StringRef) | InputKind FrontendOptions::getInputKindForExtension(StringRef Extension) {
return llvm::StringSwitch<InputKind>(Extension)
.Cases("ast", "pcm", InputKind(Language::Unknown, InputKind::Precompiled))
.Case("c", Language::C)
.Cases("S", "s", Language::Asm)
.Case("i", InputKind(Language::C).getPreprocessed())
.Case("ii", InputKind(Language::CXX).getPreprocessed())
.Case("cui", InputKind(Language::CUDA).getPreprocessed())
.Case("m", Language::ObjC)
.Case("mi", InputKind(Language::ObjC).getPreprocessed())
.Cases("mm", "M", Language::ObjCXX)
.Case("mii", InputKind(Language::ObjCXX).getPreprocessed())
.Cases("C", "cc", "cp", Language::CXX)
.Cases("cpp", "CPP", "c++", "cxx", "hpp", "hxx", Language::CXX)
.Case("cppm", Language::CXX)
.Cases("iim", "iih", InputKind(Language::CXX).getPreprocessed())
.Case("cl", Language::OpenCL)
.Case("clcpp", Language::OpenCLCXX)
.Cases("cu", "cuh", Language::CUDA)
.Case("hip", Language::HIP)
.Cases("ll", "bc", Language::LLVM_IR)
.Case("hlsl", Language::HLSL)
.Case("cir", Language::CIR)
.Default(Language::Unknown);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
leaq 0x90(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
movb $0x0, 0x14(%rax)
leaq 0xc6f797(%rip), %rsi # 0x11b1114
leaq 0xc5d6f7(%rip), %rcx # 0x119f07b
pushq $0x3
popq %rbx
movq %rax, %rdi
movq %rbx, %rdx
movq %rbx, %r8
movl $0x200, %r9d # imm = 0x200
callq 0x532d62
leaq 0xd5ced4(%rip), %rsi # 0x129e876
pushq $0x1
popq %r15
pushq $0x4
popq %rcx
movq %rax, %rdi
movq %r15, %rdx
callq 0x5323e4
leaq 0xd402cb(%rip), %rsi # 0x1281c86
leaq 0xd18db3(%rip), %rcx # 0x125a775
pushq $0x1
popq %r9
movq %rax, %rdi
movq %r15, %rdx
movq %r15, %r8
callq 0x532d62
leaq 0xd5ecef(%rip), %rsi # 0x12a06ca
movq %rax, %rdi
movq %r15, %rdx
movl $0x804, %ecx # imm = 0x804
callq 0x5323e4
leaq 0xe9161f(%rip), %rsi # 0x13d3011
pushq $0x2
popq %r14
movq %rax, %rdi
movq %r14, %rdx
movl $0x805, %ecx # imm = 0x805
callq 0x5323e4
leaq 0xc683b8(%rip), %rsi # 0x11a9dc5
movq %rax, %rdi
movq %rbx, %rdx
movl $0x80a, %ecx # imm = 0x80A
callq 0x5323e4
leaq 0xf7559a(%rip), %rsi # 0x14b6fbe
pushq $0x6
popq %rcx
movq %rax, %rdi
movq %r15, %rdx
callq 0x5323e4
leaq 0xebcb8c(%rip), %rsi # 0x13fe5c5
movq %rax, %rdi
movq %r14, %rdx
movl $0x806, %ecx # imm = 0x806
callq 0x5323e4
leaq 0xf52d36(%rip), %rsi # 0x1494786
leaq 0xedf2c1(%rip), %rcx # 0x1420d18
pushq $0x7
popq %r9
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %r8
callq 0x532d62
leaq 0xc68359(%rip), %rsi # 0x11a9dc9
movq %rax, %rdi
movq %rbx, %rdx
movl $0x807, %ecx # imm = 0x807
callq 0x5323e4
leaq 0xc799dd(%rip), %rcx # 0x11bb464
movq %rcx, 0x80(%rsp)
movq $0x2, 0x88(%rsp)
movups 0x80(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0xdfa7f9(%rip), %rsi # 0x133c2a7
leaq 0xd5cf4f(%rip), %rcx # 0x129ea04
pushq $0x5
popq %rbp
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %r8
movl %ebp, %r9d
callq 0x532426
leaq 0xc629d7(%rip), %rcx # 0x11a44a7
movq %rcx, 0x70(%rsp)
movq %rbx, 0x78(%rsp)
leaq 0xc98dce(%rip), %rcx # 0x11da8af
movq %rcx, 0x60(%rsp)
movq %rbx, 0x68(%rsp)
leaq 0xc95b0b(%rip), %rcx # 0x11d75fd
movq %rcx, 0x50(%rsp)
movq %rbx, 0x58(%rsp)
leaq 0xcd462a(%rip), %rcx # 0x121612d
movq %rcx, 0x40(%rsp)
movq %rbx, 0x48(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, 0x30(%rsp)
movups 0x50(%rsp), %xmm0
movups %xmm0, 0x20(%rsp)
movups 0x60(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movups 0x70(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0xc8b593(%rip), %rsi # 0x11cd0ce
leaq 0xc6828b(%rip), %rcx # 0x11a9dcd
movq %rax, %rdi
movq %rbx, %rdx
movq %rbx, %r8
movl %ebp, %r9d
callq 0x541c54
leaq 0xc68277(%rip), %rsi # 0x11a9dd1
pushq $0x4
popq %r15
movq %rax, %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x5323e4
leaq 0xc68264(%rip), %rsi # 0x11a9dd6
leaq 0xc68261(%rip), %rcx # 0x11a9dda
movq %rax, %rdi
movq %rbx, %rdx
movq %rbx, %r8
movl $0x805, %r9d # imm = 0x805
callq 0x532d62
leaq 0xc6bc66(%rip), %rsi # 0x11ad7fa
pushq $0x8
popq %rcx
movq %rax, %rdi
movq %r14, %rdx
callq 0x5323e4
leaq 0xc628e2(%rip), %rsi # 0x11a448b
pushq $0x5
popq %rdx
pushq $0x9
popq %rcx
movq %rax, %rdi
callq 0x5323e4
leaq 0xf7112a(%rip), %rsi # 0x14b2ce8
leaq 0xc68219(%rip), %rcx # 0x11a9dde
pushq $0xa
popq %r9
movq %rax, %rdi
movq %r14, %rdx
movq %rbx, %r8
callq 0x532d62
leaq 0xca03f7(%rip), %rsi # 0x11e1fd5
pushq $0xc
popq %rcx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x5323e4
leaq 0xf20f3d(%rip), %rsi # 0x1462b30
leaq 0xc6f6fe(%rip), %rcx # 0x11b12f8
pushq $0x3
popq %r9
movq %rax, %rdi
movq %r14, %rdx
movq %r14, %r8
callq 0x532d62
leaq 0xc83e9f(%rip), %rsi # 0x11c5ab2
pushq $0xd
popq %rcx
movq %rax, %rdi
movq %r15, %rdx
callq 0x5323e4
leaq 0xc6f51d(%rip), %rsi # 0x11b1145
pushq $0x2
popq %rcx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x5323e4
xorl %ecx, %ecx
cmpb $0x0, 0x14(%rax)
movzwl 0x10(%rax), %eax
cmovnel %eax, %ecx
movl %ecx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /Frontend/FrontendOptions.cpp |
llvm::StringMap<clang::LayoutOverrideSource::Layout, llvm::MallocAllocator>::~StringMap() | ~StringMap() {
// Delete all the elements in the map, but don't reset the elements
// to default values. This is a copy of clear(), but avoids unnecessary
// work not required in the destructor.
if (!empty()) {
for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
StringMapEntryBase *Bucket = TheTable[I];
if (Bucket && Bucket != getTombstoneVal()) {
static_cast<MapEntryTy *>(Bucket)->Destroy(getAllocator());
}
}
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
je 0x54c1d9
movl 0x8(%rbx), %r14d
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x54c1d9
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
cmpq $-0x8, %rdi
je 0x54c1d4
testq %rdi, %rdi
je 0x54c1d4
movq %rbx, %rsi
callq 0x54c1e6
incq %r15
jmp 0x54c1b5
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x454bfc
| /llvm/ADT/StringMap.h |
llvm::StringMap<std::nullopt_t, llvm::MallocAllocator>::erase(llvm::StringRef) | bool erase(StringRef Key) {
iterator I = find(Key);
if (I == end())
return false;
erase(I);
return true;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x54f244
movq %rax, %r14
movl 0x8(%rbx), %r15d
shlq $0x3, %r15
addq (%rbx), %r15
cmpq %r15, %rax
je 0x54f237
movq %rbx, %rdi
movq %r14, %rsi
callq 0x54f272
cmpq %r15, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
| /llvm/ADT/StringMap.h |
llvm::json::ObjectKey::operator=(llvm::json::ObjectKey const&) | ObjectKey &operator=(const ObjectKey &C) {
if (C.Owned) {
Owned.reset(new std::string(*C.Owned));
Data = *Owned;
} else {
Data = C.Data;
}
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x54fbf7
pushq $0x20
popq %rdi
callq 0x436820
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4363d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x54fb8c
movq (%rbx), %rax
movups (%rax), %xmm0
jmp 0x54fbfb
movups 0x8(%rsi), %xmm0
movups %xmm0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
| /llvm/Support/JSON.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::json::ObjectKey, llvm::json::Value, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::json::ObjectKey, llvm::json::Value>>, llvm::json::ObjectKey, llvm::json::Value, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::json::ObjectKey, llvm::json::Value>>::destroyAll() | void destroyAll() {
if (getNumBuckets() == 0) // Nothing to do.
return;
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->getFirst(), TombstoneKey))
P->getSecond().~ValueT();
P->getFirst().~KeyT();
}
} | cmpl $0x0, 0x10(%rdi)
je 0x54fce6
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
callq 0x54fa30
leaq 0x8(%rsp), %rdi
callq 0x54fce8
movq (%r14), %rbx
movl 0x10(%r14), %r14d
addq $0x18, %rbx
shlq $0x6, %r14
testq %r14, %r14
je 0x54fccb
movq -0x10(%rbx), %rdi
movq -0x8(%rbx), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x4673f4
testb %al, %al
jne 0x54fcb8
movq -0x10(%rbx), %rdi
movq -0x8(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x4673f4
testb %al, %al
jne 0x54fcb8
movq %rbx, %rdi
callq 0x117a148
leaq -0x18(%rbx), %rdi
callq 0x54fc08
addq $0x40, %rbx
addq $-0x40, %r14
jmp 0x54fc75
leaq 0x8(%rsp), %rdi
callq 0x54fc08
leaq 0x20(%rsp), %rdi
callq 0x54fc08
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
| /llvm/ADT/DenseMap.h |
clang::TestModuleFileExtension::Reader::Reader(clang::ModuleFileExtension*, llvm::BitstreamCursor const&) | TestModuleFileExtension::Reader::Reader(ModuleFileExtension *Ext,
const llvm::BitstreamCursor &InStream)
: ModuleFileExtensionReader(Ext), Stream(InStream)
{
// Read the extension block.
SmallVector<uint64_t, 4> Record;
while (true) {
llvm::Expected<llvm::BitstreamEntry> MaybeEntry =
Stream.advanceSkippingSubblocks();
if (!MaybeEntry)
(void)MaybeEntry.takeError();
llvm::BitstreamEntry Entry = MaybeEntry.get();
switch (Entry.Kind) {
case llvm::BitstreamEntry::SubBlock:
case llvm::BitstreamEntry::EndBlock:
case llvm::BitstreamEntry::Error:
return;
case llvm::BitstreamEntry::Record:
break;
}
Record.clear();
StringRef Blob;
Expected<unsigned> MaybeRecCode =
Stream.readRecord(Entry.ID, Record, &Blob);
if (!MaybeRecCode)
fprintf(stderr, "Failed reading rec code: %s\n",
toString(MaybeRecCode.takeError()).c_str());
switch (MaybeRecCode.get()) {
case FIRST_EXTENSION_RECORD_ID: {
StringRef Message = Blob.substr(0, Record[0]);
fprintf(stderr, "Read extension block message: %s\n",
Message.str().c_str());
break;
}
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
leaq 0x13a9c35(%rip), %rax # 0x18fd5e0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x553b50
leaq 0x88(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x400000000, %rcx # imm = 0x400000000
movq %rcx, -0x8(%rax)
leaq 0x8(%rsp), %r14
leaq 0x20(%rsp), %r15
leaq 0x78(%rsp), %r12
leaq 0x30(%rsp), %r13
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x553ba6
testb $0x1, 0x10(%rsp)
je 0x553a1d
movq 0x8(%rsp), %rdi
andq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x553b29
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x3, 0x8(%rsp)
jb 0x553b29
movl 0xc(%rsp), %edx
andl $0x0, 0x80(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rcx
movq %r13, %r8
callq 0x115c83c
testb $0x1, 0x28(%rsp)
jne 0x553a6d
cmpl $0x4, 0x20(%rsp)
je 0x553ac8
movq %r15, %rdi
callq 0x484d68
movq %r14, %rdi
callq 0x553c46
jmp 0x5539ef
movq 0x160049c(%rip), %rax # 0x1b53f10
movq (%rax), %rbp
movq 0x20(%rsp), %rax
andq $0x0, 0x20(%rsp)
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x462cc7
movq 0x58(%rsp), %rdx
movq %rbp, %rdi
leaq 0xc5938b(%rip), %rsi # 0x11ace30
xorl %eax, %eax
callq 0x436870
leaq 0x58(%rsp), %rdi
callq 0x436d30
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x553a54
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x553a54
movq 0x78(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rsp), %rcx
cmpq %rax, %rcx
cmovbq %rcx, %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movq 0x160041e(%rip), %rax # 0x1b53f10
movq (%rax), %rbp
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x4525b6
movq 0x58(%rsp), %rdx
movq %rbp, %rdi
leaq 0xc5933a(%rip), %rsi # 0x11ace4d
xorl %eax, %eax
callq 0x436870
leaq 0x58(%rsp), %rdi
callq 0x436d30
jmp 0x553a5b
leaq 0x8(%rsp), %rdi
callq 0x553c46
leaq 0x78(%rsp), %rdi
callq 0x491d0a
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /Frontend/TestModuleFileExtension.cpp |
clang::TestModuleFileExtension::str[abi:cxx11]() const | std::string TestModuleFileExtension::str() const {
std::string Buffer;
llvm::raw_string_ostream OS(Buffer);
OS << BlockName << ":" << MajorVersion << ":" << MinorVersion << ":" << Hashed
<< ":" << UserInfo;
return Buffer;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x45b7c2
leaq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x45146c
leaq 0xf6170d(%rip), %r12 # 0x14b55c3
movq %rax, %rdi
movq %r12, %rsi
callq 0x45143e
movl 0x28(%r14), %esi
movq %rax, %rdi
callq 0x47f0a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x45143e
movl 0x2c(%r14), %esi
movq %rax, %rdi
callq 0x47f0a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x45143e
movzbl 0x30(%r14), %esi
movq %rax, %rdi
callq 0x45b7f4
movq %rax, %rdi
movq %r12, %rsi
callq 0x45143e
addq $0x38, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x45146c
movq %r15, %rdi
callq 0x4801c6
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /Frontend/TestModuleFileExtension.cpp |
llvm::DenseMap<clang::FileID, clang::VerifyDiagnosticConsumer::UnparsedFileStatus, llvm::DenseMapInfo<clang::FileID, void>, llvm::detail::DenseMapPair<clang::FileID, clang::VerifyDiagnosticConsumer::UnparsedFileStatus>>::allocateBuckets(unsigned int) | bool allocateBuckets(unsigned Num) {
NumBuckets = Num;
if (NumBuckets == 0) {
Buckets = nullptr;
return false;
}
Buckets = static_cast<BucketT *>(
allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
return true;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0x10(%rdi)
testl %esi, %esi
je 0x558043
movl %ebp, %eax
imulq $0x18, %rax, %rdi
pushq $0x8
popq %rsi
callq 0x464061
jmp 0x558045
xorl %eax, %eax
testl %ebp, %ebp
setne %cl
movq %rax, (%rbx)
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /llvm/ADT/DenseMap.h |
clang::DiagnosticRenderer::emitDiagnostic(clang::FullSourceLoc, clang::DiagnosticsEngine::Level, llvm::StringRef, llvm::ArrayRef<clang::CharSourceRange>, llvm::ArrayRef<clang::FixItHint>, llvm::PointerUnion<clang::Diagnostic const*, clang::StoredDiagnostic const*>) | void DiagnosticRenderer::emitDiagnostic(FullSourceLoc Loc,
DiagnosticsEngine::Level Level,
StringRef Message,
ArrayRef<CharSourceRange> Ranges,
ArrayRef<FixItHint> FixItHints,
DiagOrStoredDiag D) {
assert(Loc.hasManager() || Loc.isInvalid());
beginDiagnostic(D, Level);
if (!Loc.isValid())
// If we have no source location, just emit the diagnostic message.
emitDiagnosticMessage(Loc, PresumedLoc(), Level, Message, Ranges, D);
else {
// Get the ranges into a local array we can hack on.
SmallVector<CharSourceRange, 20> MutableRanges(Ranges.begin(),
Ranges.end());
SmallVector<FixItHint, 8> MergedFixits;
if (!FixItHints.empty()) {
mergeFixits(FixItHints, Loc.getManager(), LangOpts, MergedFixits);
FixItHints = MergedFixits;
}
for (const auto &Hint : FixItHints)
if (Hint.RemoveRange.isValid())
MutableRanges.push_back(Hint.RemoveRange);
FullSourceLoc UnexpandedLoc = Loc;
// Find the ultimate expansion location for the diagnostic.
Loc = Loc.getFileLoc();
PresumedLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
// First, if this diagnostic is not in the main file, print out the
// "included from" lines.
emitIncludeStack(Loc, PLoc, Level);
// Next, emit the actual diagnostic message and caret.
emitDiagnosticMessage(Loc, PLoc, Level, Message, Ranges, D);
emitCaret(Loc, Level, MutableRanges, FixItHints);
// If this location is within a macro, walk from UnexpandedLoc up to Loc
// and produce a macro backtrace.
if (UnexpandedLoc.isValid() && UnexpandedLoc.isMacroID()) {
emitMacroExpansions(UnexpandedLoc, Level, MutableRanges, FixItHints);
}
}
LastLoc = Loc;
LastLevel = Level;
endDiagnostic(D, Level);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x778, %rsp # imm = 0x778
movq %r9, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movl %ecx, %ebx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movq 0x7d0(%rsp), %r12
leaq 0x7b0(%rsp), %r13
movl %esi, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq (%rdi), %rax
movq %r12, %rsi
movl %ecx, %edx
callq *0x40(%rax)
testl %ebp, %ebp
je 0x55982b
movl %ebx, 0x30(%rsp)
leaq 0x7c0(%rsp), %r12
movq (%r13), %rsi
imulq $0xc, 0x8(%r13), %rdx
addq %rsi, %rdx
leaq 0x90(%rsp), %rdi
callq 0x559a06
leaq 0x3f8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, -0x8(%rcx)
movq (%r12), %r13
movq 0x8(%r12), %r12
testq %r12, %r12
movq %r15, 0x38(%rsp)
movl %ebp, 0x34(%rsp)
je 0x55987c
movq 0x8(%r14), %rdx
leaq 0x1c8(%rsp), %rcx
movq %r15, -0x38(%rcx)
movq %rdx, %rbx
movq %rdx, -0x30(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, -0x28(%rcx)
movb $0x1, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
leaq 0x3a8(%rsp), %rax
movups %xmm0, -0x20(%rax)
movq %rax, -0x10(%rax)
movabsq $0x400000000, %rcx # imm = 0x400000000
movq %rcx, -0x8(%rax)
leaq 0x3d8(%rsp), %rax
movq %rax, -0x10(%rax)
movups %xmm0, -0x8(%rax)
movq $0x1, 0x8(%rax)
shlq $0x6, %r12
xorl %ebp, %ebp
leaq 0x190(%rsp), %r15
cmpq %rbp, %r12
je 0x559794
movq 0x20(%r13,%rbp), %r8
testq %r8, %r8
je 0x559747
movb 0x8(%r13,%rbp), %al
testb %al, %al
jne 0x559730
movl (%r13,%rbp), %esi
cmpl 0x4(%r13,%rbp), %esi
jne 0x559730
movq 0x18(%r13,%rbp), %rdx
movzbl 0x38(%r13,%rbp), %r9d
movq %r15, %rdi
movq %r8, %rcx
xorl %r8d, %r8d
callq 0xd0ab4a
jmp 0x55978b
movq (%r13,%rbp), %rsi
movq 0x18(%r13,%rbp), %rcx
movzbl %al, %edx
movq %r15, %rdi
callq 0xd0b02e
jmp 0x55978b
cmpl $0x0, 0xc(%r13,%rbp)
je 0x559779
cmpl $0x0, 0x10(%r13,%rbp)
je 0x559779
movl (%r13,%rbp), %esi
movq 0xc(%r13,%rbp), %rdx
movzbl 0x38(%r13,%rbp), %r9d
movl 0x14(%r13,%rbp), %ecx
movq %r15, %rdi
xorl %r8d, %r8d
callq 0xd0adb2
jmp 0x55978b
movq (%r13,%rbp), %rsi
movl 0x8(%r13,%rbp), %edx
movq %r15, %rdi
callq 0xd0afa6
addq $0x40, %rbp
jmp 0x5596ed
leaq 0x5f8(%rsp), %r15
movq %r15, %rdi
movq 0x38(%rsp), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x55a8da
leaq 0x190(%rsp), %rsi
movq %r15, %rdi
callq 0xd0bf02
testb %al, %al
je 0x5597f0
leaq 0x13a432f(%rip), %rax # 0x18fdaf8
leaq 0x80(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x3e8(%rsp), %rax
movq %rax, 0x8(%rsi)
leaq 0x5f8(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0xd0bfb4
leaq 0x5f8(%rsp), %rdi
callq 0x55a98e
leaq 0x190(%rsp), %rdi
callq 0x55a9ca
movq 0x3e8(%rsp), %r13
movl 0x3f0(%rsp), %r12d
leaq 0x7c0(%rsp), %rax
movq %r13, (%rax)
movq %r12, 0x8(%rax)
jmp 0x55987f
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
andq $0x0, 0x70(%rsp)
movq (%r14), %rax
movups (%r13), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x70(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movaps 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, 0x28(%rsp)
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
movl %ebx, %ecx
movq 0x40(%rsp), %r8
movq 0x48(%rsp), %r9
callq *0x10(%rax)
jmp 0x5599de
xorl %r12d, %r12d
shlq $0x6, %r12
xorl %ebp, %ebp
leaq 0x90(%rsp), %r15
cmpq %rbp, %r12
je 0x5598ba
cmpl $0x0, (%r13,%rbp)
je 0x5598b4
cmpl $0x0, 0x4(%r13,%rbp)
je 0x5598b4
movq (%r13,%rbp), %rsi
movl 0x8(%r13,%rbp), %edx
movq %r15, %rdi
callq 0x4f035c
addq $0x40, %rbp
jmp 0x55988d
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x107cf68
movl %eax, (%r15)
movq %rdx, 0x8(%r15)
movq 0x10(%r14), %rax
movl 0x4(%rax), %edx
shrl $0xd, %edx
andl $0x1, %edx
leaq 0x190(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x107cf7e
movl (%r15), %esi
movq 0x8(%r15), %rdx
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movl 0x30(%rsp), %ebx
movl %ebx, %ecx
callq 0x559a20
movl (%r15), %esi
movq 0x8(%r15), %rdx
movq (%r14), %rax
leaq 0x7b0(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%r13), %rcx
movq %rcx, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
movq 0x7d0(%rsp), %r12
movq %r12, 0x28(%rsp)
movq %r14, %rdi
movl %ebx, %ecx
movq 0x40(%rsp), %r8
movq 0x48(%rsp), %r9
callq *0x10(%rax)
movl (%r15), %esi
movq 0x8(%r15), %rdx
movq 0x90(%rsp), %r8
movl 0x98(%rsp), %r9d
leaq 0x7c0(%rsp), %r15
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movl %ebx, %ecx
callq 0x559a8e
movl 0x34(%rsp), %esi
testl %esi, %esi
jns 0x5599c0
movq 0x90(%rsp), %r8
movl 0x98(%rsp), %r9d
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq 0x38(%rsp), %rdx
movl %ebx, %ecx
callq 0x559b08
leaq 0x3e8(%rsp), %rdi
callq 0x559ed0
leaq 0x90(%rsp), %rdi
callq 0x4a5ade
movl 0x50(%rsp), %ebp
movl %ebp, 0x18(%r14)
movl %ebx, 0x20(%r14)
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq *0x48(%rax)
addq $0x778, %rsp # imm = 0x778
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Frontend/DiagnosticRenderer.cpp |
llvm::StringMap<clang::IdentifierInfo*, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>>::~StringMap() | ~StringMap() {
// Delete all the elements in the map, but don't reset the elements
// to default values. This is a copy of clear(), but avoids unnecessary
// work not required in the destructor.
if (!empty()) {
for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
StringMapEntryBase *Bucket = TheTable[I];
if (Bucket && Bucket != getTombstoneVal()) {
static_cast<MapEntryTy *>(Bucket)->Destroy(getAllocator());
}
}
}
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x45a980
movq %rbx, %rdi
popq %rbx
jmp 0x454bfc
| /llvm/ADT/StringMap.h |
clang::driver::Driver::DiagnoseInputExistence(llvm::opt::DerivedArgList const&, llvm::StringRef, clang::driver::types::ID, bool) const | bool Driver::DiagnoseInputExistence(const DerivedArgList &Args, StringRef Value,
types::ID Ty, bool TypoCorrect) const {
if (!getCheckInputsExist())
return true;
// stdin always exists.
if (Value == "-")
return true;
// If it's a header to be found in the system or user search path, then defer
// complaints about its absence until those searches can be done. When we
// are definitely processing headers for C++20 header units, extend this to
// allow the user to put "-fmodule-header -xc++-header vector" for example.
if (Ty == types::TY_CXXSHeader || Ty == types::TY_CXXUHeader ||
(ModulesModeCXX20 && Ty == types::TY_CXXHeader))
return true;
if (getVFS().exists(Value))
return true;
if (TypoCorrect) {
// Check if the filename is a typo for an option flag. OptTable thinks
// that all args that are not known options and that start with / are
// filenames, but e.g. `/diagnostic:caret` is more likely a typo for
// the option `/diagnostics:caret` than a reference to a file in the root
// directory.
std::string Nearest;
if (getOpts().findNearest(Value, Nearest, getOptionVisibilityMask()) <= 1) {
Diag(clang::diag::err_drv_no_such_file_with_suggestion)
<< Value << Nearest;
return false;
}
}
// In CL mode, don't error on apparently non-existent linker inputs, because
// they can be influenced by linker flags the clang driver might not
// understand.
// Examples:
// - `clang-cl main.cc ole32.lib` in a non-MSVC shell will make the driver
// module look for an MSVC installation in the registry. (We could ask
// the MSVCToolChain object if it can find `ole32.lib`, but the logic to
// look in the registry might move into lld-link in the future so that
// lld-link invocations in non-MSVC shells just work too.)
// - `clang-cl ... /link ...` can pass arbitrary flags to the linker,
// including /libpath:, which is used to find .lib and .obj files.
// So do not diagnose this on the driver level. Rely on the linker diagnosing
// it. (If we don't end up invoking the linker, this means we'll emit a
// "'linker' input unused [-Wunused-command-line-argument]" warning instead
// of an error.)
//
// Only do this skip after the typo correction step above. `/Brepo` is treated
// as TY_Object, but it's clearly a typo for `/Brepro`. It seems fine to emit
// an error if we have a flag that's within an edit distance of 1 from a
// flag. (Users can use `-Wl,` or `/linker` to launder the flag past the
// driver in the unlikely case they run into this.)
//
// Don't do this for inputs that start with a '/', else we'd pass options
// like /libpath: through to the linker silently.
//
// Emitting an error for linker inputs can also cause incorrect diagnostics
// with the gcc driver. The command
// clang -fuse-ld=lld -Wl,--chroot,some/dir /file.o
// will make lld look for some/dir/file.o, while we will diagnose here that
// `/file.o` does not exist. However, configure scripts check if
// `clang /GR-` compiles without error to see if the compiler is cl.exe,
// so we can't downgrade diagnostics for `/GR-` from an error to a warning
// in cc mode. (We can in cl mode because cl.exe itself only warns on
// unknown flags.)
if (IsCLMode() && Ty == types::TY_Object && !Value.starts_with("/"))
return true;
Diag(clang::diag::err_drv_no_such_file) << Value;
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movb $0x1, %bl
testb $0x1, 0x470(%rdi)
jne 0x56bd18
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r9d, %r15d
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r14
leaq 0xc285c2(%rip), %rdx # 0x11942f0
pushq $0x1
popq %rcx
movq %r13, %rdi
movq %r12, %rsi
callq 0x450e2d
movl %ebp, %ecx
andl $-0x2, %ecx
cmpl $0x20, %ecx
je 0x56bd07
testb %al, %al
jne 0x56bd07
cmpl $0x1d, %ebp
jne 0x56bd56
cmpb $0x0, 0x24(%r14)
jne 0x56bd07
movq 0x8(%r14), %rdi
leaq 0x20(%rsp), %rsi
movw $0x105, 0x20(%rsi) # imm = 0x105
movq %r13, (%rsi)
movq %r12, 0x8(%rsi)
movq (%rdi), %rax
callq *0x58(%rax)
testb %al, %al
jne 0x56bd07
testb %r15b, %r15b
je 0x56bdde
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
callq 0x579bcc
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0x10(%r14), %ecx
addl $-0x3, %ecx
cmpl $0x2, %ecx
ja 0x56bdb6
movl %ecx, %ecx
leaq 0xc41cdc(%rip), %rdi # 0x11ada8c
movl (%rdi,%rcx,4), %r8d
jmp 0x56bdba
pushq $0x1
popq %r8
orl $-0x1, (%rsp)
leaq 0x20(%rsp), %rcx
pushq $0x4
popq %r9
movq %rax, %rdi
callq 0x6aae36
cmpl $0x1, %eax
jbe 0x56be32
leaq 0x20(%rsp), %rdi
callq 0x436d30
cmpl $0x3b, %ebp
jne 0x56be06
cmpl $0x3, 0x10(%r14)
jne 0x56be06
leaq 0xf4e0de(%rip), %rsi # 0x14b9ecf
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x45d522
testb %al, %al
je 0x56bd07
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1b5, %edx # imm = 0x1B5
callq 0x55fa78
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4f956c
movq %rbx, %rdi
callq 0x4a3d6a
jmp 0x56be74
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1b6, %edx # imm = 0x1B6
callq 0x55fa78
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4f956c
leaq 0x20(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x4f8cb0
movq %rbx, %rdi
callq 0x4a3d6a
movq %r14, %rdi
callq 0x436d30
xorl %ebx, %ebx
jmp 0x56bd07
nop
| /Driver/Driver.cpp |
clang::driver::IfsMergeJobAction* clang::driver::Compilation::MakeAction<clang::driver::IfsMergeJobAction, llvm::SmallVector<clang::driver::Action*, 3u>&, clang::driver::types::ID>(llvm::SmallVector<clang::driver::Action*, 3u>&, clang::driver::types::ID&&) | T *MakeAction(Args &&... Arg) {
T *RawPtr = new T(std::forward<Args>(Arg)...);
AllActions.push_back(std::unique_ptr<Action>(RawPtr));
return RawPtr;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x58
popq %rdi
callq 0x436820
movq %rax, %rbx
movl (%r14), %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x615182
addq $0x58, %r12
movq %rsp, %r14
movq %rbx, (%r14)
movq %r12, %rdi
movq %r14, %rsi
callq 0x573dea
movq (%r14), %rdi
testq %rdi, %rdi
je 0x56dbdd
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /clang/Driver/Compilation.h |
llvm::DenseMapBase<llvm::DenseMap<clang::driver::ToolChain const*, llvm::DenseSet<llvm::StringRef, llvm::DenseMapInfo<llvm::StringRef, void>>, llvm::DenseMapInfo<clang::driver::ToolChain const*, void>, llvm::detail::DenseMapPair<clang::driver::ToolChain const*, llvm::DenseSet<llvm::StringRef, llvm::DenseMapInfo<llvm::StringRef, void>>>>, clang::driver::ToolChain const*, llvm::DenseSet<llvm::StringRef, llvm::DenseMapInfo<llvm::StringRef, void>>, llvm::DenseMapInfo<clang::driver::ToolChain const*, void>, llvm::detail::DenseMapPair<clang::driver::ToolChain const*, llvm::DenseSet<llvm::StringRef, llvm::DenseMapInfo<llvm::StringRef, void>>>>::lookup(clang::driver::ToolChain const*) const | ValueT lookup(const_arg_type_t<KeyT> Val) const {
const BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return TheBucket->getSecond();
return ValueT();
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rdx, (%rsi)
movq %rsp, %rdx
movq %rax, %rdi
callq 0x575a06
testb %al, %al
je 0x56ddc4
movq (%rsp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x5788b2
jmp 0x56ddd7
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rdi
callq 0x49b700
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /llvm/ADT/DenseMap.h |
clang::driver::VerifyPCHJobAction* clang::driver::Compilation::MakeAction<clang::driver::VerifyPCHJobAction, clang::driver::Action*&, clang::driver::types::ID>(clang::driver::Action*&, clang::driver::types::ID&&) | T *MakeAction(Args &&... Arg) {
T *RawPtr = new T(std::forward<Args>(Arg)...);
AllActions.push_back(std::unique_ptr<Action>(RawPtr));
return RawPtr;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x58
popq %rdi
callq 0x436820
movq %rax, %rbx
movq (%r15), %rsi
movl (%r14), %edx
movq %rax, %rdi
callq 0x615252
addq $0x58, %r12
movq %rsp, %r14
movq %rbx, (%r14)
movq %r12, %rdi
movq %r14, %rsi
callq 0x573dea
movq (%r14), %rdi
testq %rdi, %rdi
je 0x56e515
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /clang/Driver/Compilation.h |
clang::driver::Driver::generatePrefixedToolNames(llvm::StringRef, clang::driver::ToolChain const&, llvm::SmallVectorImpl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&) const | void Driver::generatePrefixedToolNames(
StringRef Tool, const ToolChain &TC,
SmallVectorImpl<std::string> &Names) const {
// FIXME: Needs a better variable than TargetTriple
Names.emplace_back((TargetTriple + "-" + Tool).str());
Names.emplace_back(Tool);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %r8, %rbx
movq %rdx, %r12
movq %rsi, %r13
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x398(%rdi), %rsi
leaq 0xc22875(%rip), %rdx # 0x11942f0
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x463ed8
leaq 0x80(%rsp), %rsi
movw $0x104, 0x20(%rsi) # imm = 0x104
movq %r15, (%rsi)
leaq 0x58(%rsp), %rdx
movw $0x105, 0x20(%rdx) # imm = 0x105
movq %r13, (%rdx)
movq %r12, 0x8(%rdx)
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
callq 0x4539cc
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x46ca86
movq %rbx, %rdi
movq %r13, %rsi
callq 0x571b02
movq %r13, %rdi
callq 0x436d30
movq %r15, %rdi
callq 0x436d30
movq %rbx, %rdi
movq %r14, %rsi
callq 0x571b3c
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /Driver/Driver.cpp |
bool llvm::is_contained<llvm::SmallVector<char const*, 2u> const&, llvm::StringRef>(llvm::SmallVector<char const*, 2u> const&, llvm::StringRef const&) | bool is_contained(R &&Range, const E &Element) {
if constexpr (detail::HasMemberContains<R, E>)
return Range.contains(Element);
else if constexpr (detail::HasMemberFind<R, E>)
return Range.find(Element) != Range.end();
else
return std::find(adl_begin(Range), adl_end(Range), Element) !=
adl_end(Range);
} | pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x8(%rbx), %eax
leaq (%rdi,%rax,8), %rsi
callq 0x4a0455
movl 0x8(%rbx), %ecx
shlq $0x3, %rcx
addq (%rbx), %rcx
cmpq %rcx, %rax
setne %al
popq %rbx
retq
| /llvm/ADT/STLExtras.h |
llvm::iterator_range<llvm::opt::arg_iterator<llvm::opt::Arg* const*, sizeof...(clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID)>> llvm::opt::ArgList::filtered<clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID>(clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID) const | iterator_range<filtered_iterator<sizeof...(OptSpecifiers)>>
filtered(OptSpecifiers ...Ids) const {
OptRange Range = getRange({toOptSpecifier(Ids)...});
auto B = Args.begin() + Range.first;
auto E = Args.begin() + Range.second;
using Iterator = filtered_iterator<sizeof...(OptSpecifiers)>;
return make_range(Iterator(B, E, {toOptSpecifier(Ids)...}),
Iterator(E, E, {toOptSpecifier(Ids)...}));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %r14d
movl %r8d, %r15d
movl %ecx, 0xc(%rsp)
movq %rsi, %r13
movq %rdi, %rbx
movl 0xa8(%rsp), %eax
movl 0xa0(%rsp), %esi
leaq 0x10(%rsp), %rbp
movl %edx, (%rbp)
movl %edx, %r12d
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rbp)
movl %r8d, 0x8(%rbp)
movl %r9d, 0xc(%rbp)
movl %esi, 0x10(%rbp)
movl %eax, 0x14(%rbp)
pushq $0x6
popq %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x6a8be8
movq 0x8(%r13), %rcx
movl %eax, %edx
leaq (%rcx,%rdx,8), %rsi
shrq $0x20, %rax
leaq (%rcx,%rax,8), %r13
movl %r12d, (%rbp)
movl 0xc(%rsp), %r12d
movl %r12d, 0x4(%rbp)
movl %r15d, 0x8(%rbp)
movl %r14d, 0xc(%rbp)
movl 0xa0(%rsp), %eax
movl %eax, 0x10(%rbp)
movl 0xa8(%rsp), %eax
movl %eax, 0x14(%rbp)
leaq 0x40(%rsp), %rbp
leaq 0x10(%rsp), %rcx
movq %rbp, %rdi
movq %r13, %rdx
callq 0x57310c
leaq 0x28(%rsp), %rcx
movl 0x8(%rsp), %eax
movl %eax, (%rcx)
movl %r12d, 0x4(%rcx)
movl %r15d, 0x8(%rcx)
movl %r14d, 0xc(%rcx)
movl 0xa0(%rsp), %eax
movl %eax, 0x10(%rcx)
movl 0xa8(%rsp), %eax
movl %eax, 0x14(%rcx)
leaq 0x28(%rbx), %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x57310c
movq 0x20(%rbp), %rax
movq %rax, 0x20(%rbx)
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /llvm/Option/ArgList.h |
clang::driver::OffloadUnbundlingJobAction* clang::driver::Compilation::MakeAction<clang::driver::OffloadUnbundlingJobAction, clang::driver::Action*&>(clang::driver::Action*&) | T *MakeAction(Args &&... Arg) {
T *RawPtr = new T(std::forward<Args>(Arg)...);
AllActions.push_back(std::unique_ptr<Action>(RawPtr));
return RawPtr;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x128, %edi # imm = 0x128
callq 0x436820
movq %rax, %rbx
movq (%r14), %rsi
movq %rax, %rdi
callq 0x6152a6
addq $0x58, %r15
leaq 0x8(%rsp), %r14
movq %rbx, (%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x573dea
movq (%r14), %rdi
testq %rdi, %rdi
je 0x573a8a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /clang/Driver/Compilation.h |
std::pair<clang::driver::ToolChain const*, llvm::StringRef> const* llvm::SmallVectorTemplateCommon<std::pair<clang::driver::ToolChain const*, llvm::StringRef>, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<std::pair<clang::driver::ToolChain const*, llvm::StringRef>, true>>(llvm::SmallVectorTemplateBase<std::pair<clang::driver::ToolChain const*, llvm::StringRef>, true>*, std::pair<clang::driver::ToolChain const*, llvm::StringRef> const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rbx
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %edx
addq %rax, %rcx
cmpq %rdx, %rcx
ja 0x578b83
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rdx
imulq $0x18, %rax, %rax
addq %rdx, %rax
cmpq %rbx, %rdx
setbe %sil
cmpq %rbx, %rax
seta %bpl
andb %sil, %bpl
cmpb $0x1, %bpl
je 0x578bc4
pushq $-0x1
popq %r15
movq %r14, %rdi
movq %rcx, %rsi
callq 0x578bd8
testb %bpl, %bpl
je 0x578b75
imulq $0x18, %r15, %rbx
addq (%r14), %rbx
jmp 0x578b75
movq %rbx, %rax
subq %rdx, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
movq %rax, %r15
jmp 0x578bab
nop
| /llvm/ADT/SmallVector.h |
clang::driver::Multilib const* llvm::SmallVectorTemplateCommon<clang::driver::Multilib, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<clang::driver::Multilib, false>>(llvm::SmallVectorTemplateBase<clang::driver::Multilib, false>*, clang::driver::Multilib const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rbx
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %edx
addq %rax, %rcx
cmpq %rdx, %rcx
ja 0x57d83b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rdx
imulq $0x98, %rax, %rax
addq %rdx, %rax
cmpq %rbx, %rdx
setbe %sil
cmpq %rbx, %rax
seta %bpl
andb %sil, %bpl
cmpb $0x1, %bpl
je 0x57d882
pushq $-0x1
popq %r15
movq %r14, %rdi
movq %rcx, %rsi
callq 0x57d898
testb %bpl, %bpl
je 0x57d82d
imulq $0x98, %r15, %rbx
addq (%r14), %rbx
jmp 0x57d82d
movq %rbx, %rax
subq %rdx, %rax
movl $0x98, %esi
cqto
idivq %rsi
movq %rax, %r15
jmp 0x57d866
nop
| /llvm/ADT/SmallVector.h |
llvm::opt::Arg* llvm::opt::ArgList::getLastArg<clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID>(clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID) const | Arg *getLastArg(OptSpecifiers ...Ids) const {
Arg *Res = nullptr;
for (Arg *A : filtered(Ids...)) {
Res = A;
Res->claim();
}
return Res;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movl %r8d, %eax
movl %ecx, %r8d
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %rsi
movl %r9d, (%rsp)
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movl %eax, %r9d
callq 0x58391c
movq 0x20(%r15), %rax
leaq 0x10(%rsp), %rbx
movq %rax, 0x20(%rbx)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movaps %xmm1, 0x10(%rbx)
movaps %xmm0, (%rbx)
xorl %r14d, %r14d
movq 0x28(%r15), %r15
movq 0x10(%rsp), %rax
cmpq %r15, %rax
je 0x582a71
movq (%rax), %r14
movq 0x10(%r14), %rax
testq %rax, %rax
cmoveq %r14, %rax
orb $0x1, 0x2c(%rax)
movq %rbx, %rdi
callq 0x583a0a
jmp 0x582a4b
movq %r14, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /llvm/Option/ArgList.h |
clang::driver::tools::freebsd::Assembler::~Assembler() | class LLVM_LIBRARY_VISIBILITY Assembler final : public Tool {
public:
Assembler(const ToolChain &TC)
: Tool("freebsd::Assembler", "assembler", TC) {}
bool hasIntegratedCPP() const override { return false; }
void ConstructJob(Compilation &C, const JobAction &JA,
const InputInfo &Output, const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
const char *LinkingOutput) const override;
} | pushq %rbx
movq %rdi, %rbx
callq 0x61cdaa
pushq $0x20
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x4360d0
nop
| /Driver/ToolChains/FreeBSD.h |
isSoftFloatABI(llvm::opt::ArgList const&) | static bool isSoftFloatABI(const ArgList &Args) {
Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
options::OPT_mfloat_abi_EQ);
if (!A)
return false;
return A->getOption().matches(options::OPT_msoft_float) ||
(A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
A->getValue() == StringRef("soft"));
} | pushq %rbx
subq $0x10, %rsp
movl $0xaab, %esi # imm = 0xAAB
movl $0x8ea, %edx # imm = 0x8EA
movl $0x8cb, %ecx # imm = 0x8CB
callq 0x566b16
testq %rax, %rax
je 0x5de603
movq %rax, %rbx
movq %rax, %rdi
movl $0xaab, %esi # imm = 0xAAB
callq 0x6aa012
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x5de605
movq %rbx, %rdi
movl $0x8cb, %esi # imm = 0x8CB
callq 0x6aa012
testb %al, %al
je 0x5de603
movq 0x30(%rbx), %rax
movq (%rax), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4502cc
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0xbfebf9(%rip), %rdx # 0x11dd1f2
pushq $0x4
popq %rcx
callq 0x450e2d
jmp 0x5de605
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
| /Driver/ToolChains/Gnu.cpp |
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::init(llvm::Triple const&, llvm::opt::ArgList const&) | void Generic_GCC::GCCInstallationDetector::init(
const llvm::Triple &TargetTriple, const ArgList &Args) {
llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
? TargetTriple.get64BitArchVariant()
: TargetTriple.get32BitArchVariant();
// The library directories which may contain GCC installations.
SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs;
// The compatible GCC triples for this particular architecture.
SmallVector<StringRef, 16> CandidateTripleAliases;
SmallVector<StringRef, 16> CandidateBiarchTripleAliases;
// Add some triples that we want to check first.
CandidateTripleAliases.push_back(TargetTriple.str());
std::string TripleNoVendor, BiarchTripleNoVendor;
if (TargetTriple.getVendor() == llvm::Triple::UnknownVendor) {
StringRef OSEnv = TargetTriple.getOSAndEnvironmentName();
if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32)
OSEnv = "linux-gnu";
TripleNoVendor = (TargetTriple.getArchName().str() + '-' + OSEnv).str();
CandidateTripleAliases.push_back(TripleNoVendor);
if (BiarchVariantTriple.getArch() != llvm::Triple::UnknownArch) {
BiarchTripleNoVendor =
(BiarchVariantTriple.getArchName().str() + '-' + OSEnv).str();
CandidateBiarchTripleAliases.push_back(BiarchTripleNoVendor);
}
}
CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
CandidateTripleAliases, CandidateBiarchLibDirs,
CandidateBiarchTripleAliases);
// If --gcc-install-dir= is specified, skip filesystem detection.
if (const Arg *A =
Args.getLastArg(clang::driver::options::OPT_gcc_install_dir_EQ);
A && A->getValue()[0]) {
StringRef InstallDir = A->getValue();
if (!ScanGCCForMultilibs(TargetTriple, Args, InstallDir, false)) {
D.Diag(diag::err_drv_invalid_gcc_install_dir) << InstallDir;
} else {
(void)InstallDir.consume_back("/");
StringRef VersionText = llvm::sys::path::filename(InstallDir);
StringRef TripleText =
llvm::sys::path::filename(llvm::sys::path::parent_path(InstallDir));
Version = GCCVersion::Parse(VersionText);
GCCTriple.setTriple(TripleText);
GCCInstallPath = std::string(InstallDir);
GCCParentLibPath = GCCInstallPath + "/../../..";
IsValid = true;
}
return;
}
// If --gcc-triple is specified use this instead of trying to
// auto-detect a triple.
if (const Arg *A =
Args.getLastArg(clang::driver::options::OPT_gcc_triple_EQ)) {
StringRef GCCTriple = A->getValue();
CandidateTripleAliases.clear();
CandidateTripleAliases.push_back(GCCTriple);
}
// Compute the set of prefixes for our search.
SmallVector<std::string, 8> Prefixes;
StringRef GCCToolchainDir = getGCCToolchainDir(Args, D.SysRoot);
if (GCCToolchainDir != "") {
if (GCCToolchainDir.back() == '/')
GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
Prefixes.push_back(std::string(GCCToolchainDir));
} else {
// If we have a SysRoot, try that first.
if (!D.SysRoot.empty()) {
Prefixes.push_back(D.SysRoot);
AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
}
// Then look for gcc installed alongside clang.
Prefixes.push_back(D.Dir + "/..");
// Next, look for prefix(es) that correspond to distribution-supplied gcc
// installations.
if (D.SysRoot.empty()) {
// Typically /usr.
AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
}
// Try to respect gcc-config on Gentoo if --gcc-toolchain is not provided.
// This avoids accidentally enforcing the system GCC version when using a
// custom toolchain.
SmallVector<StringRef, 16> GentooTestTriples;
// Try to match an exact triple as target triple first.
// e.g. crossdev -S x86_64-gentoo-linux-gnu will install gcc libs for
// x86_64-gentoo-linux-gnu. But "clang -target x86_64-gentoo-linux-gnu"
// may pick the libraries for x86_64-pc-linux-gnu even when exact matching
// triple x86_64-gentoo-linux-gnu is present.
GentooTestTriples.push_back(TargetTriple.str());
GentooTestTriples.append(CandidateTripleAliases.begin(),
CandidateTripleAliases.end());
if (ScanGentooConfigs(TargetTriple, Args, GentooTestTriples,
CandidateBiarchTripleAliases))
return;
}
// Loop over the various components which exist and select the best GCC
// installation available. GCC installs are ranked by version number.
const GCCVersion VersionZero = GCCVersion::Parse("0.0.0");
Version = VersionZero;
for (const std::string &Prefix : Prefixes) {
auto &VFS = D.getVFS();
if (!VFS.exists(Prefix))
continue;
for (StringRef Suffix : CandidateLibDirs) {
const std::string LibDir = concat(Prefix, Suffix);
if (!VFS.exists(LibDir))
continue;
// Maybe filter out <libdir>/gcc and <libdir>/gcc-cross.
bool GCCDirExists = VFS.exists(LibDir + "/gcc");
bool GCCCrossDirExists = VFS.exists(LibDir + "/gcc-cross");
for (StringRef Candidate : CandidateTripleAliases)
ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate, false,
GCCDirExists, GCCCrossDirExists);
}
for (StringRef Suffix : CandidateBiarchLibDirs) {
const std::string LibDir = Prefix + Suffix.str();
if (!VFS.exists(LibDir))
continue;
bool GCCDirExists = VFS.exists(LibDir + "/gcc");
bool GCCCrossDirExists = VFS.exists(LibDir + "/gcc-cross");
for (StringRef Candidate : CandidateBiarchTripleAliases)
ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate, true,
GCCDirExists, GCCCrossDirExists);
}
// Skip other prefixes once a GCC installation is found.
if (Version > VersionZero)
break;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x668, %rsp # imm = 0x668
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x117321e
leaq 0xe8(%rsp), %rdi
movq %r15, %rsi
testb %al, %al
je 0x5deb28
callq 0x11732de
jmp 0x5deb2d
callq 0x1173242
leaq 0x1e8(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x400000000, %rcx # imm = 0x400000000
movq %rcx, -0x8(%rax)
leaq 0x198(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rcx, -0x8(%rax)
leaq 0x458(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x1000000000, %r14 # imm = 0x1000000000
movq %r14, -0x8(%rax)
leaq 0x568(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r14, -0x8(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x448(%rsp), %rdi
callq 0x452c2e
leaq 0x178(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
leaq 0x158(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb %cl, (%rax)
movb %cl, (%rdx)
cmpl $0x0, 0x28(%r15)
jne 0x5deda2
movq %r15, %rdi
callq 0x1172646
cmpl $0x9, 0x30(%r15)
leaq 0xbfdd2e(%rip), %r12 # 0x11dc90a
cmovneq %rax, %r12
pushq $0x9
popq %r13
cmovneq %rdx, %r13
movq %r15, %rdi
callq 0x11724e0
leaq 0xa0(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
leaq 0xc0(%rsp), %rbp
movq %rbp, %rdi
callq 0x4525b6
leaq 0x120(%rsp), %r14
pushq $0x2d
popq %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x5750b5
leaq 0x338(%rsp), %rsi
movw $0x104, 0x20(%rsi) # imm = 0x104
movq %r14, (%rsi)
leaq 0x18(%rsp), %rdx
movw $0x105, 0x20(%rdx) # imm = 0x105
movq %r12, 0x10(%rsp)
movq %r12, (%rdx)
movq %r13, 0x8(%rdx)
leaq 0x228(%rsp), %rbp
movq %rbp, %rdi
callq 0x4539cc
leaq 0x78(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0x46ca86
leaq 0x168(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x436ae0
movq %r12, %rdi
callq 0x436d30
movq %r14, %r12
movq %r14, %rdi
movabsq $0x1000000000, %r14 # imm = 0x1000000000
callq 0x436d30
leaq 0xc0(%rsp), %rdi
callq 0x436d30
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
leaq 0x448(%rsp), %rdi
callq 0x452c2e
cmpl $0x0, 0x108(%rsp)
je 0x5deda2
leaq 0xe8(%rsp), %rdi
callq 0x11724e0
leaq 0xa0(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
leaq 0xc0(%rsp), %rbp
movq %rbp, %rdi
callq 0x4525b6
pushq $0x2d
popq %rdx
movq %r12, %r14
movq %r12, %rdi
movq %rbp, %rsi
callq 0x5750b5
leaq 0x338(%rsp), %rsi
movw $0x104, 0x20(%rsi) # imm = 0x104
movq %r12, (%rsi)
leaq 0x18(%rsp), %rdx
movw $0x105, 0x20(%rdx) # imm = 0x105
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %r13, 0x8(%rdx)
leaq 0x228(%rsp), %r12
movq %r12, %rdi
callq 0x4539cc
leaq 0x78(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x46ca86
leaq 0x148(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0x436ae0
movq %rbp, %rdi
callq 0x436d30
movq %r14, %rdi
movabsq $0x1000000000, %r14 # imm = 0x1000000000
callq 0x436d30
leaq 0xc0(%rsp), %rdi
callq 0x436d30
movq (%r12), %rsi
movq 0x8(%r12), %rdx
leaq 0x558(%rsp), %rdi
callq 0x452c2e
leaq 0xe8(%rsp), %rsi
leaq 0x1d8(%rsp), %rdx
leaq 0x448(%rsp), %rcx
leaq 0x188(%rsp), %r8
leaq 0x558(%rsp), %r9
movq %r15, %rdi
callq 0x5df604
movq 0x8(%rsp), %rdi
movl $0x766, %esi # imm = 0x766
callq 0x50fc40
testq %rax, %rax
je 0x5def33
movq 0x30(%rax), %rax
movq (%rax), %rsi
cmpb $0x0, (%rsi)
je 0x5def33
leaq 0x338(%rsp), %r12
movq %r12, %rdi
callq 0x4502cc
movq (%r12), %rcx
movq 0x8(%r12), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
xorl %r9d, %r9d
callq 0x5e01d4
testb %al, %al
je 0x5df566
leaq 0xedb09a(%rip), %rsi # 0x14b9ecf
leaq 0x338(%rsp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x4a29e4
movq (%r14), %rdi
movq 0x8(%r14), %rsi
xorl %edx, %edx
callq 0x481f7c
movq %rax, %r15
movq %rdx, %r12
movq (%r14), %rdi
movq 0x8(%r14), %rsi
xorl %edx, %edx
callq 0x4818bc
movq %rax, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x481f7c
movq %rax, %r13
movq %rdx, %rbp
leaq 0x228(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5de6c4
leaq 0x1c0(%rbx), %rdi
movq %r14, %rsi
callq 0x5e2ab6
movq %r14, %rdi
callq 0x595e0e
leaq 0x8(%rbx), %rdi
movw $0x105, 0x20(%r14) # imm = 0x105
movq %r13, (%r14)
movq %rbp, 0x8(%r14)
leaq 0x228(%rsp), %rsi
callq 0x1172b18
leaq 0x228(%rsp), %r14
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
leaq 0x338(%rsp), %rsi
callq 0x454ae0
leaq 0x48(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x436ae0
movq %r14, %rdi
callq 0x436d30
leaq 0xbfd64f(%rip), %rdx # 0x11dc553
leaq 0x228(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x463ed8
leaq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x436ae0
movq %r14, %rdi
callq 0x436d30
movb $0x1, (%rbx)
jmp 0x5df597
movq 0x8(%rsp), %rdi
movl $0x768, %esi # imm = 0x768
callq 0x50fc40
testq %rax, %rax
je 0x5def78
movq 0x30(%rax), %rax
movq (%rax), %rsi
leaq 0x228(%rsp), %r12
movq %r12, %rdi
callq 0x4502cc
leaq 0x448(%rsp), %rdi
andl $0x0, 0x8(%rdi)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
callq 0x452c2e
leaq 0x238(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
movq 0x8(%rsp), %rdi
movl $0x767, %esi # imm = 0x767
callq 0x50fc40
testq %rax, %rax
je 0x5defc8
movq 0x30(%rax), %rax
movq (%rax), %rsi
leaq 0x338(%rsp), %r12
movq %r12, %rdi
callq 0x4502cc
movq (%r12), %r13
movq 0x8(%r12), %r12
jmp 0x5defd2
leaq 0xca36f8(%rip), %r13 # 0x12826c7
xorl %r12d, %r12d
movq %r13, 0x68(%rsp)
movq %r12, 0x70(%rsp)
leaq 0xca36e4(%rip), %rdx # 0x12826c7
movq %r13, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x476ce5
testb %al, %al
je 0x5df044
cmpb $0x2f, -0x1(%r13,%r12)
jne 0x5df00d
leaq -0x1(%r12), %rax
cmpq %rax, %r12
cmovbq %r12, %rax
movq %rax, 0x70(%rsp)
leaq 0x338(%rsp), %r12
leaq 0x68(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x454ae0
leaq 0x228(%rsp), %rdi
movq %r12, %rsi
callq 0x46395c
movq %r12, %rdi
callq 0x436d30
jmp 0x5df15e
movq 0x40(%rbx), %rsi
cmpq $0x0, 0x1d8(%rsi)
je 0x5df08d
addq $0x1d0, %rsi # imm = 0x1D0
leaq 0x228(%rsp), %r12
movq %r12, %rdi
callq 0x49f910
movq 0x40(%rbx), %rax
movq 0x1d0(%rax), %rcx
movq 0x1d8(%rax), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5e2b0a
movq 0x40(%rbx), %rsi
addq $0x50, %rsi
leaq 0xbfd4c1(%rip), %rdx # 0x11dc559
leaq 0x338(%rsp), %r12
movq %r12, %rdi
callq 0x463ed8
leaq 0x228(%rsp), %rdi
movq %r12, %rsi
callq 0x46395c
movq %r12, %rdi
callq 0x436d30
movq 0x40(%rbx), %rax
cmpq $0x0, 0x1d8(%rax)
jne 0x5df0eb
movq 0x1d0(%rax), %rcx
leaq 0x228(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x5e2b0a
leaq 0x348(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r14, -0x8(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x338(%rsp), %r12
movq %r12, %rdi
callq 0x452c2e
movq 0x448(%rsp), %rsi
movl 0x450(%rsp), %edx
shlq $0x4, %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x5e318a
leaq 0x558(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
movq %r12, %rcx
callq 0x5e31da
movl %eax, %ebp
movq %r12, %rdi
callq 0x45d092
testb %bpl, %bpl
jne 0x5df557
leaq 0xbfd3f8(%rip), %rsi # 0x11dc55d
leaq 0x338(%rsp), %r14
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0x5de6c4
leaq 0x1c0(%rbx), %rdi
movq %rdi, 0x60(%rsp)
movq %r14, %rsi
callq 0x595dba
movq 0x228(%rsp), %r12
movl 0x230(%rsp), %r14d
shlq $0x5, %r14
addq %r12, %r14
movq %r14, 0x58(%rsp)
cmpq %r14, %r12
je 0x5df54a
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rdi
movw $0x104, 0x38(%rsp) # imm = 0x104
movq %r12, 0x18(%rsp)
movq (%rdi), %rax
movq %rdi, 0x10(%rsp)
leaq 0x18(%rsp), %rsi
callq *0x58(%rax)
testb %al, %al
je 0x5df541
movq %rbx, %r14
movq 0x1d8(%rsp), %rax
movl 0x1e0(%rsp), %ecx
shlq $0x4, %rcx
addq %rax, %rcx
movq %rcx, 0x40(%rsp)
movq %r12, 0x50(%rsp)
cmpq 0x40(%rsp), %rax
je 0x5df39e
movq %rax, 0x48(%rsp)
movups (%rax), %xmm0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movw $0x105, 0x38(%rsp) # imm = 0x105
movups %xmm0, 0x18(%rsp)
movw $0x101, %ax # imm = 0x101
movw %ax, 0x98(%rsp)
movw %ax, 0x140(%rsp)
movw %ax, 0xe0(%rsp)
subq $0x8, %rsp
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rcx
leaq 0x80(%rsp), %r8
leaq 0x128(%rsp), %r9
leaq 0xc8(%rsp), %rax
pushq %rax
callq 0x582426
addq $0x10, %rsp
movw $0x104, 0x38(%rsp) # imm = 0x104
movq %r12, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x58(%rax)
testb %al, %al
je 0x5df37e
leaq 0x78(%rsp), %r13
movq %r13, %rdi
leaq 0xa0(%rsp), %rsi
leaq 0xcb5e57(%rip), %rdx # 0x129510d
callq 0x463ed8
movw $0x104, %ax # imm = 0x104
movw %ax, 0x38(%rsp)
movq %r13, 0x18(%rsp)
movq 0x10(%rsp), %rbp
movq (%rbp), %rax
movq %rbp, %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq *0x58(%rax)
movl %eax, %r12d
movq %r13, %rdi
callq 0x436d30
movq %r13, %rdi
leaq 0xa0(%rsp), %rsi
leaq 0xbfd266(%rip), %rdx # 0x11dc563
callq 0x463ed8
movw $0x104, %ax # imm = 0x104
movw %ax, 0x38(%rsp)
movq %r13, 0x18(%rsp)
movq (%rbp), %rax
movq %rbp, %rdi
movq %rbx, %rsi
callq *0x58(%rax)
movl %eax, %ebp
movq %r13, %rdi
callq 0x436d30
movq 0x448(%rsp), %rbx
movl 0x450(%rsp), %r13d
shlq $0x4, %r13
testq %r13, %r13
je 0x5df37e
movq (%rbx), %r8
movq 0x8(%rbx), %r9
subq $0x8, %rsp
movzbl %bpl, %eax
movzbl %r12b, %r10d
movq %r14, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
leaq 0xa8(%rsp), %rcx
pushq %rax
pushq %r10
pushq $0x0
callq 0x5e3326
addq $0x20, %rsp
addq $0x10, %rbx
addq $-0x10, %r13
jmp 0x5df33b
leaq 0xa0(%rsp), %rdi
callq 0x436d30
movq 0x48(%rsp), %rax
addq $0x10, %rax
movq 0x50(%rsp), %r12
jmp 0x5df200
movq 0x188(%rsp), %rax
movl 0x190(%rsp), %ecx
shlq $0x4, %rcx
addq %rax, %rcx
movq %rcx, 0x40(%rsp)
cmpq 0x40(%rsp), %rax
je 0x5df523
movq %rax, 0x48(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0xc0(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
leaq 0xc0(%rsp), %rsi
callq 0x4525b6
leaq 0x78(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x5750d7
movq %rbx, %rdi
callq 0x436d30
movw $0x104, 0x38(%rsp) # imm = 0x104
movq %r13, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x58(%rax)
testb %al, %al
je 0x5df506
leaq 0x120(%rsp), %r13
movq %r13, %rdi
leaq 0x78(%rsp), %r12
movq %r12, %rsi
leaq 0xcb5ccd(%rip), %rdx # 0x129510d
callq 0x463ed8
movw $0x104, %ax # imm = 0x104
movw %ax, 0x38(%rsp)
movq %r13, 0x18(%rsp)
movq 0x10(%rsp), %rbp
movq (%rbp), %rax
movq %rbp, %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq *0x58(%rax)
movb %al, 0x7(%rsp)
movq %r13, %rdi
callq 0x436d30
movq %r13, %rdi
movq %r12, %rsi
leaq 0xbfd0e0(%rip), %rdx # 0x11dc563
callq 0x463ed8
movw $0x104, %ax # imm = 0x104
movw %ax, 0x38(%rsp)
movq %r13, 0x18(%rsp)
movq (%rbp), %rax
movq %rbp, %rdi
movq %rbx, %rsi
callq *0x58(%rax)
movl %eax, %r12d
movq %r13, %rdi
callq 0x436d30
movq 0x558(%rsp), %rbx
movl 0x560(%rsp), %r13d
shlq $0x4, %r13
movzbl %r12b, %r12d
movzbl 0x7(%rsp), %ebp
testq %r13, %r13
je 0x5df506
movq (%rbx), %r8
movq 0x8(%rbx), %r9
subq $0x8, %rsp
movq %r14, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
leaq 0x80(%rsp), %rcx
pushq %r12
pushq %rbp
pushq $0x1
callq 0x5e3326
addq $0x20, %rsp
addq $0x10, %rbx
addq $-0x10, %r13
jmp 0x5df4cb
leaq 0x78(%rsp), %rdi
callq 0x436d30
movq 0x48(%rsp), %rax
addq $0x10, %rax
movq 0x50(%rsp), %r12
jmp 0x5df3b9
leaq 0x338(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x5970f8
testb %al, %al
movq %r14, %rbx
movq 0x58(%rsp), %r14
jne 0x5df54a
addq $0x20, %r12
jmp 0x5df1a8
leaq 0x338(%rsp), %rdi
callq 0x595e0e
leaq 0x228(%rsp), %rdi
callq 0x500a50
jmp 0x5df597
movq 0x40(%rbx), %rsi
leaq 0x228(%rsp), %rbx
movq %rbx, %rdi
movl $0x17c, %edx # imm = 0x17C
callq 0x55fa78
leaq 0x338(%rsp), %rsi
movq %rbx, %rdi
callq 0x4f956c
movq %rbx, %rdi
callq 0x4a3d6a
leaq 0x148(%rsp), %rdi
callq 0x436d30
leaq 0x168(%rsp), %rdi
callq 0x436d30
leaq 0x558(%rsp), %rdi
callq 0x45d092
leaq 0x448(%rsp), %rdi
callq 0x45d092
leaq 0x188(%rsp), %rdi
callq 0x45d092
leaq 0x1d8(%rsp), %rdi
callq 0x45d092
leaq 0xe8(%rsp), %rdi
callq 0x436d30
addq $0x668, %rsp # imm = 0x668
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Driver/ToolChains/Gnu.cpp |
clang::driver::toolchains::RISCVToolChain::AddClangSystemIncludeArgs(llvm::opt::ArgList const&, llvm::SmallVector<char const*, 16u>&) const | void RISCVToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
ArgStringList &CC1Args) const {
if (DriverArgs.hasArg(options::OPT_nostdinc))
return;
if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
SmallString<128> Dir(getDriver().ResourceDir);
llvm::sys::path::append(Dir, "include");
addSystemInclude(DriverArgs, CC1Args, Dir.str());
}
if (!DriverArgs.hasArg(options::OPT_nostdlibinc)) {
SmallString<128> Dir(computeSysRoot());
llvm::sys::path::append(Dir, "include");
addSystemInclude(DriverArgs, CC1Args, Dir.str());
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x140, %rsp # imm = 0x140
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movl $0xb52, %esi # imm = 0xB52
callq 0x5100c6
testb %al, %al
jne 0x60bbd8
movq %r14, %rdi
movl $0xb3e, %esi # imm = 0xB3E
callq 0x5100c6
testb %al, %al
jne 0x60bb1c
movq 0x8(%r15), %rax
movq 0xe0(%rax), %rsi
movq 0xe8(%rax), %rdx
addq %rsi, %rdx
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
callq 0x453f24
leaq 0xba3ad8(%rip), %rax # 0x11af58d
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movw $0x103, 0x20(%r13) # imm = 0x103
movw $0x101, %ax # imm = 0x101
leaq 0x80(%rsp), %rdx
movw %ax, 0x20(%rdx)
leaq 0x58(%rsp), %rcx
movw %ax, 0x20(%rcx)
leaq 0x30(%rsp), %r8
movw %ax, 0x20(%r8)
movq %r12, %rdi
movq %r13, %rsi
callq 0x4817f9
movups (%r12), %xmm0
movw $0x105, 0x20(%r13) # imm = 0x105
movups %xmm0, (%r13)
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x582304
movq %r12, %rdi
callq 0x4521fe
movq %r14, %rdi
movl $0xb54, %esi # imm = 0xB54
callq 0x5100c6
testb %al, %al
jne 0x60bbd8
movq (%r15), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq *0x218(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
callq 0x453f24
movq %r12, %rdi
callq 0x436d30
leaq 0xba3a1d(%rip), %rax # 0x11af58d
movq %rax, (%r12)
movw $0x103, 0x20(%r12) # imm = 0x103
movw $0x101, %ax # imm = 0x101
leaq 0x80(%rsp), %rdx
movw %ax, 0x20(%rdx)
leaq 0x58(%rsp), %rcx
movw %ax, 0x20(%rcx)
leaq 0x30(%rsp), %r8
movw %ax, 0x20(%r8)
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4817f9
movups (%r15), %xmm0
movw $0x105, 0x20(%r12) # imm = 0x105
movups %xmm0, (%r12)
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x582304
movq %r15, %rdi
callq 0x4521fe
addq $0x140, %rsp # imm = 0x140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /Driver/ToolChains/RISCVToolchain.cpp |
getLEHLQ[abi:cxx11](llvm::opt::ArgList const&) | static std::string getLEHLQ(const ArgList &Args) {
if (Args.hasArg(options::OPT_mzos_hlq_le_EQ)) {
Arg *LEHLQArg = Args.getLastArg(options::OPT_mzos_hlq_le_EQ);
StringRef HLQ = LEHLQArg->getValue();
if (!HLQ.empty())
return HLQ.str();
}
return "CEE";
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0xb14, %esi # imm = 0xB14
callq 0x5100c6
testb %al, %al
je 0x6125ad
movq %r14, %rdi
movl $0xb14, %esi # imm = 0xB14
callq 0x50fc40
movq 0x30(%rax), %rax
movq (%rax), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4502cc
cmpq $0x0, 0x8(%r14)
je 0x6125ad
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4525b6
jmp 0x6125c1
leaq 0xbcf5cb(%rip), %rsi # 0x11e1b7f
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x450adc
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /Driver/ToolChains/ZOS.cpp |
clang::Parser::ParseKNRParamDeclarations(clang::Declarator&) | void Parser::ParseKNRParamDeclarations(Declarator &D) {
// We know that the top-level of this declarator is a function.
DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
// Enter function-declaration scope, limiting any declarators to the
// function prototype scope, including parameter declarators.
ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope |
Scope::FunctionDeclarationScope | Scope::DeclScope);
// Read all the argument declarations.
while (isDeclarationSpecifier(ImplicitTypenameContext::No)) {
SourceLocation DSStart = Tok.getLocation();
// Parse the common declaration-specifiers piece.
DeclSpec DS(AttrFactory);
ParsedTemplateInfo TemplateInfo;
ParseDeclarationSpecifiers(DS, TemplateInfo);
// C99 6.9.1p6: 'each declaration in the declaration list shall have at
// least one declarator'.
// NOTE: GCC just makes this an ext-warn. It's not clear what it does with
// the declarations though. It's trivial to ignore them, really hard to do
// anything else with them.
if (TryConsumeToken(tok::semi)) {
Diag(DSStart, diag::err_declaration_does_not_declare_param);
continue;
}
// C99 6.9.1p6: Declarations shall contain no storage-class specifiers other
// than register.
if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
DS.getStorageClassSpec() != DeclSpec::SCS_register) {
Diag(DS.getStorageClassSpecLoc(),
diag::err_invalid_storage_class_in_func_decl);
DS.ClearStorageClassSpecs();
}
if (DS.getThreadStorageClassSpec() != DeclSpec::TSCS_unspecified) {
Diag(DS.getThreadStorageClassSpecLoc(),
diag::err_invalid_storage_class_in_func_decl);
DS.ClearStorageClassSpecs();
}
// Parse the first declarator attached to this declspec.
Declarator ParmDeclarator(DS, ParsedAttributesView::none(),
DeclaratorContext::KNRTypeList);
ParseDeclarator(ParmDeclarator);
// Handle the full declarator list.
while (true) {
// If attributes are present, parse them.
MaybeParseGNUAttributes(ParmDeclarator);
// Ask the actions module to compute the type for this declarator.
Decl *Param =
Actions.ActOnParamDeclarator(getCurScope(), ParmDeclarator);
if (Param &&
// A missing identifier has already been diagnosed.
ParmDeclarator.getIdentifier()) {
// Scan the argument list looking for the correct param to apply this
// type.
for (unsigned i = 0; ; ++i) {
// C99 6.9.1p6: those declarators shall declare only identifiers from
// the identifier list.
if (i == FTI.NumParams) {
Diag(ParmDeclarator.getIdentifierLoc(), diag::err_no_matching_param)
<< ParmDeclarator.getIdentifier();
break;
}
if (FTI.Params[i].Ident == ParmDeclarator.getIdentifier()) {
// Reject redefinitions of parameters.
if (FTI.Params[i].Param) {
Diag(ParmDeclarator.getIdentifierLoc(),
diag::err_param_redefinition)
<< ParmDeclarator.getIdentifier();
} else {
FTI.Params[i].Param = Param;
}
break;
}
}
}
// If we don't have a comma, it is either the end of the list (a ';') or
// an error, bail out.
if (Tok.isNot(tok::comma))
break;
ParmDeclarator.clear();
// Consume the comma.
ParmDeclarator.setCommaLoc(ConsumeToken());
// Parse the next declarator.
ParseDeclarator(ParmDeclarator);
}
// Consume ';' and continue parsing.
if (!ExpectAndConsumeSemi(diag::err_expected_semi_declaration))
continue;
// Otherwise recover by skipping to next semi or mandatory function body.
if (SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch))
break;
TryConsumeToken(tok::semi);
}
// The actions module must verify that all arguments were declared.
Actions.ActOnFinishKNRParamDeclarations(getCurScope(), D, Tok.getLocation());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1398, %rsp # imm = 0x1398
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq %rsi, %rdi
callq 0x62dd40
movq %rax, %r15
movq %r14, 0x20(%rsp)
movq %r14, %rdi
movl $0x308, %esi # imm = 0x308
callq 0x62a8c6
leaq 0x3f0(%r14), %rax
movq %rax, 0x18(%rsp)
leaq 0xc8(%rsp), %r13
leaq 0x230(%rsp), %rbp
leaq 0x48(%rsp), %rbx
movq %r15, 0x10(%rsp)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x63e350
testb %al, %al
je 0x62e07b
movl 0x10(%r14), %r12d
movq %r13, %rdi
movq 0x18(%rsp), %rsi
callq 0x62e238
andl $0x0, 0x28(%rsp)
leaq 0x30(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, %rdi
movq %r13, %rsi
leaq 0x28(%rsp), %rdx
pushq $0x3
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x62d2a0
movq %r14, %rdi
pushq $0x3f
popq %rsi
callq 0x62a0b2
testb %al, %al
je 0x62de78
movl %r12d, %edx
movq %rbx, %r12
movq %r13, %rbx
leaq 0xa8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movl $0x5c5, %ecx # imm = 0x5C5
callq 0x629b7a
movq %r13, %rdi
movq %rbx, %r13
movq %r12, %rbx
movq 0x10(%rsp), %r15
callq 0x4a3d6a
jmp 0x62e054
movq 0xc8(%rsp), %rax
movl %eax, %ecx
andl $0x7, %ecx
je 0x62dece
cmpl $0x5, %ecx
je 0x62dece
movl 0x1b0(%rsp), %edx
leaq 0x88(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
pushq $0x1d
popq %rcx
callq 0x629b7a
movq %r12, %rdi
callq 0x4a3d6a
movq 0xc8(%rsp), %rax
andq $-0x40, %rax
movq %rax, 0xc8(%rsp)
andq $0x0, 0x1b0(%rsp)
testb $0x18, %al
je 0x62df05
movl 0x1b4(%rsp), %edx
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
pushq $0x1d
popq %rcx
callq 0x629b7a
movq %r12, %rdi
callq 0x4a3d6a
andb $-0x40, 0xc8(%rsp)
andq $0x0, 0x1b0(%rsp)
callq 0x62d2ba
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
pushq $0x4
popq %rcx
callq 0x62e278
movq %r14, %rdi
movq %rbp, %rsi
callq 0x636fbc
movq %r14, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x62e33c
movq 0x58(%r14), %rdi
movq 0x260(%rdi), %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0x85b680
testq %rax, %rax
je 0x62dfe4
cmpl $0x0, 0x268(%rsp)
setne %dl
movq 0x270(%rsp), %rcx
testq %rcx, %rcx
sete %sil
orb %dl, %sil
jne 0x62dfe4
movl 0x10(%r15), %esi
movq 0x28(%r15), %rdx
xorl %edi, %edi
cmpl %edi, %esi
je 0x62dfa7
movl %edi, %r8d
shlq $0x5, %r8
incl %edi
cmpq %rcx, (%rdx,%r8)
jne 0x62df7a
cmpq $0x0, 0x10(%rdx,%r8)
je 0x62e008
movl 0x280(%rsp), %edx
movq %rbx, %rdi
movq %r14, %rsi
pushq $0x39
popq %rcx
jmp 0x62dfb9
movl 0x280(%rsp), %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x666, %ecx # imm = 0x666
callq 0x629b7a
cmpl $0x0, 0x268(%rsp)
jne 0x62dfd2
movq 0x270(%rsp), %rsi
jmp 0x62dfd4
xorl %esi, %esi
movq %rbx, %rdi
callq 0x500ecf
movq %rbx, %rdi
callq 0x4a3d6a
cmpw $0x42, 0x20(%r14)
jne 0x62e015
movq %rbp, %rdi
callq 0x62e3b4
movq %r14, %rdi
callq 0x62a14e
movl %eax, 0x1388(%rsp)
jmp 0x62df1b
leaq (%rdx,%r8), %rcx
addq $0x10, %rcx
movq %rax, (%rcx)
jmp 0x62dfe4
movq %r14, %rdi
movl $0x606, %esi # imm = 0x606
leaq 0xc546a3(%rip), %rdx # 0x12826c7
xorl %ecx, %ecx
callq 0x629f68
testb %al, %al
je 0x62e04c
movq %r14, %rdi
pushq $0x18
popq %rsi
pushq $0x3
popq %rdx
callq 0x62a81c
testb %al, %al
jne 0x62e061
movq %r14, %rdi
pushq $0x3f
popq %rsi
callq 0x62a0b2
movq %rbp, %rdi
callq 0x62e45a
movq %r13, %rdi
callq 0x62e492
jmp 0x62dde2
leaq 0x230(%rsp), %rdi
callq 0x62e45a
leaq 0xc8(%rsp), %rdi
callq 0x62e492
movq 0x58(%r14), %rdi
movq 0x260(%rdi), %rsi
movl 0x10(%r14), %ecx
movq 0x8(%rsp), %rdx
callq 0x85c470
leaq 0x20(%rsp), %rdi
callq 0x62e0b0
addq $0x1398, %rsp # imm = 0x1398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Parse/Parser.cpp |
clang::ParsingDeclRAIIObject::ParsingDeclRAIIObject(clang::Parser&, clang::ParsingDeclRAIIObject::NoParent_t) | Sema &getActions() const { return Actions; } | movq 0x58(%rsi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
leaq 0x8(%rdi), %rcx
leaq 0x20(%rdi), %rdx
movq %rdx, 0x10(%rdi)
movabsq $0x400000000, %rdx # imm = 0x400000000
movq %rdx, 0x18(%rdi)
andq $0x0, 0x160(%rdi)
movq 0x210(%rax), %rdx
movq %rcx, 0x210(%rax)
movq %rdx, 0x160(%rdi)
movb $0x0, 0x168(%rdi)
retq
nop
| /clang/Parse/Parser.h |
clang::Parser::ParseOpenACCVar(clang::OpenACCClauseKind) | Parser::OpenACCVarParseResult Parser::ParseOpenACCVar(OpenACCClauseKind CK) {
OpenACCArraySectionRAII ArraySections(*this);
ExprResult Res = ParseAssignmentExpression();
if (!Res.isUsable())
return {Res, OpenACCParseCanContinue::Cannot};
Res = getActions().CorrectDelayedTyposInExpr(Res.get());
if (!Res.isUsable())
return {Res, OpenACCParseCanContinue::Can};
Res = getActions().OpenACC().ActOnVar(CK, Res.get());
return {Res, OpenACCParseCanContinue::Can};
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movb $0x1, 0x3dc(%rdi)
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x6650fa
cmpq $0x2, %rax
jb 0x6327ed
movq 0x58(%rbx), %rdi
andq $-0x2, %rax
leaq 0x1623(%rip), %r8 # 0x633ddc
leaq 0xf(%rsp), %r9
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x9b7c38
pushq $0x1
popq %rbp
cmpq $0x2, %rax
jb 0x6327ed
movq 0x58(%rbx), %rcx
movq 0x2e0(%rcx), %rdi
andq $-0x2, %rax
movl %r14d, %esi
movq %rax, %rdx
callq 0xa7bd3a
movb $0x0, 0x3dc(%rbx)
movl %ebp, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| /Parse/ParseOpenACC.cpp |
clang::Parser::ParseLexedMemberInitializers(clang::Parser::ParsingClass&) | void Parser::ParseLexedMemberInitializers(ParsingClass &Class) {
ReenterClassScopeRAII InClassScope(*this, Class);
if (!Class.LateParsedDeclarations.empty()) {
// C++11 [expr.prim.general]p4:
// Otherwise, if a member-declarator declares a non-static data member
// (9.2) of a class X, the expression this is a prvalue of type "pointer
// to X" within the optional brace-or-equal-initializer. It shall not
// appear elsewhere in the member-declarator.
// FIXME: This should be done in ParseLexedMemberInitializer, not here.
Sema::CXXThisScopeRAII ThisScope(Actions, Class.TagOrTemplate,
Qualifiers());
for (LateParsedDeclaration *D : Class.LateParsedDeclarations)
D->ParseLexedMemberInitializers();
}
Actions.ActOnFinishDelayedMemberInitializers(Class.TagOrTemplate);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x63626e
cmpl $0x0, 0x18(%rbx)
je 0x6351ed
movq 0x58(%r14), %rsi
movq 0x8(%rbx), %rdx
xorl %r15d, %r15d
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %r8
xorl %ecx, %ecx
callq 0x9b6e7a
movq 0x10(%rbx), %r12
movl 0x18(%rbx), %r13d
shlq $0x3, %r13
cmpq %r15, %r13
je 0x6351e3
movq (%r12,%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x8, %r15
jmp 0x6351ce
leaq 0x8(%rsp), %rdi
callq 0x9b6f06
movq 0x58(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x8bbd40
leaq 0x20(%rsp), %rdi
callq 0x6362c6
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /Parse/ParseCXXInlineMethods.cpp |
llvm::SmallDenseMap<clang::IdentifierInfo*, clang::tok::TokenKind, 4u, llvm::DenseMapInfo<clang::IdentifierInfo*, void>, llvm::detail::DenseMapPair<clang::IdentifierInfo*, clang::tok::TokenKind>>::grow(unsigned int) | void grow(unsigned AtLeast) {
if (AtLeast > InlineBuckets)
AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
if (Small) {
// First move the inline buckets into a temporary storage.
AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
BucketT *TmpBegin = reinterpret_cast<BucketT *>(&TmpStorage);
BucketT *TmpEnd = TmpBegin;
// Loop over the buckets, moving non-empty, non-tombstones into the
// temporary storage. Have the loop move the TmpEnd forward as it goes.
const KeyT EmptyKey = this->getEmptyKey();
const KeyT TombstoneKey = this->getTombstoneKey();
for (BucketT *P = getBuckets(), *E = P + InlineBuckets; P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->getFirst(), TombstoneKey)) {
assert(size_t(TmpEnd - TmpBegin) < InlineBuckets &&
"Too many inline buckets!");
::new (&TmpEnd->getFirst()) KeyT(std::move(P->getFirst()));
::new (&TmpEnd->getSecond()) ValueT(std::move(P->getSecond()));
++TmpEnd;
P->getSecond().~ValueT();
}
P->getFirst().~KeyT();
}
// AtLeast == InlineBuckets can happen if there are many tombstones,
// and grow() is used to remove them. Usually we always switch to the
// large rep here.
if (AtLeast > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(AtLeast));
}
this->moveFromOldBuckets(TmpBegin, TmpEnd);
return;
}
LargeRep OldRep = std::move(*getLargeRep());
getLargeRep()->~LargeRep();
if (AtLeast <= InlineBuckets) {
Small = true;
} else {
new (getLargeRep()) LargeRep(allocateBuckets(AtLeast));
}
this->moveFromOldBuckets(OldRep.Buckets, OldRep.Buckets+OldRep.NumBuckets);
// Free the old table.
deallocate_buffer(OldRep.Buckets, sizeof(BucketT) * OldRep.NumBuckets,
alignof(BucketT));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpl $0x5, %esi
jb 0x66dc84
decl %esi
movq %rsi, %rdi
callq 0x45e847
cmpl $0x41, %eax
pushq $0x40
popq %rsi
cmovael %eax, %esi
movl (%rbx), %eax
testb $0x1, %al
jne 0x66dc9e
movq 0x8(%rbx), %r14
movl 0x10(%rbx), %r15d
cmpl $0x4, %esi
ja 0x66dd07
orl $0x1, %eax
movl %eax, (%rbx)
jmp 0x66dd16
movq %rsp, %r14
pushq $0x10
popq %rax
cmpq $0x50, %rax
je 0x66dcd8
movq -0x8(%rbx,%rax), %rcx
movq %rcx, %rdx
orq $0x1000, %rdx # imm = 0x1000
cmpq $-0x1000, %rdx # imm = 0xF000
je 0x66dcd2
movq %rcx, (%r14)
movzwl (%rbx,%rax), %ecx
movw %cx, 0x8(%r14)
addq $0x10, %r14
addq $0x10, %rax
jmp 0x66dca4
cmpl $0x4, %esi
jbe 0x66dcef
andb $-0x2, (%rbx)
movq %rbx, %rdi
callq 0x630962
movq %rax, 0x8(%rbx)
movl %edx, 0x10(%rbx)
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x66dd40
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x630962
movq %rax, 0x8(%rbx)
movl %edx, 0x10(%rbx)
shlq $0x4, %r15
leaq (%r14,%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x66dd40
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x464066
| /llvm/ADT/DenseMap.h |
clang::Parser::isSimpleObjCMessageExpression() | bool Parser::isSimpleObjCMessageExpression() {
assert(Tok.is(tok::l_square) && getLangOpts().ObjC &&
"Incorrect start for isSimpleObjCMessageExpression");
return GetLookAheadToken(1).is(tok::identifier) &&
GetLookAheadToken(2).is(tok::identifier);
} | pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x62b816
cmpw $0x5, 0x10(%rax)
jne 0x67f56e
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x62b816
cmpw $0x5, 0x10(%rax)
sete %al
jmp 0x67f570
xorl %eax, %eax
popq %rbx
retq
| /Parse/ParseObjc.cpp |
clang::Parser::ParseOpenMPDeclarativeOrExecutableDirective(clang::Parser::ParsedStmtContext, bool) | StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective(
ParsedStmtContext StmtCtx, bool ReadDirectiveWithinMetadirective) {
if (!ReadDirectiveWithinMetadirective)
assert(Tok.isOneOf(tok::annot_pragma_openmp, tok::annot_attr_openmp) &&
"Not an OpenMP directive!");
ParsingOpenMPDirectiveRAII DirScope(*this);
ParenBraceBracketBalancer BalancerRAIIObj(*this);
SourceLocation Loc = ReadDirectiveWithinMetadirective
? Tok.getLocation()
: ConsumeAnnotationToken();
OpenMPDirectiveKind DKind = parseOpenMPDirectiveKind(*this);
if (ReadDirectiveWithinMetadirective && DKind == OMPD_unknown) {
Diag(Tok, diag::err_omp_unknown_directive);
return StmtError();
}
StmtResult Directive = StmtError();
bool IsExecutable = [&]() {
if (DKind == OMPD_error) // OMPD_error is handled as executable
return true;
auto Res = getDirectiveCategory(DKind);
return Res == Category::Executable || Res == Category::Subsidiary;
}();
if (IsExecutable) {
Directive = ParseOpenMPExecutableDirective(
StmtCtx, DKind, Loc, ReadDirectiveWithinMetadirective);
assert(!Directive.isUnset() && "Executable directive remained unprocessed");
return Directive;
}
switch (DKind) {
case OMPD_nothing:
ConsumeToken();
// If we are parsing the directive within a metadirective, the directive
// ends with a ')'.
if (ReadDirectiveWithinMetadirective && Tok.is(tok::r_paren))
while (Tok.isNot(tok::annot_pragma_openmp_end))
ConsumeAnyToken();
else
skipUntilPragmaOpenMPEnd(DKind);
if (Tok.is(tok::annot_pragma_openmp_end))
ConsumeAnnotationToken();
// return an empty statement
return StmtEmpty();
case OMPD_metadirective: {
ConsumeToken();
SmallVector<VariantMatchInfo, 4> VMIs;
// First iteration of parsing all clauses of metadirective.
// This iteration only parses and collects all context selector ignoring the
// associated directives.
TentativeParsingAction TPA(*this);
ASTContext &ASTContext = Actions.getASTContext();
BalancedDelimiterTracker T(*this, tok::l_paren,
tok::annot_pragma_openmp_end);
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
OpenMPClauseKind CKind = Tok.isAnnotation()
? OMPC_unknown
: getOpenMPClauseKind(PP.getSpelling(Tok));
SourceLocation Loc = ConsumeToken();
// Parse '('.
if (T.expectAndConsume(diag::err_expected_lparen_after,
getOpenMPClauseName(CKind).data()))
return Directive;
OMPTraitInfo &TI = Actions.getASTContext().getNewOMPTraitInfo();
if (CKind == OMPC_when) {
// parse and get OMPTraitInfo to pass to the When clause
parseOMPContextSelectors(Loc, TI);
if (TI.Sets.size() == 0) {
Diag(Tok, diag::err_omp_expected_context_selector) << "when clause";
TPA.Commit();
return Directive;
}
// Parse ':'
if (Tok.is(tok::colon))
ConsumeAnyToken();
else {
Diag(Tok, diag::err_omp_expected_colon) << "when clause";
TPA.Commit();
return Directive;
}
}
// Skip Directive for now. We will parse directive in the second iteration
int paren = 0;
while (Tok.isNot(tok::r_paren) || paren != 0) {
if (Tok.is(tok::l_paren))
paren++;
if (Tok.is(tok::r_paren))
paren--;
if (Tok.is(tok::annot_pragma_openmp_end)) {
Diag(Tok, diag::err_omp_expected_punc)
<< getOpenMPClauseName(CKind) << 0;
TPA.Commit();
return Directive;
}
ConsumeAnyToken();
}
// Parse ')'
if (Tok.is(tok::r_paren))
T.consumeClose();
VariantMatchInfo VMI;
TI.getAsVariantMatchInfo(ASTContext, VMI);
VMIs.push_back(VMI);
}
TPA.Revert();
// End of the first iteration. Parser is reset to the start of metadirective
std::function<void(StringRef)> DiagUnknownTrait =
[this, Loc](StringRef ISATrait) {
// TODO Track the selector locations in a way that is accessible here
// to improve the diagnostic location.
Diag(Loc, diag::warn_unknown_declare_variant_isa_trait) << ISATrait;
};
TargetOMPContext OMPCtx(ASTContext, std::move(DiagUnknownTrait),
/* CurrentFunctionDecl */ nullptr,
ArrayRef<llvm::omp::TraitProperty>());
// A single match is returned for OpenMP 5.0
int BestIdx = getBestVariantMatchForContext(VMIs, OMPCtx);
int Idx = 0;
// In OpenMP 5.0 metadirective is either replaced by another directive or
// ignored.
// TODO: In OpenMP 5.1 generate multiple directives based upon the matches
// found by getBestWhenMatchForContext.
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
// OpenMP 5.0 implementation - Skip to the best index found.
if (Idx++ != BestIdx) {
ConsumeToken(); // Consume clause name
T.consumeOpen(); // Consume '('
int paren = 0;
// Skip everything inside the clause
while (Tok.isNot(tok::r_paren) || paren != 0) {
if (Tok.is(tok::l_paren))
paren++;
if (Tok.is(tok::r_paren))
paren--;
ConsumeAnyToken();
}
// Parse ')'
if (Tok.is(tok::r_paren))
T.consumeClose();
continue;
}
OpenMPClauseKind CKind = Tok.isAnnotation()
? OMPC_unknown
: getOpenMPClauseKind(PP.getSpelling(Tok));
SourceLocation Loc = ConsumeToken();
// Parse '('.
T.consumeOpen();
// Skip ContextSelectors for when clause
if (CKind == OMPC_when) {
OMPTraitInfo &TI = Actions.getASTContext().getNewOMPTraitInfo();
// parse and skip the ContextSelectors
parseOMPContextSelectors(Loc, TI);
// Parse ':'
ConsumeAnyToken();
}
// If no directive is passed, skip in OpenMP 5.0.
// TODO: Generate nothing directive from OpenMP 5.1.
if (Tok.is(tok::r_paren)) {
SkipUntil(tok::annot_pragma_openmp_end);
break;
}
// Parse Directive
Directive = ParseOpenMPDeclarativeOrExecutableDirective(
StmtCtx,
/*ReadDirectiveWithinMetadirective=*/true);
break;
}
break;
}
case OMPD_threadprivate: {
// FIXME: Should this be permitted in C++?
if ((StmtCtx & ParsedStmtContext::AllowStandaloneOpenMPDirectives) ==
ParsedStmtContext()) {
Diag(Tok, diag::err_omp_immediate_directive)
<< getOpenMPDirectiveName(DKind) << 0;
}
ConsumeToken();
DeclDirectiveListParserHelper Helper(this, DKind);
if (!ParseOpenMPSimpleVarList(DKind, Helper,
/*AllowScopeSpecifier=*/false)) {
skipUntilPragmaOpenMPEnd(DKind);
DeclGroupPtrTy Res = Actions.OpenMP().ActOnOpenMPThreadprivateDirective(
Loc, Helper.getIdentifiers());
Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
}
SkipUntil(tok::annot_pragma_openmp_end);
break;
}
case OMPD_allocate: {
// FIXME: Should this be permitted in C++?
if ((StmtCtx & ParsedStmtContext::AllowStandaloneOpenMPDirectives) ==
ParsedStmtContext()) {
Diag(Tok, diag::err_omp_immediate_directive)
<< getOpenMPDirectiveName(DKind) << 0;
}
ConsumeToken();
DeclDirectiveListParserHelper Helper(this, DKind);
if (!ParseOpenMPSimpleVarList(DKind, Helper,
/*AllowScopeSpecifier=*/false)) {
SmallVector<OMPClause *, 1> Clauses;
if (Tok.isNot(tok::annot_pragma_openmp_end)) {
llvm::SmallBitVector SeenClauses(llvm::omp::Clause_enumSize + 1);
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
OpenMPClauseKind CKind =
Tok.isAnnotation() ? OMPC_unknown
: getOpenMPClauseKind(PP.getSpelling(Tok));
Actions.OpenMP().StartOpenMPClause(CKind);
OMPClause *Clause = ParseOpenMPClause(OMPD_allocate, CKind,
!SeenClauses[unsigned(CKind)]);
SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,
StopBeforeMatch);
SeenClauses[unsigned(CKind)] = true;
if (Clause != nullptr)
Clauses.push_back(Clause);
if (Tok.is(tok::annot_pragma_openmp_end)) {
Actions.OpenMP().EndOpenMPClause();
break;
}
// Skip ',' if any.
if (Tok.is(tok::comma))
ConsumeToken();
Actions.OpenMP().EndOpenMPClause();
}
skipUntilPragmaOpenMPEnd(DKind);
}
DeclGroupPtrTy Res = Actions.OpenMP().ActOnOpenMPAllocateDirective(
Loc, Helper.getIdentifiers(), Clauses);
Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
}
SkipUntil(tok::annot_pragma_openmp_end);
break;
}
case OMPD_declare_reduction:
ConsumeToken();
if (DeclGroupPtrTy Res =
ParseOpenMPDeclareReductionDirective(/*AS=*/AS_none)) {
skipUntilPragmaOpenMPEnd(OMPD_declare_reduction);
ConsumeAnyToken();
Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
} else {
SkipUntil(tok::annot_pragma_openmp_end);
}
break;
case OMPD_declare_mapper: {
ConsumeToken();
if (DeclGroupPtrTy Res =
ParseOpenMPDeclareMapperDirective(/*AS=*/AS_none)) {
// Skip the last annot_pragma_openmp_end.
ConsumeAnnotationToken();
Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
} else {
SkipUntil(tok::annot_pragma_openmp_end);
}
break;
}
case OMPD_reverse:
case OMPD_interchange:
case OMPD_declare_target: {
SourceLocation DTLoc = ConsumeAnyToken();
bool HasClauses = Tok.isNot(tok::annot_pragma_openmp_end);
SemaOpenMP::DeclareTargetContextInfo DTCI(DKind, DTLoc);
if (HasClauses)
ParseOMPDeclareTargetClauses(DTCI);
bool HasImplicitMappings =
!HasClauses || (DTCI.ExplicitlyMapped.empty() && DTCI.Indirect);
if (HasImplicitMappings) {
Diag(Tok, diag::err_omp_unexpected_directive)
<< 1 << getOpenMPDirectiveName(DKind);
SkipUntil(tok::annot_pragma_openmp_end);
break;
}
// Skip the last annot_pragma_openmp_end.
ConsumeAnyToken();
Actions.OpenMP().ActOnFinishedOpenMPDeclareTargetContext(DTCI);
break;
}
case OMPD_declare_simd:
case OMPD_begin_declare_target:
case OMPD_end_declare_target:
case OMPD_requires:
case OMPD_begin_declare_variant:
case OMPD_end_declare_variant:
case OMPD_declare_variant:
Diag(Tok, diag::err_omp_unexpected_directive)
<< 1 << getOpenMPDirectiveName(DKind);
SkipUntil(tok::annot_pragma_openmp_end);
break;
case OMPD_unknown:
default:
Diag(Tok, diag::err_omp_unknown_directive);
SkipUntil(tok::annot_pragma_openmp_end);
break;
}
return Directive;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x888, %rsp # imm = 0x888
movl %edx, %r13d
movl %esi, %r15d
movq %rdi, %rbx
movb 0x3da(%rdi), %al
movb %al, 0x17(%rsp)
movb $0x1, 0x3da(%rdi)
movq %rdi, 0x30(%rsp)
movl 0x50(%rdi), %eax
movl %eax, 0x38(%rsp)
movzwl 0x54(%rdi), %eax
movw %ax, 0x3c(%rsp)
testl %edx, %edx
je 0x689c01
movl 0x10(%rbx), %ebp
jmp 0x689c0b
movq %rbx, %rdi
callq 0x62a7b4
movl %eax, %ebp
movq %rbx, %rdi
callq 0x688edf
movl %eax, %r12d
cmpl $0x63, %eax
setne %al
movl %r13d, %ecx
xorb $0x1, %cl
orb %al, %cl
pushq $0x1
popq %r14
jne 0x689c50
leaq 0x10(%rbx), %rdx
leaq 0x298(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x6ab, %ecx # imm = 0x6AB
callq 0x629b8c
movq %r15, %rdi
callq 0x4a3d6a
jmp 0x689c7f
cmpl $0x21, %r12d
je 0x689c68
movl %r12d, %edi
callq 0x10c2ed9
cmpl $0x4, %eax
je 0x689c68
cmpl $0x1, %eax
jne 0x689caa
movzbl %r13b, %r8d
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x689450
movq %rax, %r14
movb 0x17(%rsp), %bpl
leaq 0x30(%rsp), %rdi
callq 0x62cd6c
movb %bpl, 0x3da(%rbx)
movq %r14, %rax
addq $0x888, %rsp # imm = 0x888
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leal -0x6(%r12), %eax
cmpl $0x15, %eax
ja 0x689d26
leaq 0xb5cfc9(%rip), %rcx # 0x11e6c84
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rdx
leaq 0x2b8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x6a8, %ecx # imm = 0x6A8
callq 0x629b8c
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x52ea18
movl %r12d, %edi
callq 0x10c0803
leaq 0xe8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r15, %rdi
callq 0x4a3d52
movq %r15, %rdi
callq 0x4a3d6a
movq %rbx, %rdi
movl $0x1b8, %esi # imm = 0x1B8
xorl %edx, %edx
callq 0x62a81c
jmp 0x689c7f
movabsq $0x400000000, %rax # imm = 0x400000000
testl %r12d, %r12d
je 0x68a1b4
cmpl $0x25, %r12d
je 0x689dac
cmpl $0x2b, %r12d
je 0x689fd5
cmpl $0x61, %r12d
je 0x689f20
cmpl $0x3b, %r12d
je 0x689cc4
cmpl $0x3c, %r12d
je 0x689dac
cmpl $0x2c, %r12d
jne 0x689e8c
movq %rbx, %rdi
callq 0x62a14e
testb %r13b, %r13b
je 0x68a264
cmpw $0x17, 0x20(%rbx)
jne 0x68a264
movw $0x17, %ax
movb 0x17(%rsp), %bpl
cmpw $0x1b8, %ax # imm = 0x1B8
je 0x68a27c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x629ed2
movzwl 0x20(%rbx), %eax
jmp 0x689d92
movq %rbx, %rdi
xorl %esi, %esi
callq 0x629ed2
movzwl 0x20(%rbx), %ebp
leaq 0x2b8(%rsp), %rdi
movl %r12d, %esi
movl %eax, %edx
callq 0x6893f0
cmpw $0x1b8, %bp # imm = 0x1B8
jne 0x689e2f
leaq 0x10(%rbx), %rdx
leaq 0xe8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x6a8, %ecx # imm = 0x6A8
callq 0x629b8c
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x52ea18
movl %r12d, %edi
callq 0x10c0803
leaq 0x78(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r15, %rdi
callq 0x4a3d52
movq %r15, %rdi
callq 0x4a3d6a
movq %rbx, %rdi
movl $0x1b8, %esi # imm = 0x1B8
xorl %edx, %edx
callq 0x62a81c
jmp 0x689e75
leaq 0x2b8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6873ea
cmpl $0x0, 0x8(%r15)
jne 0x689e53
cmpb $0x1, 0x2e0(%rsp)
je 0x689dd3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x629ed2
movq 0x58(%rbx), %rax
movq 0x2f0(%rax), %rdi
leaq 0x2b8(%rsp), %rsi
callq 0xab1352
movb 0x17(%rsp), %bpl
leaq 0x2b8(%rsp), %rdi
callq 0x68d860
jmp 0x689c84
leaq 0x10(%rbx), %rdx
leaq 0x258(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x6ab, %ecx # imm = 0x6AB
callq 0x629b8c
jmp 0x689d0a
movq %rbx, %rdi
callq 0x62a14e
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6812f8
testq %rax, %rax
je 0x689d12
movq %rax, %r15
movq %rbx, %rdi
callq 0x62a7b4
jmp 0x689f0a
movq %rbx, %rdi
callq 0x62a14e
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6806ee
testq %rax, %rax
je 0x689d12
movq %rax, %r15
pushq $0xc
popq %rsi
movq %rbx, %rdi
callq 0x682742
movq %rbx, %rdi
xorl %esi, %esi
callq 0x629ed2
movq 0x58(%rbx), %rdi
movl 0x10(%rbx), %ecx
movq %r15, %rsi
movl %ebp, %edx
callq 0xb2856c
jmp 0x689c7c
movq %rax, %r12
testb $0x2, %r15b
jne 0x689f76
leaq 0x10(%rbx), %rdx
leaq 0x2b8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x699, %ecx # imm = 0x699
callq 0x629b8c
pushq $0x61
popq %rdi
callq 0x10c0803
leaq 0xe8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r14, %rdi
callq 0x4a3d52
movq %rax, %rdi
xorl %esi, %esi
callq 0x52ea18
movq %r14, %rdi
callq 0x4a3d6a
movq %rbx, %rdi
callq 0x62a14e
leaq 0x2c8(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r12, -0x8(%rax)
movq %rbx, 0x20(%rax)
movl $0x61, 0x28(%rax)
leaq 0x4ab2(%rip), %rax # 0x68ea52
leaq 0xe8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x2b8(%rsp), %rax
movq %rax, 0x8(%rdx)
pushq $0x61
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x687b7e
testb %al, %al
je 0x68a28c
pushq $0x1
popq %r14
jmp 0x68a2cc
movq %rbx, %rdi
movq %rax, %r14
callq 0x62a14e
leaq 0x2c8(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r14, -0x8(%rax)
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
callq 0x636694
movq 0x58(%rbx), %rax
movq 0x100(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x3d8(%rbx), %rax
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
movb 0x3d8(%rbx), %al
movb %al, 0x8(%rcx)
movb $0x1, 0x3d8(%rbx)
movq %rbx, 0x10(%rcx)
movl $0x170016, 0x18(%rcx) # imm = 0x170016
movw $0x1b8, 0x1c(%rcx) # imm = 0x1B8
leaq -0x5f870(%rip), %rax # 0x62a7d4
movq %rax, 0x20(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rcx)
leaq 0x10(%rbx), %r13
pushq $0x1
popq %r14
movq %r13, 0x18(%rsp)
cmpw $0x1b8, 0x20(%rbx) # imm = 0x1B8
je 0x68a320
movq %r13, %rdi
callq 0x54f570
pushq $0x5f
popq %r12
testb %al, %al
jne 0x68a0b3
movq 0x8(%rbx), %rsi
leaq 0xe8(%rsp), %rdi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x54f41e
movq 0xe8(%rsp), %rdi
movq 0xf0(%rsp), %rsi
callq 0x10c0820
movl %eax, %r12d
leaq 0xe8(%rsp), %rdi
callq 0x436d30
movq %rbx, %rdi
callq 0x62a14e
movl %r12d, %edi
callq 0x10c1141
leaq 0x40(%rsp), %rdi
movl $0x5ef, %esi # imm = 0x5EF
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x62fb90
testb %al, %al
jne 0x68a5f6
movq 0x58(%rbx), %rax
movq 0x100(%rax), %rdi
callq 0xdbb466
movq %rax, 0x20(%rsp)
xorl %r13d, %r13d
cmpl $0x67, %r12d
jne 0x68a130
movq %rbx, %rdi
movq 0x20(%rsp), %r13
movq %r13, %rdx
callq 0x68424a
cmpl $0x0, 0x8(%r13)
je 0x68a59e
xorl %r13d, %r13d
cmpw $0x3e, 0x20(%rbx)
jne 0x68a5b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x629ed2
movzwl 0x20(%rbx), %eax
cmpw $0x17, %ax
jne 0x68a18d
testl %r13d, %r13d
jne 0x68a18d
leaq 0x40(%rsp), %rdi
callq 0x62e642
leaq 0xe8(%rsp), %r12
movq %r12, %rdi
callq 0x689326
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %r12, %rdx
callq 0xf54e44
leaq 0x2b8(%rsp), %rdi
movq %r12, %rsi
callq 0x68a77c
movq %r12, %rdi
callq 0x6893c2
movq 0x18(%rsp), %r13
jmp 0x68a05c
cmpw $0x1b8, %ax # imm = 0x1B8
je 0x68a518
xorl %ecx, %ecx
cmpw $0x17, %ax
sete %cl
xorl %edx, %edx
cmpw $0x16, %ax
sete %dl
addl %edx, %r13d
subl %ecx, %r13d
jmp 0x68a126
movq %rax, %r12
testb $0x2, %r15b
jne 0x68a209
leaq 0x10(%rbx), %rdx
leaq 0x2b8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x699, %ecx # imm = 0x699
callq 0x629b8c
xorl %edi, %edi
callq 0x10c0803
leaq 0xe8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r14, %rdi
callq 0x4a3d52
movq %rax, %rdi
xorl %esi, %esi
callq 0x52ea18
movq %r14, %rdi
callq 0x4a3d6a
movq %rbx, %rdi
callq 0x62a14e
leaq 0x2c8(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r12, -0x8(%rax)
movq %rbx, 0x20(%rax)
andl $0x0, 0x28(%rax)
leaq 0x4822(%rip), %rax # 0x68ea52
leaq 0xe8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x2b8(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x687b7e
testb %al, %al
je 0x68a2f2
pushq $0x1
popq %r14
jmp 0x68a68d
pushq $0x2c
popq %rsi
movq %rbx, %rdi
callq 0x682742
cmpw $0x1b8, 0x20(%rbx) # imm = 0x1B8
movb 0x17(%rsp), %bpl
jne 0x68a284
movq %rbx, %rdi
callq 0x62a7b4
xorl %r14d, %r14d
jmp 0x689c84
pushq $0x61
popq %rsi
movq %rbx, %rdi
callq 0x682742
movq 0x58(%rbx), %rax
movq 0x2f0(%rax), %rdi
movq 0x2b8(%rsp), %rdx
movl 0x2c0(%rsp), %ecx
movl %ebp, %esi
callq 0xa84b26
movq 0x58(%rbx), %rdi
movl 0x10(%rbx), %ecx
movq %rax, %rsi
movl %ebp, %edx
callq 0xb2856c
movq %rax, %r14
movb 0x17(%rsp), %bpl
movq %rbx, %rdi
movl $0x1b8, %esi # imm = 0x1B8
xorl %edx, %edx
callq 0x62a81c
leaq 0x2b8(%rsp), %rdi
callq 0x633cd8
jmp 0x689c84
leaq 0x88(%rsp), %r8
movq %r8, -0x10(%r8)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x8(%r8)
cmpw $0x1b8, 0x20(%rbx) # imm = 0x1B8
jne 0x68a400
xorl %r9d, %r9d
jmp 0x68a649
leaq 0x78(%rsp), %rdi
callq 0x6366e0
leaq 0xc8(%rsp), %rdx
andq $0x0, 0x8(%rdx)
movq %rbx, (%rdx)
movl %ebp, 0x8(%rdx)
leaq 0x51b0(%rip), %rax # 0x68f4f4
movq %rax, 0x18(%rdx)
leaq 0x51eb(%rip), %rax # 0x68f53a
movq %rax, 0x10(%rdx)
xorl %r13d, %r13d
leaq 0xe8(%rsp), %r14
movq %r14, %rdi
movq 0x28(%rsp), %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xf55704
leaq 0x2b8(%rsp), %rdi
movq %r14, %rsi
callq 0x10c3aa8
movl %eax, 0x20(%rsp)
pushq $0x1
popq %r14
leaq 0x40(%rsp), %r12
cmpw $0x1b8, 0x20(%rbx) # imm = 0x1B8
je 0x68a563
cmpl 0x20(%rsp), %r13d
je 0x68a56d
incl %r13d
movq %rbx, %rdi
callq 0x62a14e
movq %r12, %rbp
movq %r12, %rdi
callq 0x62e5d8
xorl %r12d, %r12d
movzwl 0x20(%rbx), %eax
cmpw $0x17, %ax
jne 0x68a3cf
testl %r12d, %r12d
je 0x68a3f3
xorl %ecx, %ecx
cmpw $0x16, %ax
sete %cl
addl %ecx, %r12d
xorl %ecx, %ecx
cmpw $0x17, %ax
sete %cl
subl %ecx, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x629ed2
jmp 0x68a3c0
movq %rbp, %r12
movq %rbp, %rdi
callq 0x62e642
jmp 0x68a390
leaq 0x10(%rbx), %r14
leaq 0x40(%rsp), %rdi
pushq $0x6a
popq %rsi
xorl %edx, %edx
callq 0x689296
cmpw $0x1b8, 0x20(%rbx) # imm = 0x1B8
je 0x68a628
movq %r14, %rdi
callq 0x54f570
pushq $0x5f
popq %r13
testb %al, %al
jne 0x68a468
movq 0x8(%rbx), %rsi
leaq 0xe8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x54f41e
movq 0xe8(%rsp), %rdi
movq 0xf0(%rsp), %rsi
callq 0x10c0820
movl %eax, %r13d
movq %r15, %rdi
callq 0x436d30
movq 0x58(%rbx), %rax
movq 0x2f0(%rax), %rdi
movl %r13d, %esi
callq 0xa83022
leaq 0x40(%rsp), %r12
movq %r12, 0xe8(%rsp)
movl %r13d, 0xf0(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0x6892f4
xorb $0x1, %al
movzbl %al, %ecx
movq %rbx, %rdi
xorl %esi, %esi
movl %r13d, %edx
callq 0x68187c
movq %rax, %r15
movq %rbx, %rdi
pushq $0x42
popq %rsi
pushq $0x5
popq %rdx
movl $0x1b8, %ecx # imm = 0x1B8
pushq $0x2
popq %r8
callq 0x6320a8
movq %r12, %rdi
movl %r13d, %esi
callq 0x68d618
testq %r15, %r15
je 0x68a4e6
leaq 0x78(%rsp), %rdi
movq %r15, %rsi
callq 0x681f46
movzwl 0x20(%rbx), %eax
cmpl $0x42, %eax
je 0x68a4fb
cmpl $0x1b8, %eax # imm = 0x1B8
jne 0x68a503
jmp 0x68a618
movq %rbx, %rdi
callq 0x62a14e
movq 0x58(%rbx), %rax
movq 0x2f0(%rax), %rdi
callq 0xa8302e
jmp 0x68a413
leaq 0xe8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq 0x18(%rsp), %rdx
movl $0x695, %ecx # imm = 0x695
callq 0x629b8c
movl %r12d, %edi
callq 0x10c1141
leaq 0xc8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r15, %rdi
callq 0x4a3d52
movq %rax, %rdi
xorl %esi, %esi
callq 0x52ea18
jmp 0x68a5e4
movb 0x17(%rsp), %bpl
jmp 0x68a749
movq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0x54f570
testb %al, %al
je 0x68a6ae
movq %rbx, %rdi
callq 0x62a14e
leaq 0x40(%rsp), %rdi
callq 0x62e5d8
movb 0x17(%rsp), %bpl
jmp 0x68a720
leaq 0xe8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq 0x18(%rsp), %rdx
movl $0x691, %ecx # imm = 0x691
jmp 0x68a5d0
leaq 0xe8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq 0x18(%rsp), %rdx
movl $0x690, %ecx # imm = 0x690
callq 0x629b8c
leaq 0xb5c7cd(%rip), %rsi # 0x11e6da9
movq %r15, %rdi
callq 0x52f590
movq %r15, %rdi
callq 0x4a3d6a
leaq 0x78(%rsp), %rdi
callq 0x648fb4
movb 0x17(%rsp), %bpl
movb 0x48(%rsp), %al
movq 0x40(%rsp), %rcx
movb %al, (%rcx)
leaq 0x2b8(%rsp), %rdi
callq 0x68a7a2
jmp 0x689c84
movq 0x58(%rbx), %rax
movq 0x2f0(%rax), %rdi
callq 0xa8302e
movq %rbx, %rdi
xorl %esi, %esi
callq 0x682742
leaq 0x40(%rsp), %rdi
callq 0x689302
movq 0x78(%rsp), %r8
movl 0x80(%rsp), %r9d
movq 0x58(%rbx), %rax
movq 0x2f0(%rax), %rdi
movq 0x2b8(%rsp), %rdx
movl 0x2c0(%rsp), %ecx
andq $0x0, (%rsp)
movl %ebp, %esi
callq 0xa851d8
movq 0x58(%rbx), %rdi
movl 0x10(%rbx), %ecx
movq %rax, %rsi
movl %ebp, %edx
callq 0xb2856c
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0x68d8e4
movq %rbx, %rdi
movl $0x1b8, %esi # imm = 0x1B8
xorl %edx, %edx
callq 0x62a81c
leaq 0x2b8(%rsp), %rdi
callq 0x633cd8
jmp 0x689c7f
movq 0x8(%rbx), %rsi
leaq 0x278(%rsp), %r12
movq %r12, %rdi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x54f41e
movq (%r12), %rdi
movq 0x8(%r12), %rsi
callq 0x10c0820
movl %eax, %ebp
movq %r12, %rdi
callq 0x436d30
movq %rbx, %rdi
callq 0x62a14e
leaq 0x40(%rsp), %rdi
callq 0x62e5d8
cmpl $0x67, %ebp
movb 0x17(%rsp), %bpl
jne 0x68a720
movq 0x58(%rbx), %rax
movq 0x100(%rax), %rdi
callq 0xdbb466
movq %rbx, %rdi
movq %rax, %rdx
callq 0x68424a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x629ed2
cmpw $0x17, 0x20(%rbx)
jne 0x68a738
movq %rbx, %rdi
movl $0x1b8, %esi # imm = 0x1B8
xorl %edx, %edx
callq 0x62a81c
jmp 0x68a749
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x689bb8
movq %rax, %r14
leaq 0xe8(%rsp), %rdi
callq 0x689372
movq 0xd8(%rsp), %rax
testq %rax, %rax
je 0x68a5fb
leaq 0xc8(%rsp), %rdi
pushq $0x3
popq %rdx
movq %rdi, %rsi
callq *%rax
jmp 0x68a5fb
| /Parse/ParseOpenMP.cpp |
clang::TypeLocReader::VisitTypeOfExprTypeLoc(clang::TypeOfExprTypeLoc) | void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
TL.setTypeofLoc(readSourceLocation());
TL.setLParenLoc(readSourceLocation());
TL.setRParenLoc(readSourceLocation());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x6c8e48
movl %eax, (%rbx)
movq %r14, %rdi
callq 0x6c8e48
movl %eax, 0x4(%rbx)
movq %r14, %rdi
callq 0x6c8e48
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /Serialization/ASTReader.cpp |
clang::serialization::ModuleFile* const* llvm::SmallVectorTemplateCommon<clang::serialization::ModuleFile*, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<clang::serialization::ModuleFile*, true>>(llvm::SmallVectorTemplateBase<clang::serialization::ModuleFile*, true>*, clang::serialization::ModuleFile* const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | pushq %rbx
movq %rsi, %rbx
movl 0x8(%rdi), %esi
movl 0xc(%rdi), %eax
addq %rdx, %rsi
cmpq %rax, %rsi
ja 0x6df923
movq %rbx, %rax
popq %rbx
retq
callq 0x6df8cc
jmp 0x6df91e
| /llvm/ADT/SmallVector.h |
std::pair<llvm::DenseMapIterator<clang::NamedDecl*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::NamedDecl*, void>, llvm::detail::DenseSetPair<clang::NamedDecl*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<clang::NamedDecl*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::NamedDecl*, void>, llvm::detail::DenseSetPair<clang::NamedDecl*>>, clang::NamedDecl*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::NamedDecl*, void>, llvm::detail::DenseSetPair<clang::NamedDecl*>>::try_emplace<llvm::detail::DenseSetEmpty&>(clang::NamedDecl* const&, llvm::detail::DenseSetEmpty&) | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
false); // Already in map.
// Otherwise, insert the new element.
TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
true);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x6e1de4
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x6e1daa
xorl %ecx, %ecx
jmp 0x6e1dbd
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x6e1e04
movb $0x1, %cl
movl 0x10(%r14), %edx
shlq $0x3, %rdx
addq (%r14), %rdx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movb %cl, 0x10(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /llvm/ADT/DenseMap.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.