name string | code string | asm string | file string |
|---|---|---|---|
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;
... | 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 ... | /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 bel... | 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 %ra... | /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... | 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 0... | /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 usin... | 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, %r... | /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.s... | 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 %ea... | /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), ... | 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, 0... | /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 tru... | 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(%... | /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 appropri... | 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... | /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
... | /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) {
... | 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 ... | /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,
... | 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
mov... | /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 *=... | 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... | /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,
... | 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,... | /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,... | 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 %xm... | /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 Galact... | 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 ... | /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,
... | 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... | /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,
... | 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 ... | /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,... | 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... | /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,
... | 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... | /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... | 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(%r... | /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 ;
... | 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 0x3610... | /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)... | /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&, llv... | 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(%ri... | /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... | 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, %... | /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(B... | 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 0x4... | /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... | 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 %... | /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)... | /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 %r... | /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_bac... | 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
m... | /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 j... | 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, %r... | /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
... | 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 $... | /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_M... | 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... | /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 ... | /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 (%rd... | /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(%... | /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... | 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... | /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::Dens... | 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 + ... | 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(llv... | 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(%... | /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, %... | /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... | 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 ... | /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()->Attri... | 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(%r... | /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*, cla... | 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,%r... | /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,... | /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);
takeAllocationFor... | 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
mov... | /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
imul... | /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, ... | /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 0x4e7... | /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]... | 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, (%... | /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::Take... | 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 ... | /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, %rd... | /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) {
... | 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... | /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::Characteristic... | 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)
... | /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>, s... | 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 a... | 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 %ra... | /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**, s... | 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
ca... | /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::mo... | 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
mov... | /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_c... | 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 0x... | /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::Dens... | 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... | 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, %r1... | /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).getPre... | 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 ... | /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... | 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... | /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
m... | /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::Object... | 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->... | 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(... | /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::BitstreamEnt... | 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 $0x4000... | /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 ... | /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
re... | /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<FixItHi... | 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), %r... | /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... | 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 ... | 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,... | /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
m... | /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::S... | 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 %r... | /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... | /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
mo... | /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_... | 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:... | 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 ma... | 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 %r... | /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),... | /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::SmallVectorTempl... | 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::Take... | 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, %... | /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::Take... | 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, %... | /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::option... | 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... | /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,... | 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... | 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, %a... | /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.get32BitArch... | 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)... | /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);
... | 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 0x5100c... | /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, %r... | /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 declara... | 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 %r... | /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
... | /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.... | 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 %ec... | /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... | 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, ... | /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<Bu... | 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... | /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!");
ParsingOpenMPDirectiveRAI... | 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 ... | /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::Modul... | 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::Take... | 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::... | 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()
... | 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,... | /llvm/ADT/DenseMap.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.