name string | code string | asm string | file string | addresses string | bin string |
|---|---|---|---|---|---|
bool duckdb::BitpackingState<int, int>::Update<duckdb::EmptyBitpackingWriter>(int, bool) | bool Update(T value, bool is_valid) {
compression_buffer_validity[compression_buffer_idx] = is_valid;
all_valid = all_valid && is_valid;
all_invalid = all_invalid && !is_valid;
if (is_valid) {
compression_buffer[compression_buffer_idx] = value;
minimum = MinValue<T>(minimum, value);
maximum = MaxValue... | pushq %rbx
movq %rdi, %rbx
movq 0x4810(%rdi), %rax
movb %dl, 0x4010(%rdi,%rax)
andb %dl, 0x4844(%rdi)
xorb $0x1, %dl
andb %dl, 0x4845(%rdi)
testb %dl, %dl
jne 0xf888ff
movq 0x2008(%rbx), %rcx
movl %esi, (%rcx,%rax,4)
movl 0x4828(%rbx), %ecx
movl 0x482c(%rbx), %edx
cmpl %esi, %ecx
cmovgel %esi, %ecx
movl %ecx, 0x4828(%r... | /duckdb[P]duckdb/src/storage/compression/bitpacking.cpp | 0xf888ae | duckdb[P]duckdb[P]build_O1[P]tools[P]sqlite3_api_wrapper[P]libsqlite3_api_wrapper.so |
CheckNinjaVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void CheckNinjaVersion(const string& version) {
int bin_major, bin_minor;
ParseVersion(kNinjaVersion, &bin_major, &bin_minor);
int file_major, file_minor;
ParseVersion(version, &file_major, &file_minor);
if (bin_major > file_major) {
Warning("ninja executable version (%s) greater than build file "
... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x12de1(%rip), %rsi # 0x36478
leaq 0x18(%rsp), %r14
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0xd8e6
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x235c0
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x236d6
movq 0x2... | /Kitware[P]ninja/src/version.cc | 0x23686 | Kitware[P]ninja[P]build_O1[P]canon_perftest |
int baryonyx::itm::compute_order::run<baryonyx::itm::solver_inequalities_01coeff<float, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<float>, true>, baryonyx::bit_array, float>(baryonyx::itm::solver_inequalities_01coeff<float, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<float>, tru... | int run(Solver& solver,
Xtype& x,
random_engine& rng,
Float kappa,
Float delta,
Float theta)
{
bool pi_changed = false;
int remaining = 0;
switch (order) {
case solver_parameters::constraint_order::reversing:
so... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x30(%rdi), %eax
decl %eax
cmpl $0x6, %eax
ja 0x278fd8
leaq 0x27e7f1(%rip), %rdx # 0x4f7650
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
leaq 0x18(%rsp), %rdx
mov... | /quesnel[P]baryonyx/lib/src/itm-common.hpp | 0x278e34 | quesnel[P]baryonyx[P]build_O1[P]lib[P]testpreprocess |
void Diligent::FormatStrSS<std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>, char [43], unsigned int, char [22], unsigned int, char [3]>(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [43], unsigned int const&, char const (&) [22... | void FormatStrSS(SSType& ss, const FirstArgType& FirstArg, const RestArgsType&... RestArgs)
{
FormatStrSS(ss, FirstArg);
FormatStrSS(ss, RestArgs...); // recursive call using pack expansion syntax
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
leaq 0x10(%rdi), %rbx
movq %rsi, %rdi
callq 0x8ebd0
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x8ff60
movl (%r12), %esi
movq %rbx, %rdi... | /DiligentGraphics[P]DiligentCore/Primitives/interface/FormatString.hpp | 0x11f647 | DiligentGraphics[P]DiligentCore[P]build_O1[P]Graphics[P]GraphicsEngineVulkan[P]libGraphicsEngineVk.so |
bool llvm::DenseMapBase<llvm::DenseMap<void*, clang::ento::CheckerManager::EventInfo, llvm::DenseMapInfo<void*, void>, llvm::detail::DenseMapPair<void*, clang::ento::CheckerManager::EventInfo>>, void*, clang::ento::CheckerManager::EventInfo, llvm::DenseMapInfo<void*, void>, llvm::detail::DenseMapPair<void*, clang::ento... | 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... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8b6bf60
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x8a6b300
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x8b6bd32
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x77(%rs... | /llvm/ADT/DenseMap.h | 0x8b6bce0 | llvm-project[P]build_O0[P]bin[P]clang-19 |
google::operator<<(std::ostream&, google::Counter_t const&) | ostream& operator<<(ostream& os, const Counter_t&) {
#ifdef DISABLE_RTTI
LogMessage::LogStream* log = static_cast<LogMessage::LogStream*>(&os);
#else
auto* log = dynamic_cast<LogMessage::LogStream*>(&os);
#endif
CHECK(log && log == log->self())
<< "You must not use COUNTER with non-glog ostream";
os << lo... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x1329b
movq -0xa0(%rbp), %rdi
movq 0x5ed4e(%rip), %rsi # 0x71fd0
leaq 0x5e207(%rip), %rdx # 0x71490
xorl %eax, %eax
movl %eax, %ecx
callq 0x9840
movq %rax, -0... | /sergiud[P]glog/src/logging.cc | 0x13250 | sergiud[P]glog[P]build_O0[P]cleanup_with_absolute_prefix_unittest |
pagerAddPageToRollbackJournal | static SQLITE_NOINLINE int pagerAddPageToRollbackJournal(PgHdr *pPg){
Pager *pPager = pPg->pPager;
int rc;
u32 cksum;
char *pData2;
i64 iOff = pPager->journalOff;
/* We should never write to the journal file the page that
** contains the database locks. The following assert verifies
** that we do not.... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
call... | /xujihui1985[P]learingcpp/thirdparty/sqlite3.c | 0x32c30 | xujihui1985[P]learingcpp[P]build_O0[P]sqlite |
clang::RecursiveASTVisitor<(anonymous namespace)::DiagnoseUnguardedAvailability>::VisitOMPThreadLimitClause(clang::OMPThreadLimitClause*) | bool RecursiveASTVisitor<Derived>::VisitOMPThreadLimitClause(
OMPThreadLimitClause *C) {
TRY_TO(VisitOMPClauseWithPreInit(C));
TRY_TO(TraverseStmt(C->getThreadLimit()));
return true;
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x231ab30
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x20(%rsp)
je 0x24851bc
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq ... | /clang/AST/RecursiveASTVisitor.h | 0x2485170 | llvm-project[P]build_O0[P]bin[P]lldb-server |
llvm::detail::DoubleAPFloat::DoubleAPFloat(llvm::fltSemantics const&, unsigned long) | DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, integerPart I)
: Semantics(&S), Floats(new APFloat[2]{APFloat(semIEEEdouble, I),
APFloat(semIEEEdouble)}) {
assert(Semantics == &semPPCDoubleDouble);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, (%rdi)
movl $0x48, %edi
callq 0x11e3a0
movq %rax, %r15
movq $0x2, (%rax)
leaq 0x8(%rax), %r13
leaq 0x10(%rax), %rdi
leaq 0x1432981(%rip), %r12 # 0x1836f4c
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3fe5aa
addq $0x30, %r15
m... | /Support/APFloat.cpp | 0x404596 | llvm-project[P]build_O3[P]bin[P]sancov |
std::enable_if<is_hashable_data<char const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<char const>(char const*, char const*) | std::enable_if_t<is_hashable_data<ValueT>::value, hash_code>
hash_combine_range_impl(ValueT *first, ValueT *last) {
const uint64_t seed = get_execution_seed();
const char *s_begin = reinterpret_cast<const char *>(first);
const char *s_end = reinterpret_cast<const char *>(last);
const size_t length = std::distan... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r15
movabsq $-0xae502812aa7333, %rdx # imm = 0xFF51AFD7ED558CCD
movq %rsi, %rbx
subq %rdi, %rbx
cmpq $0x40, %rbx
ja 0x4aa126
movq %r15, %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4aa1e4... | /llvm/ADT/Hashing.h | 0x4aa0e8 | llvm-project[P]build_O3[P]bin[P]clang-installapi |
Variable_addTwoVariables_Test::~Variable_addTwoVariables_Test() | TEST(Variable, addTwoVariables)
{
const std::string in = "valid_name";
const std::string e =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\">\n"
" <component name=\"valid_name\">\n"
" <variable name=\"variable1\"/>\n"
... | pushq %rbx
movq %rdi, %rbx
callq 0xb640
pushq $0x10
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xb330
nop
| /cellml[P]libcellml/tests/variable/variable.cpp | 0x22db4 | cellml[P]libcellml[P]build_O2[P]tests[P]test_variable |
llvm::SmallPtrSetIterator<llvm::PHINode*>::operator++() | inline SmallPtrSetIterator& operator++() { // Preincrement
assert(isHandleInSync() && "invalid iterator access!");
if (shouldReverseIterate()) {
--Bucket;
RetreatIfNotValid();
return *this;
}
++Bucket;
AdvanceIfNotValid();
return *this;
} | pushq %rbx
movq %rdi, %rbx
addq $0x8, (%rdi)
callq 0x117e56c
movq %rbx, %rax
popq %rbx
retq
| /llvm/ADT/SmallPtrSet.h | 0x147957c | llvm-project[P]build_O2[P]bin[P]clang-19 |
testing::internal::XmlUnitTestResultPrinter::EscapeXml(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::string XmlUnitTestResultPrinter::EscapeXml(
const std::string& str, bool is_attribute) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '<':
m << "<";
break;
case '>':
m << ">";
break;
case '&'... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r12
movq %rdi, -0x48(%rbp)
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0xc73e
movq (%rbx), %rax
movq %rax, -0x40(%rbp)
addq $0x10, %rax
movq %rax, -0x38(%rbp)
xorl %ebx, %ebx
leaq -0x70... | /metacall[P]core/build_O2/source/tests/src/google-test-depends/googletest/src/gtest.cc | 0x12ca4 | metacall[P]core[P]build_O2[P]metacall-handle-export-test |
spirv_cross::AlignedBuffer<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 8ul>::data() | T *data()
{
#if defined(_MSC_VER) && _MSC_VER < 1900
// MSVC 2013 workarounds, sigh ...
// Only use this workaround on MSVC 2013 due to some confusion around default initialized unions.
// Spec seems to suggest the memory will be zero-initialized, which is *not* what we want.
return reinterpret_cast<T *>(u.ali... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| /3D4Medical[P]SPIRV-Cross/spirv_cross_containers.hpp | 0x1b63d0 | 3D4Medical[P]SPIRV-Cross[P]build_O0[P]spirv-cross |
spirv_cross::SPIRVariable* spirv_cross::ObjectPool<spirv_cross::SPIRVariable>::allocate<unsigned int&, spv::StorageClass, int, unsigned int&>(unsigned int&, spv::StorageClass&&, int&&, unsigned int&) | T *allocate(P &&... p)
{
if (vacants.empty())
{
unsigned num_objects = start_object_count << memory.size();
T *ptr = static_cast<T *>(malloc(num_objects * sizeof(T)));
if (!ptr)
return nullptr;
vacants.reserve(num_objects);
for (unsigned i = 0; i < num_objects; i++)
vacants.push_back(&ptr[i... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x8, %rdi
callq 0x210300
testb $0x1, %al
jne 0x2ee4e9
jmp 0x2ee594
movq -0x70(%rbp), %rdi
movl 0x80(%rdi), %ea... | /HansKristian-Work[P]dxil-spirv/third_party/SPIRV-Cross/spirv_cross_containers.hpp | 0x2ee4b0 | HansKristian-Work[P]dxil-spirv[P]build_O0[P]dxil-spirv |
wabt::WastParser::ParseModuleField(wabt::Module*) | Result WastParser::ParseModuleField(Module* module) {
WABT_TRACE(ParseModuleField);
switch (Peek(1)) {
case TokenType::Data: return ParseDataModuleField(module);
case TokenType::Elem: return ParseElemModuleField(module);
case TokenType::Except: return ParseExceptModuleField(module);
case TokenTy... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0xca3d32
addl $-0xb, %eax
cmpl $0x1a, %eax
ja 0xca6a2c
leaq 0x2782c6(%rip), %rcx # 0xf1ec44
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
j... | /chakra-core[P]ChakraCore/lib/wabt/src/wast-parser.cc | 0xca6956 | chakra-core[P]ChakraCore[P]build_O2[P]bin[P]ChakraCore[P]libChakraCore.so |
gguf_kv::gguf_kv(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&) | gguf_kv(const std::string & key, const std::string & value)
: key(key), is_array(false), type(GGUF_TYPE_STRING) {
GGML_ASSERT(!key.empty());
data_string.push_back(value);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
callq 0x16630
movb $0x0, 0x20(%r14)
movl $0x8, 0x24(%r14)
leaq 0x28(%r14), %rbp
leaq 0x40(%r14), %r1... | /ggerganov[P]ggml/src/gguf.cpp | 0x46846 | ggerganov[P]ggml[P]build_O3[P]src[P]libggml-base.so |
bool TestConstExpr::NotEqualTest<unsigned long long, long long>() | SAFEINT_CONSTEXPR11 bool NotEqualTest()
{
return
(U)2 != SafeInt<T>(3) &&
SafeInt<T>(4) != (U)5 &&
SafeInt<T>(6) != SafeInt<U>(7) &&
true != SafeInt<T>(1) &&
false != SafeInt<T>(0);
} | subq $0x68, %rsp
movl $0x3, 0x5c(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x1fe10
movq 0x60(%rsp), %rsi
movl $0x2, %edi
callq 0x1756d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0x1755dc
jmp 0x1756bc
movl $0x4, 0x4c(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x4c(%rsp), %rsi
callq 0x1fe1... | /dcleblanc[P]SafeInt/Test/ConstExpr.cpp | 0x1755a0 | dcleblanc[P]SafeInt[P]build_O0[P]Test[P]ClangTest[P]CompileTest_clang14_NoEH |
readChunk_cHRM(LodePNGInfo*, unsigned char const*, unsigned long) | static unsigned readChunk_cHRM(LodePNGInfo* info, const unsigned char* data, size_t chunkLength) {
if(chunkLength != 32) return 97; /*invalid cHRM chunk size*/
info->chrm_defined = 1;
info->chrm_white_x = 16777216u * data[ 0] + 65536u * data[ 1] + 256u * data[ 2] + data[ 3];
info->chrm_white_y = 16777216u * da... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x20, -0x20(%rbp)
je 0x2f2a3
movl $0x61, -0x4(%rbp)
jmp 0x2f47f
movq -0x10(%rbp), %rax
movl $0x1, 0xbc(%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
shl... | /AGraber[P]librw/src/lodepng/lodepng.cpp | 0x2f280 | AGraber[P]librw[P]build_O0[P]tools[P]dumprwtree[P]dumprwtree |
testing::internal::UnitTestImpl::UnitTestImpl(testing::UnitTest*) | UnitTestImpl::UnitTestImpl(UnitTest* parent)
: parent_(parent),
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
default_global_test_part_result_reporter_(this),
default_per_thread_test_part_result_reporter_(this),
GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_... | subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rdi
movq %rdi, 0xa0(%rsp)
leaq 0x8fed2(%rip), %rax # 0x162f50
movq %rax, (%rdi)
movq 0xc8(%rsp), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, 0x98(%rsp)
callq 0xdcb60
movq 0xa0(%rsp), %rsi
movq %rsi, %rdi
addq $0x30, %rdi
movq %... | /todo-group[P]exact/build_O0/_deps/googletest-src/googletest/src/gtest.cc | 0xd3050 | todo-group[P]exact[P]build_O0[P]ising[P]free_energy[P]square_finite_gt |
ncnn::binary_op_broadcast_outer(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, int, ncnn::Option const&) | static int binary_op_broadcast_outer(const Mat& a, const Mat& b, Mat& c, int op_type, const Option& opt)
{
using namespace BinaryOp_x86_functor;
if (op_type == BinaryOp::Operation_ADD) return binary_op_broadcast_outer<binary_op_add>(a, b, c, opt);
if (op_type == BinaryOp::Operation_SUB) return binary_op_br... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, 0x30(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
cmpl $0xb, %ecx
ja 0x2839df
movl %ecx, %eax
leaq 0x1dae37(%rip), %rcx # 0x45ca24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rsi
movl 0x2c(%... | /csukuangfj[P]ncnn/src/layer/x86/binaryop_x86.cpp | 0x281bbb | csukuangfj[P]ncnn[P]build_O3[P]examples[P]nanodet |
mbedtls_md5_starts | int mbedtls_md5_starts_ret( mbedtls_md5_context *ctx )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89;
ctx->state[2] = 0x98BADCFE;
ctx->state[3] = 0x10325476;
return( 0 );
} | movaps 0x401f(%rip), %xmm0 # 0x147a0
movups %xmm0, (%rdi)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%rdi)
retq
| /ARMmbed[P]mbed-crypto/library/md5.c | 0x1077a | ARMmbed[P]mbed-crypto[P]build_O1[P]tests[P]test_suite_dhm |
bsplib::Rdma::hpget(int, unsigned long, unsigned long, void*, unsigned long) | void Rdma::hpget( int src_pid, Memslot src_slot, size_t src_offset,
void * dst, size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::HPGET );
#endif
if ( size < m_min_n_hp_msg_size ) {
get( src_pid, src_slot, src_offset, dst, size );
return;
}
assert( !( slot( m_pid, src_slot ).sta... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x6, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1c0b0
movq -0xb0(%... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc | 0x28730 | wijnand-suijlen[P]bsponmpi[P]build_O0[P]test_move_payload_null_rma_prof |
pybind11::class_<pybind11::detail::iterator_state<__gnu_cxx::__normal_iterator<std::vector<long, std::allocator<long>>*, std::vector<std::vector<long, std::allocator<long>>, std::allocator<std::vector<long, std::allocator<long>>>>>, __gnu_cxx::__normal_iterator<std::vector<long, std::allocator<long>>*, std::vector<std:... | static void init_instance(detail::instance *inst, const void *holder_ptr) {
auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
if (!v_h.instance_registered()) {
register_instance(inst, v_h.value_ptr(), v_h.type);
v_h.set_instance_registered();
}
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10a71a(%rip), %rax # 0x197148
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
xorl %esi, %esi
callq 0x5c99b
leaq 0x10(%rsp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5e79a
movq %r15, %rdi
callq 0x... | /bioinfologics[P]sdg/deps/pybind11/pybind11.h | 0x8ca18 | bioinfologics[P]sdg[P]build_O2[P]SDGpython[P]SDGpython.so |
js_object_propertyIsEnumerable | static JSValue js_object_propertyIsEnumerable(JSContext *ctx, JSValueConst this_val,
int argc, JSValueConst *argv)
{
JSValue obj, res = JS_EXCEPTION;
JSAtom prop = JS_ATOM_NULL;
JSPropertyDescriptor desc;
int has_prop;
obj = JS_ToObject(ctx, this_val);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rdi, %rbx
callq 0x1d00e
movq %rax, %r14
movq %rdx, %r15
pushq $0x6
popq %r12
cmpl $0x6, %r15d
jne 0x52def
xorl %r13d, %r13d
jmp 0x52e35
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0x1a5c3
testl %eax,... | /jameslahm[P]quick-preact-ssr/quickjs/quickjs.c | 0x52dc1 | jameslahm[P]quick-preact-ssr[P]build_O2[P]qpreact-linux-x86_64 |
png_print_info | void png_print_info(png_t* png)
{
printf("PNG INFO:\n");
printf("\twidth:\t\t%d\n", png->width);
printf("\theight:\t\t%d\n", png->height);
printf("\tdepth:\t\t%d\n", png->depth);
printf("\tcolor:\t\t");
switch(png->color_type)
{
case PNG_GREYSCALE: printf("greyscale\n"); break;
case PNG_TRUECOLOR... | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3349d(%rip), %rsi # 0xe1350
movl $0x1, %edi
xorl %eax, %eax
callq 0x13ac0
movl 0x2c(%rbx), %edx
leaq 0x33492(%rip), %rsi # 0xe135b
movl $0x1, %edi
xorl %eax, %eax
callq 0x13ac0
movl 0x30(%rbx), %edx
leaq 0x33489(%rip), %rsi # 0xe1368
movl $0x1,... | /TsFreddie[P]teeworlds/src/engine/external/pnglite/pnglite.c | 0xadea1 | TsFreddie[P]teeworlds[P]build_O3[P]teeworlds |
fmt::v9::detail::counting_iterator fmt::v9::detail::write_codepoint<8ul, char, fmt::v9::detail::counting_iterator>(fmt::v9::detail::counting_iterator, char, unsigned int) | auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt {
*out++ = static_cast<Char>('\\');
*out++ = static_cast<Char>(prefix);
Char buf[width];
fill_n(buf, width, static_cast<Char>('0'));
format_uint<4>(buf, cp, width);
return copy_str<Char>(buf, buf + width, out);
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movabsq $0x3030303030303030, %rax # imm = 0x3030303030303030
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
pushq $0x8
popq %rax
movl %edx, %esi
movl %eax, %edx
xorl %ecx, %ecx
callq 0x220f4
addq $0xa, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h | 0x2a643 | njoy[P]ENDFtk[P]build_O2[P]src[P]ENDFtk[P]section[P]2[P]152[P]test[P]ENDFtk.section.2.152.test |
ncnn::HardSigmoid_x86_avx::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int HardSigmoid_x86_avx::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int d = bottom_top_blob.d;
int channels = bottom_top_blob.c;
int elempack = bottom_top_blob.elempack;
int size = w * h * d * elempack;
#pragma omp ... | movslq 0x38(%rsi), %rax
testq %rax, %rax
jle 0x3ab69b
movl 0x30(%rsi), %ecx
imull 0x2c(%rsi), %ecx
imull 0x34(%rsi), %ecx
imull 0x18(%rsi), %ecx
movl %ecx, %edx
andl $-0x8, %edx
xorl %r8d, %r8d
vbroadcastss 0x14490d(%rip), %ymm0 # 0x4efe98
vxorps %xmm1, %xmm1, %xmm1
vxorps %xmm2, %xmm2, %xmm2
vbroadcastss 0x1448fc(%rip... | /Tencent[P]ncnn/build_O1/src/layer/x86/hardsigmoid_x86_avx.cpp | 0x3ab55e | Tencent[P]ncnn[P]build_O1[P]examples[P]mobilenetssd |
ReleaseMutex | BOOL
PALAPI
ReleaseMutex( IN HANDLE hMutex )
{
PAL_ERROR palError = NO_ERROR;
CPalThread *pthr = NULL;
PERF_ENTRY(ReleaseMutex);
ENTRY("ReleaseMutex(hMutex=%p)\n", hMutex);
pthr = InternalGetCurrentThread();
palError = InternalReleaseMutex(pthr, hMutex);
if (NO_ERROR != palError)
{
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x126681f(%rip), %r14 # 0x14a8fa4
cmpb $0x0, (%r14)
je 0x2427d0
movq %rdi, %rbx
leaq 0x1267a1b(%rip), %rax # 0x14aa1b0
movl (%rax), %edi
callq 0x1d6110
testq %rax, %rax
jne 0x2427a6
callq 0x2337ec
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2427d5
movl %eax, %ebx
te... | /chakra-core[P]ChakraCore/pal/src/synchobj/mutex.cpp | 0x242777 | chakra-core[P]ChakraCore[P]build_O1[P]bin[P]ChakraCore[P]libChakraCore.so |
void mp::internal::NLReader<mp::internal::TextReader<fmt::Locale>, mp::internal::VarBoundHandler<ExprCounter>>::ReadColumnSizes<false>() | void NLReader<Reader, Handler>::ReadColumnSizes() {
int num_sizes = header_.num_vars - 1;
if (reader_.ReadUInt() != num_sizes)
reader_.ReportError("expected {}", num_sizes);
reader_.ReadTillEndOfLine();
typename Handler::ColumnSizeHandler size_handler = handler_.OnColumnSizes();
int prev_size = 0;
for (... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movl %ecx, 0x2c(%rsp)
movq (%rax), %rdi
callq 0x7f70
cmpl 0x2c(%rsp), %eax
je 0x8efe
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x7acc7(%rip),... | /ampl[P]mp/include/mp/nl-reader.h | 0x8ea0 | ampl[P]mp[P]build_O0[P]bin[P]nl-reader-example |
void capnp::_::checkList<capnp::Text, capnp::DynamicValue::Builder>(capnp::DynamicValue::Builder, std::initializer_list<capnp::ReaderFor_<capnp::Text, ::capnp::kind<capnp::Text>()>::Type>) | void checkList(T reader, std::initializer_list<ReaderFor<Element>> expected) {
auto list = reader.as<DynamicList>();
ASSERT_EQ(expected.size(), list.size());
for (uint i = 0; i < expected.size(); i++) {
expectPrimitiveEq(expected.begin()[i], list[i].as<Element>());
}
auto typed = reader.as<List<Element>>... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0xb0(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2ff794
movl 0x28(%r15), %eax
cmpq %rbx, %rax
jne 0x25afec
testq %rbx, %rbx
je 0x25afc1
movq %r12, 0x30(%rsp)
xorl %eax, %eax
le... | /Cosmic-Sans[P]capnproto/c++/src/capnp/test-util.h | 0x25ad89 | Cosmic-Sans[P]capnproto[P]build_O3[P]c++[P]src[P]capnp[P]capnp-heavy-tests |
printAddress | static void printAddress(MCInst *MI, unsigned Base, int64_t Disp, unsigned Index, SStream *O)
{
if (Disp >= 0) {
if (Disp > HEX_THRESHOLD)
SStream_concat(O, "0x%"PRIx64, Disp);
else
SStream_concat(O, "%"PRIu64, Disp);
} else {
if (Disp < -HEX_THRESHOLD)
SStream_concat(O, "-0x%"PRIx64, -Disp);
else
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x1310b8
cmpq $0x9, -0x18(%rbp)
jle 0x1310a0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x8ef7e(%rip), %rsi # 0x1c0015
movb $0... | /sidneyp[P]capstone-tricore/arch/SystemZ/SystemZInstPrinter.c | 0x131060 | sidneyp[P]capstone-tricore[P]build_O0[P]test_detail |
google::protobuf::UnknownField::SerializeLengthDelimitedNoTag(google::protobuf::io::CodedOutputStream*) const | void UnknownField::SerializeLengthDelimitedNoTag(
io::CodedOutputStream* output) const {
GOOGLE_DCHECK_EQ(TYPE_LENGTH_DELIMITED, type());
const string& data = *data_.length_delimited_.string_value_;
output->WriteVarint32(data.size());
output->WriteRawMaybeAliased(data.data(), data.size());
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5a73d0
movl %eax, %ecx
movb $0x0, -0x49(%rbp)
movl $0x3, %eax
cmpl %ecx, %eax
jne 0xa521e1
jmp 0xa5222a
leaq 0x77276(%rip), %rdx # 0xac945e
leaq -0x48(%rbp), %rdi
movq %rdi, ... | /1duo[P]coremltools/deps/protobuf/src/google/protobuf/unknown_field_set.cc | 0xa521b0 | 1duo[P]coremltools[P]build_O0[P]libcaffeconverter.so |
testing::AssertionResult& testing::AssertionResult::operator<<<char [106]>(char const (&) [106]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xac2a
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x74e0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x220ae
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1e6... | /metacall[P]core/build_O2/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h | 0x1e68a | metacall[P]core[P]build_O2[P]configuration-default-test[P]metacall-configuration-default-test |
roaring_bitmap_minimum | uint32_t roaring_bitmap_minimum(const roaring_bitmap_t *bm) {
if (bm->high_low_container.size > 0) {
container_t *c = bm->high_low_container.containers[0];
uint8_t type = bm->high_low_container.typecodes[0];
uint32_t key = bm->high_low_container.keys[0];
uint32_t lowvalue = container... | pushq %rbx
cmpl $0x0, (%rdi)
jle 0x13fe0
movq %rdi, %rax
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
movq (%rdx), %rdi
movq 0x18(%rax), %rax
movb (%rax), %al
cmpb $0x4, %al
jne 0x13fc3
movb 0x8(%rdi), %al
movq (%rdi), %rdi
movzwl (%rcx), %ebx
cmpb $0x3, %al
je 0x13fd2
movzbl %al, %eax
cmpl $0x2, %eax
jne 0x13fe5
cmpl $0... | /RoaringBitmap[P]CRoaring/src/roaring.c | 0x13f9f | RoaringBitmap[P]CRoaring[P]build_O2[P]tests[P]cpp_unit |
gmlc::networking::TcpAcceptor::TcpAcceptor(asio::io_context&, asio::ip::basic_endpoint<asio::ip::tcp>&) | TcpAcceptor::TcpAcceptor(asio::io_context& io_context, tcp::endpoint& ep) :
endpoint_(ep), acceptor_(io_context)
{
acceptor_.open(ep.protocol());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups (%rdx), %xmm0
movups 0xc(%rdx), %xmm1
movups %xmm0, 0x10(%rdi)
movups %xmm1, 0x1c(%rdi)
leaq 0x30(%rdi), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x27308c
l... | /GMLC-TDC[P]HELICS/ThirdParty/networking/gmlc/networking/TcpAcceptor.cpp | 0x2724a4 | GMLC-TDC[P]HELICS[P]build_O2[P]bin[P]helics_broker |
testing::AssertionResult testing::internal::CmpHelperOpFailure<unsigned int, unsigned long>(char const*, char const*, unsigned int const&, unsigned long const&, char const*) | AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
const T1& val1, const T2& val2,
const char* op) {
return AssertionFailure()
<< "Expected: (" << expr1 << ") " << op << " (" << expr2
<< "), actual: " << Form... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %r9, (%rsp)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x4566f
leaq 0x4cb76(%rip), %rsi # 0x6f423
movq %r12, %rdi
callq 0x175e4
leaq 0x10(%rsp), %rsi
movq %rax... | /nmoinvaz[P]zlib-ng/build_O3/_deps/googletest-src/googletest/include/gtest/gtest.h | 0x22877 | nmoinvaz[P]zlib-ng[P]build_O3[P]gtest_zlib |
main | int main(int argc, char *argv[])
{
fpstate fpvar;
if (argc <= 1) { fp_usage (); fp_hint (); exit (-1); }
fp_init (&fpvar);
fp_get_param (argc, argv, &fpvar);
if (fpvar.listonly) {
fp_list (argc, argv, fpvar);
} else {
fp_preflight (argc, argv, FPACK, &fpvar);
fp_loop (argc, argv, FPACK, fpvar);... | subq $0xd88, %rsp # imm = 0xD88
movl $0x0, 0xd84(%rsp)
movl %edi, 0xd80(%rsp)
movq %rsi, 0xd78(%rsp)
cmpl $0x1, 0xd80(%rsp)
jg 0xe1af
callq 0xe2a0
callq 0xe2d0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0x6150
leaq 0x6d0(%rsp), %rdi
callq 0x6aa0
movl 0xd80(%rsp), %edi
movq 0xd78(%rsp), %rsi
leaq 0... | /Helioviewer-Project[P]fits2img/support/cfitsio/cfitsio-4.6.2/utilities/fpack.c | 0xe170 | Helioviewer-Project[P]fits2img[P]build_O0[P]support[P]cfitsio[P]fpack |
flatbuffers::(anonymous namespace)::CamelToSnake(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string CamelToSnake(const std::string &input) {
std::string s;
for (size_t i = 0; i < input.length(); i++) {
if (i == 0) {
s += CharToLower(input[i]);
} else if (input[i] == '_') {
s += '_';
} else if (!islower(input[i])) {
// Prevent duplicate underscores for Upper_Snake_Case str... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5740
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x57a0
movq %rax, %rcx
movq -0x48(%... | /aardappel[P]flatbuffers/src/util.cpp | 0xb3b60 | aardappel[P]flatbuffers[P]build_O0[P]flatsamplebfbs |
fmt::v8::detail::thousands_sep_result<char> fmt::v8::detail::thousands_sep_impl<char>(fmt::v8::detail::locale_ref) | FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
auto grouping = facet.grouping();
auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
return {std::move(grouping), thousands_sep};
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x25d60
movq %r14, %rdi
callq 0x24920
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x25de0
movq (%r14), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, ... | /mrzv[P]henson/ext/fmt/include/fmt/format-inl.h | 0x2d331 | mrzv[P]henson[P]build_O2[P]examples[P]storage[P]storage |
testing::internal::HasGoogleTestFlagPrefix(char const*) | static bool HasGoogleTestFlagPrefix(const char* str) {
return (SkipPrefix("--", &str) ||
SkipPrefix("-", &str) ||
SkipPrefix("/", &str)) &&
!SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
(SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
SkipPrefix(GTEST_FLAG_PREFIX_DASH_, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x96329(%rip), %rdi # 0x118e69
leaq 0x10(%rsp), %rsi
callq 0x787e0
testb $0x1, %al
jne 0x82b83
leaq 0x96315(%rip), %rdi # 0x118e6a
leaq 0x10(%rsp), %rsi
callq 0x787e0
testb $0x1, %al
jne 0x82b83
leaq 0x95e44(%rip), %rdi # 0x1189ae
leaq 0x10(%rsp), %rsi
callq 0x787... | /rjenkins[P]stats-cpp/build_O0/_deps/googletest-src/googletest/src/gtest.cc | 0x82b30 | rjenkins[P]stats-cpp[P]build_O0[P]test[P]stats_cpp_tst |
save_column | void save_column(int symbol, int default_state)
{
register int i;
register int m;
register int n;
register Yshort *sp;
register Yshort *sp1;
register Yshort *sp2;
register int count;
register int symno;
m = goto_map[symbol];
n = goto_map[symbol + 1];
count = 0;
for (i =... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x16133(%rip), %rax # 0x2b1f8
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
leaq 0x1611f(%rip), %rax # 0x2b1f8
movq (%rax), %rax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %... | /ChrisDodd[P]btyacc/output.c | 0x150b0 | ChrisDodd[P]btyacc[P]build_O0[P]btyacc |
h264_print_ref_pic_list_modification | void h264_print_ref_pic_list_modification(struct h264_ref_pic_list_modification *list, char *which) {
static const char *const opnames[6] = { "pic_num sub", "pic_num add", "long term", "end", "view idx sub", "view idx add" };
static const char *const argnames[6] = { "abs_diff_pic_num_minus1", "abs_diff_pic_num_minus1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edx
leaq 0xc1f9(%rip), %rdi # 0x17260
xorl %eax, %eax
callq 0x3070
addq $0x4, %rbx
leaq 0xadeb(%rip), %r13 # 0x15e64
leaq 0xc209(%rip), %r14 # 0x17289
leaq 0x25ff9(%rip), %rbp # 0x31080
leaq 0xc... | /polachok[P]envytools/vstream/h264_print.c | 0xb050 | polachok[P]envytools[P]build_O2[P]vstream[P]deh264 |
sysbvm_simpleFunctionType_primitiveAnalyzeAndTypeCheckFunctionApplicationNode | static sysbvm_tuple_t sysbvm_simpleFunctionType_primitiveAnalyzeAndTypeCheckFunctionApplicationNode(sysbvm_context_t *context, sysbvm_tuple_t closure, size_t argumentCount, sysbvm_tuple_t *arguments)
{
(void)closure;
if(argumentCount != 3) sysbvm_error_argumentCountMismatch(3, argumentCount);
sysbvm_simple... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x3, -0x18(%rbp)
je 0x46030
movq -0x18(%rbp), %rsi
movl $0x3, %edi
callq 0x2bd50
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0... | /ronsaldo[P]sysmel/lib/sysbvm/interpreter.c | 0x46000 | ronsaldo[P]sysmel[P]build_O0[P]dist[P]TestSysbvm |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkSamplerReductionMode>, rapidjson::internal::IsGenericValue<VkSamplerReductionMode>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::Memo... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x28, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
leaq 0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
movslq %edx, %rdx
movq %rdx, (%rax)
testl %edx, %edx
movl $0x1f6, %edx ... | /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h | 0x71728 | ValveSoftware[P]Fossilize[P]build_O3[P]cli[P]fossilize-opt |
std::enable_if<(unsigned short)41 + (unsigned short)29 >= 64, void>::type (anonymous namespace)::pack_single_in64<(unsigned short)41, (unsigned short)29, 2199023255551ul>(unsigned long, unsigned int* restrict&) | pack_single_in64(
const uint64_t in, uint32_t *__restrict__ &out) {
*out |= in << SHL;
++out;
*out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
++out;
if (DELTA + SHL > 64) {
*out = (in & MASK) >> (64 - SHL);
}
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rdx
shlq $0x1d, %rdx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl (%rax), %ecx
orq %rdx, %rcx
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movabsq $0x1ffffffffff, %rax # imm = 0x1FFFFFFFFFF
andq -0x8(%rsp)... | /lemire[P]FastPFor/src/bitpacking.cpp | 0x12ed70 | lemire[P]FastPFor[P]build_O0[P]FastPFOR_unittest |
leveldb::Footer::DecodeFrom(leveldb::Slice*) | Status Footer::DecodeFrom(Slice* input) {
const char* magic_ptr = input->data() + kEncodedLength - 8;
const uint32_t magic_lo = DecodeFixed32(magic_ptr);
const uint32_t magic_hi = DecodeFixed32(magic_ptr + 4);
const uint64_t magic = ((static_cast<uint64_t>(magic_hi) << 32) |
(static_ca... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdx), %r13
movabsq $-0x24b88adb747f04a9, %rax # imm = 0xDB4775248B80FB57
cmpq %rax, 0x28(%r13)
jne 0x2a649
movq %rdx, %r14
movq %rsi, %r15
movq %rbx, %rdi
callq 0x2a4cc
cmpq $0x0, (%rbx)
jne 0x2a62c
addq $0x10, %r15
movq %rsp... | /walterzhaoJR[P]leveldb/table/format.cc | 0x2a5c8 | walterzhaoJR[P]leveldb[P]build_O1[P]recovery_test |
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allo... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0xb4240
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq ... | /ggerganov[P]llama/common/json.hpp | 0xb3f9e | ggerganov[P]llama[P]build_O3[P]bin[P]llama-mtmd-cli |
QUnit::UnitTest::evaluate(bool, bool, 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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char... | inline void UnitTest::evaluate(
bool compare, bool result,
std::string val1, std::string val2,
std::string str1, std::string str2,
const char * file, int line, const char * func) {
bool ok = result ? (val1 == val2) : (val1 != val2);
tests_ += 1;
errors_ +... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x18(%rsp)
movq %r8, %r14
movq %rcx, %r12
movl %edx, %ebp
movl %esi, 0x14(%rsp)
movq %rdi, %rbx
movq 0x8(%rcx), %rdx
movq 0x8(%r8), %rax
testl %ebp, %ebp
je 0x9c24
cmpq %rax, %rdx
jne 0x9c45
testq %rdx, %rdx
je 0x9c4a
movq (%r1... | /Hao-Lin[P]A1/Main/Qunit/headers/QUnit.h | 0x9bd8 | Hao-Lin[P]A1[P]build_O3[P]A1 |
testing::internal::EqFailure(char const*, char const*, 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&, bool) | AssertionResult EqFailure(const char* lhs_expression,
const char* rhs_expression,
const std::string& lhs_value,
const std::string& rhs_value,
bool ignoring_case) {
Message msg;
msg << "Expected equality of these ... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xc0(%rbp)
movb %r9b, %al
movq %rdi, %r9
movq %r9, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
leaq -0x38(%rbp), %rdi
mo... | /metacall[P]core/build_O0/source/tests/src/google-test-depends/googletest/src/gtest.cc | 0x15240 | metacall[P]core[P]build_O0[P]metacall-backtrace-plugin-test |
google::LogMessage::~LogMessage() | LogMessage::~LogMessage() {
Flush();
#ifdef GLOG_THREAD_LOCAL_STORAGE
if (data_ == static_cast<void*>(&thread_msg_data)) {
data_->~LogMessageData();
thread_data_available = true;
} else {
delete allocated_;
}
#else // !defined(GLOG_THREAD_LOCAL_STORAGE)
delete allocated_;
#endif // defined(GLOG... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xf6e0
jmp 0xf64b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
leaq -0x76e8(%rcx), %rcx
cmpq %rcx, %rax
jne 0xf69b
movq -0x... | /sergiud[P]glog/src/logging.cc | 0xf630 | sergiud[P]glog[P]build_O0[P]stacktrace_unittest |
fts5ExprNodeTest_AND | static int fts5ExprNodeTest_AND(
Fts5Expr *pExpr, /* Expression pPhrase belongs to */
Fts5ExprNode *pAnd /* FTS5_AND node to advance */
){
int iChild;
i64 iLast = pAnd->iRowid;
int rc = SQLITE_OK;
int bMatch;
assert( pAnd->bEof==0 );
do {
pAnd->bNomatch = 0;
bMatch =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rsi), %rbp
movl 0x28(%rsi), %eax
xorl %ecx, %ecx
movl $0x0, 0x8(%rbx)
testl %eax, %eax
jle 0xa7d4a
movl $0x1, %r13d
xorl %r14d, %r14d
movq %rbp, %r15
movq 0x30(%rbx,%r14,8), %r12
movq 0x18(%r12), %rax
cmpl $0x0, 0x18... | /4rterius[P]cgtfs/third_party/sqlite3/src/sqlite3.c | 0xa7c7e | 4rterius[P]cgtfs[P]build_O3[P]example_2 |
Memory::HeapBucketT<Memory::SmallFinalizableWithBarrierHeapBlockT<MediumAllocationBlockAttributes>>::StopAllocationBeforeSweep() | void
HeapBucketT<TBlockType>::StopAllocationBeforeSweep()
{
#if ENABLE_ALLOCATIONS_DURING_CONCURRENT_SWEEP
this->allocationsStartedDuringConcurrentSweep = false;
#if SUPPORT_WIN32_SLIST
this->lastKnownNextAllocableBlockHead = this->nextAllocableBlockHead;
#endif
#endif
Assert(!this->IsAllocationStopped());... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x130d64
testb %al, %al
je 0x130aa6
leaq 0x12e2b0(%rip), %rax # 0x25ed0c
incl (%rax)
callq 0xf72e6
movq %fs:0x0, %rax
addq 0x12c4ad(%rip), %rax # 0x25cf20
movq %rax, %r14
movl $0x1, (%rax)
leaq 0xcaee3(%rip), %rdi # 0x1fb966
leaq 0xcb309(%... | /chakra-core[P]ChakraCore/lib/Common/Memory/HeapBucket.cpp | 0x130a42 | chakra-core[P]ChakraCore[P]build_O1[P]bin[P]GCStress[P]GCStress |
std::enable_if<(unsigned short)41 + (unsigned short)29 >= 64, void>::type (anonymous namespace)::pack_single_in64<(unsigned short)41, (unsigned short)29, 2199023255551ul>(unsigned long, unsigned int* restrict&) | pack_single_in64(
const uint64_t in, uint32_t *__restrict__ &out) {
*out |= in << SHL;
++out;
*out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
++out;
if (DELTA + SHL > 64) {
*out = (in & MASK) >> (64 - SHL);
}
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rdx
shlq $0x1d, %rdx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl (%rax), %ecx
orq %rdx, %rcx
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movabsq $0x1ffffffffff, %rax # imm = 0x1FFFFFFFFFF
andq -0x8(%rsp)... | /lemire[P]FastPFor/src/bitpacking.cpp | 0x12ed70 | lemire[P]FastPFor[P]build_O0[P]FastPFOR_unittest |
std::enable_if<(unsigned short)41 + (unsigned short)29 >= 64, void>::type (anonymous namespace)::pack_single_in64<(unsigned short)41, (unsigned short)29, 2199023255551ul>(unsigned long, unsigned int* restrict&) | pack_single_in64(
const uint64_t in, uint32_t *__restrict__ &out) {
*out |= in << SHL;
++out;
*out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
++out;
if (DELTA + SHL > 64) {
*out = (in & MASK) >> (64 - SHL);
}
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rdx
shlq $0x1d, %rdx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl (%rax), %ecx
orq %rdx, %rcx
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movabsq $0x1ffffffffff, %rax # imm = 0x1FFFFFFFFFF
andq -0x8(%rsp)... | /lemire[P]FastPFor/src/bitpacking.cpp | 0x12ed70 | lemire[P]FastPFor[P]build_O0[P]FastPFOR_unittest |
llvm::createR600ControlFlowFinalizer() | FunctionPass *llvm::createR600ControlFlowFinalizer() {
return new R600ControlFlowFinalizer();
} | pushq %rax
movl $0x58, %edi
callq 0xfc59e0
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x7519876(%rip), %rdx # 0x87daa54
movq %rdx, 0x10(%rax)
movl $0x2, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rcx, 0x30(%rax)
leaq 0x70ae70d(%rip), %rdx # 0x836f908
movq %rdx, (%rax)
movq %rcx, 0x50(%rax)
movups %... | /Target/AMDGPU/R600ControlFlowFinalizer.cpp | 0x12c11c6 | llvm-project[P]build_O1[P]bin[P]clang-19 |
testing::Message::operator<<(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) | Message& Message::operator <<(const ::std::wstring& wstr) {
internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x6c78f
movq (%rsi), %r13
leaq 0x18(%rsp), %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
cmpl $0x0, (%r13,%rbp,4)
je 0x6c76e
leaq (,%rbp,4), %rsi
addq %r13, %rsi
movl %r15d, %edx
subl ... | /Tom1975[P]SugarConvDsk/googletest/googletest/src/gtest.cc | 0x6c6e2 | Tom1975[P]SugarConvDsk[P]build_O3[P]Tests[P]Tests |
add64 | static inline void add64( mbedtls_mpi_uint *dst, mbedtls_mpi_uint *src, mbedtls_mpi_uint *carry )
{
unsigned char i;
mbedtls_mpi_uint c = 0;
for( i = 0; i < 8 / sizeof( mbedtls_mpi_uint ); i++, dst++, src++ )
{
*dst += c; c = ( *dst < c );
*dst += *src; c += ( *dst < *src );
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movb $0x0, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpq $0x1, %rax
jae 0x349e3
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq ... | /ARMmbed[P]mbed-crypto/library/ecp_curves.c | 0x34940 | ARMmbed[P]mbed-crypto[P]build_O0[P]programs[P]test[P]benchmark |
Js::JavascriptOperators::UpdateNativeArrayProfileInfoToCreateVarArray(void*, bool, bool) | void JavascriptOperators::UpdateNativeArrayProfileInfoToCreateVarArray(Var instance, const bool expectingNativeFloatArray, const bool expectingVarArray)
{
Assert(instance);
Assert(expectingNativeFloatArray ^ expectingVarArray);
JavascriptNativeArray * nativeArr = JavascriptOperators::TryFro... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
testq %rdi, %rdi
jne 0x9acf96
leaq 0xae6375(%rip), %rax # 0x14932bc
incl (%rax)
callq 0x592f56
leaq 0xa9bfb2(%rip), %rdi # 0x1448f08
callq 0x1cf730
movq %rax, %r12
movl $0x1, (%rax)
leaq 0x66741... | /chakra-core[P]ChakraCore/lib/Runtime/Language/JavascriptOperators.cpp | 0x9acf28 | chakra-core[P]ChakraCore[P]build_O3[P]bin[P]ChakraCore[P]libChakraCore.so |
bool duckdb::IntegerCastLoop<duckdb::IntegerDecimalCastData<unsigned int>, true, true, duckdb::IntegerDecimalCastOperation, (char)46>(char const*, unsigned long, duckdb::IntegerDecimalCastData<unsigned int>&, bool) | static bool IntegerCastLoop(const char *buf, idx_t len, T &result, bool strict) {
idx_t start_pos;
if (NEGATIVE) {
start_pos = 1;
} else {
if (*buf == '+') {
if (strict) {
// leading plus is not allowed in strict mode
return false;
}
start_pos = 1;
} else {
start_pos = 0;
}
}
idx_t pos ... | subq $0x68, %rsp
movb %cl, %al
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
movq $0x1, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x1681d4e
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx),... | /duckdb[P]duckdb/src/include/duckdb/common/operator/integer_cast_operator.hpp | 0x1681960 | duckdb[P]duckdb[P]build_O0[P]duckdb |
void slang::ast::ASTVisitor<auto slang::ast::makeVisitor<SvTypeReflector::reflect()::$_3>(SvTypeReflector::reflect()::$_3)::Result, true, true, false, false>::visit<slang::ast::TimingPathSymbol>(slang::ast::TimingPathSymbol const&) | void visit(const T& t) {
if constexpr (!VisitBad && requires { t.bad(); }) {
if (t.bad())
return;
}
if constexpr (requires { (DERIVED).handle(t); })
(DERIVED).handle(t);
else if constexpr (requires { (DERIVED)(DERIVED, t); })
(DERIVED)... | pushq %rax
callq 0x24e076
testq %rax, %rax
je 0x7c68b
movq %rax, %rdi
callq 0x1aacf8
testq %rax, %rax
je 0x7c68b
movq %rax, %rdi
popq %rax
jmp 0x7ca12
popq %rax
retq
nop
| /MikePopoloski[P]slang/source/../include/slang/ast/ASTVisitor.h | 0x7c66a | MikePopoloski[P]slang[P]build_O1[P]bin[P]slang-reflect |
Assimp::IFC::Schema_2x3::IfcCostItem::~IfcCostItem() | IfcCostItem() : Object("IfcCostItem") {} | pushq %rbx
movq %rdi, %rbx
leaq 0x429771(%rip), %rax # 0x882a20
movq %rax, (%rdi)
leaq 0x4297df(%rip), %rax # 0x882a98
movq %rax, 0xf0(%rdi)
leaq 0x429781(%rip), %rax # 0x882a48
movq %rax, 0x88(%rdi)
leaq 0x42979b(%rip), %rax # 0x882a70
movq %rax, 0x98(%rdi)
movq 0xa8(%rdi), %rdi
leaq 0xb8(%rbx), %rax
cmpq ... | /hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen_2x3.h | 0x4592a4 | hbina[P]fatuous[P]build_O1[P]thirdparty[P]assimp[P]test[P]unit |
ShowDemoWindowWidgets()::Funcs::MyResizeCallback(ImGuiInputTextCallbackData*) | static int MyResizeCallback(ImGuiInputTextCallbackData* data)
{
if (data->EventFlag == ImGuiInputTextFlags_CallbackResize)
{
ImVector<char>* my_str = (ImVector<char>*)data->UserData;
IM_ASSERT(my_str->begin() == data... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x40000, (%rax) # imm = 0x40000
jne 0x803dc
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x24(%rax), %esi
callq 0x3dab0
movq 0x8(%rsp), %rdi
callq 0x44cf0
movq %rax, %rcx
movq 0x1... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui_demo.cpp | 0x80390 | ggerganov[P]imgui-ws[P]build_O0[P]bin[P]textures-null |
llvm::SmallVectorImpl<clang::FieldDecl*>::operator=(llvm::SmallVectorImpl<clang::FieldDecl*> const&) | SmallVectorImpl<T> &SmallVectorImpl<T>::
operator=(const SmallVectorImpl<T> &RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (C... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xc56d5c
movq %rsi, %r15
movl 0x8(%rsi), %r14d
movl 0x8(%rbx), %r12d
cmpl %r14d, %r12d
jae 0xc56cff
cmpl %r14d, 0xc(%rbx)
jae 0xc56d19
andl $0x0, 0x8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5c7286
jmp 0xc56d33
testl %r14d, %... | /llvm/ADT/SmallVector.h | 0xc56cc4 | llvm-project[P]build_O2[P]bin[P]lldb-server |
llvm::ResourceSegments::sortAndMerge() | void ResourceSegments::sortAndMerge() {
if (_Intervals.size() <= 1)
return;
// First sort the collection.
_Intervals.sort(sortIntervals);
// can use next because I have at least 2 elements in the list
auto next = std::next(std::begin(_Intervals));
auto E = std::end(_Intervals);
for (; next != E; ++n... | cmpq $0x2, 0x10(%rdi)
jb 0x2c00859
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x25c(%rip), %rsi # 0x2c00a68
callq 0x2c0085a
movq (%rbx), %rax
movq (%rax), %r15
cmpq %rbx, %r15
je 0x2c00854
movq 0x8(%r15), %rax
movq 0x18(%rax), %rax
cmpq 0x10(%r15), %rax
jl 0x2c0084f
movq 0x8(%r15), %r14
movq 0x10(%r14)... | /CodeGen/MachineScheduler.cpp | 0x2c007f6 | llvm-project[P]build_O1[P]bin[P]clangd |
helics::CommsBroker<helics::zeromq::ZmqComms, helics::CoreBroker>::CommsBroker(bool) | CommsBroker<COMMS, BrokerT>::CommsBroker(bool arg) noexcept: BrokerT(arg)
{
static_assert(std::is_base_of<CommsInterface, COMMS>::value,
"COMMS object must be a CommsInterface Object");
static_assert(std::is_base_of<BrokerBase, BrokerT>::value,
"Broker must be an object with... | pushq %rbx
movq %rdi, %rbx
callq 0x238fca
leaq 0x2833fa(%rip), %rax # 0x457638
leaq 0x10(%rax), %rcx
movq %rcx, (%rbx)
addq $0x168, %rax # imm = 0x168
movq %rax, 0x8(%rbx)
movl $0x0, 0xe70(%rbx)
movq $0x0, 0xe78(%rbx)
movb $0x0, 0xe80(%rbx)
movq %rbx, %rdi
callq 0x1d410c
popq %rbx
retq
movq %rax, %rdi
cal... | /GMLC-TDC[P]HELICS/src/helics/network/CommsBroker_impl.hpp | 0x1d422e | GMLC-TDC[P]HELICS[P]build_O3[P]bin[P]helics_broker |
jrtplib::RTCPCompoundPacketBuilder::RTCPCompoundPacketBuilder(jrtplib::RTPMemoryManager*) | RTCPCompoundPacketBuilder::RTCPCompoundPacketBuilder(RTPMemoryManager *mgr) : RTCPCompoundPacket(mgr), report(mgr), sdes(mgr)
{
byesize = 0;
appsize = 0;
#ifdef RTP_SUPPORT_RTCPUNKNOWN
unknownsize = 0;
#endif // RTP_SUPPORT_RTCPUNKNOWN
maximumpacketsize = 0;
buffer = 0;
external = false;
arebuilding = false;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2e3ca
leaq 0x1725a(%rip), %rax # 0x45858
movq %rax, (%rbx)
movq %r14, 0x70(%rbx)
leaq 0x17284(%rip), %rax # 0x45890
movq %rax, 0x68(%rbx)
leaq 0xa8(%rbx), %rax
movq %rax, 0xb0(%rbx)
movq %rax, 0xa8(%rbx)
andq $0x0, 0xb8(%rbx)
leaq 0x88(%rb... | /astronautlabs[P]rtp/src/rtcpcompoundpacketbuilder.cpp | 0x2e5e8 | astronautlabs[P]rtp[P]build_O2[P]examples[P]example5 |
std::vector<tinyusdz::value::color3h, std::allocator<tinyusdz::value::color3h>> tinyusdz::lerp<tinyusdz::value::color3h>(std::vector<tinyusdz::value::color3h, std::allocator<tinyusdz::value::color3h>> const&, std::vector<tinyusdz::value::color3h, std::allocator<tinyusdz::value::color3h>> const&, double) | inline std::vector<T> lerp(const std::vector<T> &a, const std::vector<T> &b,
const double t) {
std::vector<T> dst;
// Choose shorter one
size_t n = std::min(a.size(), b.size());
if (n == 0) {
return dst;
}
dst.resize(n);
if (a.size() != b.size()) {
return dst;
}
f... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
pushq $0x6
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
... | /syoyo[P]tinyusdz/src/value-eval-util.hh | 0x98c41 | syoyo[P]tinyusdz[P]build_O2[P]save_usda |
prepare_coeffs | static inline void prepare_coeffs(const InterpFilterParams *const filter_params,
const int subpel_q4,
__m256i *const coeffs /* [4] */) {
const int16_t *filter = av1_get_interp_filter_subpel_kernel(
filter_params, subpel_q4 & SUBPEL_MASK);
co... | pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x80, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
andl $0xf, %esi
callq 0x50aa60
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa... | /m-ab-s[P]aom/aom_dsp/x86/convolve_avx2.h | 0x505170 | m-ab-s[P]aom[P]build_O0[P]aomenc |
QJsonDocument::operator=(QJsonDocument const&) | QJsonDocument &QJsonDocument::operator =(const QJsonDocument &other)
{
if (this != &other) {
if (other.d) {
if (!d)
d = std::make_unique<QJsonDocumentPrivate>();
d->value = other.d->value;
} else {
d.reset();
}
}
return *this;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
cmpq %rsi, %rdi
je 0x1f4fa1
movq %rsi, %r14
cmpq $0x0, (%rsi)
je 0x1f4f97
cmpq $0x0, (%rbx)
jne 0x1f4f8a
movl $0x18, %edi
callq 0xd4930
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0... | /qt[P]qtbase/src/corelib/serialization/qjsondocument.cpp | 0x1f4f22 | qt[P]qtbase[P]build_O1[P]lib[P]libQt6Core.so.6.10.0 |
bool TestComparisonsF<Counter<unsigned short, 16u>>() | bool TestComparisonsF()
{
CounterT a = 2, b = 2, c = 3;
TEST_CHECK(a == b);
TEST_CHECK(b != c);
b = c;
TEST_CHECK(b == c);
TEST_CHECK(a != b);
for (unsigned sep = 0; sep < 3; ++sep)
{
a = CounterT::kMask - sep;
b = 0;
c = 1 + sep;
for (unsigned ii = 0; i... | movb $0x1, %al
retq
| /catid[P]counter/tests/CounterUnitTest.cpp | 0x18c4 | catid[P]counter[P]build_O2[P]counter_unit_test |
args::FlagBase::Match(char) | virtual FlagBase *Match(const char flag)
{
if (matcher.Match(flag))
{
if (extraError && matched)
{
#ifdef ARGS_NOEXCEPT
error = Error::Extra;
#else
std::ostringstream problem;
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movl %esi, %ebx
movq %rdi, %r14
addq $0x58, %rdi
leaq 0x28(%rsp), %rsi
movb %bl, (%rsi)
callq 0xc72a
testq %rax, %rax
je 0xc016
cmpb $0x1, 0x51(%r14)
jne 0xc00f
cmpb $0x1, 0x8(%r14)
je 0xc028
movb $0x1, 0x8(%r14)
jmp 0xc019
xorl %r14d, %r14d
mo... | /rilianx[P]IMRTsolver/main/args.hxx | 0xbfdc | rilianx[P]IMRTsolver[P]build_O3[P]IAS |
bool baryonyx::itm::solver_inequalities_01coeff<float, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<float>, false>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>(baryonyx::bit_ar... | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x10(%rdi), %rax
vmovss %xmm2, 0x14(%rsp)
vmovss %xmm1, 0x10(%rsp)
vmovss %xmm0, 0xc(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebp, %ebp
movq %rax, 0x28(%rsp)
cmpq 0x30(%rsp), %r14
je 0x21c3a4... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-01.cpp | 0x21c2c2 | quesnel[P]baryonyx[P]build_O2[P]lib[P]testsolver |
clipp::operator,(clipp::group, clipp::parameter) | inline group
operator , (group a, parameter b)
{
return !a.scoped() && !a.blocking() && !a.exclusive() && !a.repeatable()
&& !a.joinable() && (a.doc().empty() || a.doc() == b.doc())
? a.push_back(std::move(b))
: group{std::move(a), std::move(b)}.scoped(false);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x0, 0x42(%rsi)
jne 0x2c9aa
movq %r15, %rdi
callq 0x2fc34
testb %al, %al
jne 0x2c9aa
cmpb $0x0, 0x40(%r15)
jne 0x2c9aa
cmpb $0x0, 0x20(%r15)
jne 0x2c9aa
cmpb $0x0, 0x41(%r15)
jne ... | /dkolmakov[P]hm/thirdparty/clipp/./clipp.hpp | 0x2c944 | dkolmakov[P]hm[P]build_O1[P]src[P]hm-db |
cmake::RunCheckForUnusedVariables() | void cmake::RunCheckForUnusedVariables()
{
#ifdef CMAKE_BUILD_WITH_CMAKE
bool haveUnused = false;
std::ostringstream msg;
msg << "Manually-specified variables were not used by the project:";
for (std::map<std::string, bool>::const_iterator it =
this->UsedCliVariables.begin();
it != this->UsedCli... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x143fc0
leaq 0x292214(%rip), %rsi # 0x468582
movl $0x3a, %edx
movq %r14, %rdi
callq 0x1440d0
movq 0xe8(%rbx), %r14
leaq 0xd8(%rbx), %r13
cmpq %r13,... | /jdavidberger[P]CMake/Source/cmake.cxx | 0x1d6346 | jdavidberger[P]CMake[P]build_O3[P]bin[P]cmake |
cmPropertyDefinitionMap::DefineProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmProperty::ScopeType, char const*, char const*, bool) | void cmPropertyDefinitionMap::DefineProperty(const std::string& name,
cmProperty::ScopeType scope,
const char* ShortDescription,
const char* FullDescription,
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0x44f6d0
movq -0x50(%rbp), %rdi
movq ... | /havogt[P]cmakels/cmakels/external/cmake/Source/cmPropertyDefinitionMap.cxx | 0x44f580 | havogt[P]cmakels[P]build_O0[P]cmakels[P]external[P]cmake[P]bin[P]cmake |
QPDFPageDocumentHelper::addPageAt(QPDFPageObjectHelper, bool, QPDFPageObjectHelper) | void
QPDFPageDocumentHelper::addPageAt(
QPDFPageObjectHelper newpage, bool before, QPDFPageObjectHelper refpage)
{
this->qpdf.addPageAt(newpage.getObjectHandle(), before, refpage.getObjectHandle());
} | pushq %rbx
subq $0x20, %rsp
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0xd2547
movq 0x121a47(%rip), %rsi # 0x1f3f80
cmpb $0x0, (%rsi)
je 0xd2543
incl 0x8(%rax)
jmp 0xd2547
lock
incl 0x8(%rax)
movq 0x8(%rcx), %rax
movq %rax, (%rsp)
m... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageDocumentHelper.cc | 0xd2512 | jberkenbilt[P]qpdf[P]build_O1[P]libtests[P]concatenate |
llvm::SmallVectorImpl<clang::RISCV::PrototypeDescriptor>::insert(clang::RISCV::PrototypeDescriptor*, unsigned long, clang::RISCV::PrototypeDescriptor) | iterator insert(iterator I, size_type NumToInsert, ValueParamT Elt) {
// Convert iterator to elt# to avoid invalidating iterator when we reserve()
size_t InsertElt = I - this->begin();
if (I == this->end()) { // Important special case for empty vector.
append(NumToInsert, Elt);
return this->be... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdx, %r8
movq %rdi, %rbp
movq (%rdi), %r12
movq 0x8(%rdi), %rax
movq %rsi, %r13
subq %r12, %r13
leaq (%rax,%rax,2), %rcx
addq %r12, %rcx
cmpq %rsi, %rcx
je 0xe2f528
leaq (%rax,%r8), %rdx
movq %r12, %rcx
cmpq 0x10(%r... | /llvm/ADT/SmallVector.h | 0xe2f240 | llvm-project[P]build_O3[P]bin[P]clang-diff |
nlohmann::detail::binary_reader<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::iterator_... | bool get_ubjson_object()
{
std::pair<std::size_t, char_int_type> size_and_type;
if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
{
return false;
}
string_t key;
if (size_and_type.first != string_t::npos)
{
if (JSON_HEDLE... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsp, %rsi
movq $0x0, (%rsi)
movl $0x0, 0x8(%rsi)
callq 0x21ab10
testb %al, %al
je 0x5991a5
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%rsp), %rsi
movq 0x28(%rbx), %rdi
cmpq $-0x1... | /ornladios[P]ADIOS2/thirdparty/nlohmann_json/nlohmann_json_wrapper/single_include/nlohmann/json.hpp | 0x598f6a | ornladios[P]ADIOS2[P]build_O1[P]lib[P]libadios2_core.so.2.10.0 |
llvm::DIEHash::collectAttributes(llvm::DIE const&, llvm::DIEHash::DIEAttrs&) | void DIEHash::collectAttributes(const DIE &Die, DIEAttrs &Attrs) {
for (const auto &V : Die.values()) {
LLVM_DEBUG(dbgs() << "Attribute: "
<< dwarf::AttributeString(V.getAttribute())
<< " added.\n");
switch (V.getAttribute()) {
#define HANDLE_DIE_HASH_ATTR(NAME) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2aecc76
movq (%rax), %r14
andq $-0x8, %r14
jmp 0x2aecc79
xorl %r14d, %r14d
leaq 0x310(%rbx), %rax
movq %rax, 0x170(%rsp)
leaq 0x300(%rbx), %rax
movq %ra... | /CodeGen/AsmPrinter/DIEHash.cpp | 0x2aecc50 | llvm-project[P]build_O2[P]bin[P]clang-19 |
validation_layer::basic_leakChecker::ZEbasic_leakChecker::zeContextDestroyEpilogue(_ze_context_handle_t*, _ze_result_t) | ze_result_t basic_leakChecker::ZEbasic_leakChecker::zeContextDestroyEpilogue(ze_context_handle_t, ze_result_t result) {
if (result == ZE_RESULT_SUCCESS) {
countFunctionCall("zeContextDestroy");
}
return result;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
testl %edx, %edx
jne 0x92e4b
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x124de(%rip), %rsi # 0xa52e5
leaq 0x124e7(%rip), %rdx # 0xa52f5
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x271e0
addq $0x8, %r14
movq %r1... | /oneapi-src[P]level-zero/source/layers/validation/checkers/basic_leak/zel_basic_leak_checker.cpp | 0x92de2 | oneapi-src[P]level-zero[P]build_O3[P]lib[P]libze_validation_layer.so.1.22.0 |
File::copy(String const&, String const&, bool) | bool File::copy(const String& src, const String& destination, bool failIfExists)
{
#ifdef _WIN32
return CopyFile(src, destination, failIfExists) == TRUE;
#else
int fd = ::open(src, O_RDONLY);
if(fd == -1)
return false;
off64_t size = lseek(fd, 0, SEEK_END);
if(size < 0)
return false;
i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6350
movq %rax, %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x4350
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x16e2e
movb $0x0, -0x1(%rbp)
jm... | /craflin[P]dehprox/3rdparty/libnstd/src/File.cpp | 0x16df0 | craflin[P]dehprox[P]build_O0[P]src[P]dehprox |
DecodeVLDST3Instruction | static DecodeStatus DecodeVLDST3Instruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
unsigned align, load;
unsigned size = fieldFromInstruction_4(Insn, 6, 2);
if (size == 3) return MCDisassembler_Fail;
align = fieldFromInstruction_4(Insn, 4, 2);
if (align & 2) return MCDisassembler_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %edi
movl $0x6, %esi
movl $0x2, %edx
callq 0x48660
movl %eax, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jne 0x64b7b
movl $0x0, -0x4(%rbp)
jmp 0x64bf5
movl -0x14(%rbp), %edi
... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c | 0x64b40 | bughoho[P]capstone[P]build_O0[P]libcapstone.so |
BufferInputSource::~BufferInputSource() | BufferInputSource::~BufferInputSource()
{
if (this->own_memory) {
delete this->buf;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1cf904(%rip), %rax # 0x1eeb50
movq %rax, (%rdi)
cmpb $0x1, 0xa8(%rdi)
jne 0x1f279
movq 0xd0(%rbx), %r14
testq %r14, %r14
je 0x1f279
movq %r14, %rdi
callq 0x1ef14
movl $0x8, %esi
movq %r14, %rdi
callq 0x190e0
movq 0xb0(%rbx), %rdi
addq $0xc0, %rbx
cmpq %rbx, %rd... | /jberkenbilt[P]qpdf/libqpdf/BufferInputSource.cc | 0x1f23e | jberkenbilt[P]qpdf[P]build_O1[P]libtests[P]logger |
void google::protobuf::(anonymous namespace)::FlatAllocatorImpl<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, google::protobuf::SourceCodeInfo, google::protobuf::FileDescriptorTables, google::protobuf::FeatureSet, google::protobuf::MessageOptions, google::protobuf::FieldOptions, ... | void PlanArray(int array_size) {
// We can't call PlanArray after FinalizePlanning has been called.
ABSL_CHECK(!has_allocated());
if (std::is_trivially_destructible<U>::value) {
// Trivial types are aligned to 8 bytes.
static_assert(alignof(U) <= 8, "");
total_.template Get<char>() += Roun... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2138e0
xorb $-0x1, %al
xorb $-0x1, %al
movb $0x0, -0x21(%rbp)
testb $0x1, %al
jne 0x215e5a
jmp 0x215e97
leaq 0x44125b(%rip), %rsi # 0x6570bc
leaq 0x464ab3(%rip), %rcx # 0x67... | /protocolbuffers[P]protobuf/src/google/protobuf/descriptor.cc | 0x215e30 | protocolbuffers[P]protobuf[P]build_O0[P]test_plugin |
printLogicalImm64 | static void printLogicalImm64(MCInst *MI, unsigned OpNum, SStream *O)
{
int64_t Val = MCOperand_getImm(MCInst_getOperand(MI, OpNum));
Val = AArch64_AM_decodeLogicalImmediate(Val, 64);
switch(MI->flat_insn->id) {
default:
printInt64Bang(O, Val);
break;
case ARM64_INS_ORR:
case ARM64_INS_AND:
case ARM64... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x44d20
movq %rax, %rdi
callq 0x44e90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x40, %esi
callq 0xcdab0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax... | /bughoho[P]capstone/arch/AArch64/AArch64InstPrinter.c | 0xcc520 | bughoho[P]capstone[P]build_O0[P]test_x86 |
KDIS::PDU::Entity_State_PDU::operator==(KDIS::PDU::Entity_State_PDU const&) const | KBOOL Entity_State_PDU::operator == ( const Entity_State_PDU & Value ) const
{
if( Header::operator !=( Value ) ) return false;
if( m_EntityID != Value.m_EntityID ) return false;
if( m_ui8ForceID != Value.m_ui... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3c7cc
testb %al, %al
jne 0x35799
leaq 0x28(%r14), %rdi
leaq 0x28(%rbx), %rsi
callq 0x29414
testb %al, %al
jne 0x35799
movb 0x38(%r14), %al
cmpb 0x38(%rbx), %al
jne 0x35799
movb 0x39(%r14), %al
cmpb 0x39(%rbx), %al
jne 0x35799
leaq 0x40(%r14), %rdi... | /jarvisfriends[P]KDIS/KDIS/PDU/Entity_Info_Interaction/Entity_State_PDU.cpp | 0x3569e | jarvisfriends[P]KDIS[P]build_O1[P]Examples[P]PDU[P]Bundle[P]Example_Bundle |
testing::internal::ParameterizedTestSuiteInfo<bssl::(anonymous namespace)::SimplePathBuilderDelegate1024SuccessTest>::RegisterTests() | iterator begin() const { return iterator(impl_->Begin()); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
leaq 0x128(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r13
xorl %r14d, %r14d
movb %r14b, (%rax)
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %r14b, (%rax)
movq... | /jedisct1[P]boringssl/third_party/googletest/googletest/include/gtest/internal/gtest-param-util.h | 0x1ee61e | jedisct1[P]boringssl[P]build_O2[P]pki_test |
foreach_test_func(void*, void*) | static void foreach_test_func (ppointer data, ppointer user_data)
{
if (user_data == NULL)
return;
TestData *test_data = (TestData *) user_data;
if (test_data->index < 0 || test_data->index > 2)
return;
test_data->test_array[test_data->index] = P_POINTER_TO_INT (data);
++test_data->index;
} | testq %rsi, %rsi
je 0x19ff
movl 0xc(%rsi), %eax
cmpq $0x2, %rax
ja 0x19ff
movl %edi, (%rsi,%rax,4)
incl 0xc(%rsi)
retq
| /saprykin[P]plibsys/tests/plist_test.cpp | 0x19eb | saprykin[P]plibsys[P]build_O3[P]tests[P]plist_test |
aom_paeth_predictor_4x4_ssse3 | void aom_paeth_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t stride,
const uint8_t *above, const uint8_t *left) {
__m128i l = _mm_loadl_epi64((const __m128i *)left);
const __m128i t = _mm_loadl_epi64((const __m128i *)above);
const __m128i zero = _mm_setzero_si128();
const __m128... | subq $0x238, %rsp # imm = 0x238
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movq %rcx, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x108(%rsp), %rax
movq (%rax), %xmm0
movaps %xmm0, 0xf0(%rsp)
movaps 0xf0(%rsp), %xmm0
movaps %xmm0, 0xa0(%rsp)
movq 0xb8(%rsp), %rax
movq ... | /m-ab-s[P]aom/aom_dsp/x86/intrapred_ssse3.c | 0x3c6be0 | m-ab-s[P]aom[P]build_O0[P]examples[P]simple_encoder |
Fl::screen_dpi(float&, float&, int) | void Fl::screen_dpi(float &h, float &v, int n)
{
if (num_screens < 0) screen_init();
h = v = 0.0f;
#ifdef WIN32
if (n >= 0 && n < num_screens) {
h = float(dpi[n][0]);
v = float(dpi[n][1]);
}
#elif defined(__APPLE__)
if (n >= 0 && n < num_screens) {
h = dpi_h[n];
v = dpi_v[n];
}
#else
if (... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x9a12d(%rip) # 0x18d5d4
jns 0xf34ae
callq 0xf2e1e
andl $0x0, (%rbx)
andl $0x0, (%r14)
testl %ebp, %ebp
js 0xf34de
cmpl %ebp, 0x9a115(%rip) # 0x18d5d4
jle 0xf34de
movl %ebp, %eax
leaq 0xb1f76(%rip), %rcx # 0x1a5440
m... | /sidneydijkstra[P]SDEN/external/fltk-1.3.4-1/src/screen_xywh.cxx | 0xf3494 | meruiden[P]CS3D[P]build_O2[P]external[P]fltk-1.3.4-1[P]bin[P]fluid |
wasm::(anonymous namespace)::GlobalTypeOptimization::updateTypes(wasm::Module&)::TypeRewriter::~TypeRewriter() | void updateTypes(Module& wasm) {
class TypeRewriter : public GlobalTypeRewriter {
GlobalTypeOptimization& parent;
public:
TypeRewriter(Module& wasm, GlobalTypeOptimization& parent)
: GlobalTypeRewriter(wasm), parent(parent) {}
void modifyStruct(HeapType oldStructType, Struct& struct_... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x77c100
pushq $0x70
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x741cc0
nop
| /WebAssembly[P]binaryen/src/passes/GlobalTypeOptimization.cpp | 0x9092fa | WebAssembly[P]binaryen[P]build_O2[P]lib[P]libbinaryen.so |
bool baryonyx::itm::solver_inequalities_01coeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::push_and_compute_update_row<baryonyx::bit_array, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>>(baryonyx::bit_array&... | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rcx, -0x100(%rbp)
movq %rdx, -0xf8(%rbp)
fldt 0x40(%rbp)
fldt 0x30(%rbp)
fldt 0x20(%rbp)
fldt 0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
fstpt -0x30(%rbp)
fstpt -0x40(%rbp)
fstpt -0x50(... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-01.cpp | 0x73e300 | quesnel[P]baryonyx[P]build_O0[P]app[P]baryonyx-0.5 |
doctest::(anonymous namespace)::XmlReporter::test_case_skipped(doctest::TestCaseData const&) | void test_case_skipped(const TestCaseData& in) override {
if(opt.no_skipped_summary == false) {
test_case_start_impl(in);
xml.writeAttribute("skipped", "true");
xml.endElement();
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x78(%rdi), %rax
cmpb $0x0, 0x7f(%rax)
jne 0x1fe19
movq %rdi, %rbx
callq 0x20970
addq $0x8, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x371f2(%rip), %rsi # 0x56fc9
leaq 0x371f2(%rip), %rdx # 0x56fd0
movq %rsp, %r14
movq %r14, %rdi
callq 0x4edda... | /taskflow[P]taskflow/3rd-party/doctest/doctest.h | 0x1fda8 | taskflow[P]taskflow[P]build_O3[P]unittests[P]test_find |
fminnewt | int fminnewt(custom_function *funcpt, custom_gradient *funcgrad, int N, double *xi,
double delta,double *dx,double fsval,double maxstep, int method,double *xf) {
int retval;
int MAXITER,niter;
double eps,gtol,stol;
/*
* Method 1 - Newton Line Search
* Method 2 - Newton Trust Region - Hook Step
* Method... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
movsd %xmm2, -0x40(%rbp)
movl %r9d, -0x44(%rbp)
imull $0xc8, -0x14(%rbp), %eax
movl %eax, -... | /rafat[P]ctsa/src/optimc.c | 0x38810 | rafat[P]ctsa[P]build_O0[P]Bin[P]sarimatest3 |
measure_lincost | int measure_lincost( int pid, int nprocs, int repeat,
int msg_size, int total_size, int min_niters, int niters, int ncomms,
conf_interval_method_t conf_interval_method,
int * n_samples,
const char * sample_file_name,
double * alpha_msg, double * alpha_msg_min, double * alpha_msg... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq 0xa8(%rbp), %rax
movq 0xa0(%rbp), %rax
movq 0x98(%rbp), %rax
movq 0x90(%rbp), %rax
movq 0x88(%rbp), %rax
movq 0x80(%rbp), %rax
movq 0x78(%rbp), %rax
movq 0x70(%rbp), %rax
movq 0x68(%rbp), %rax
movq 0x60(%rbp), %rax
movq 0x5... | /wijnand-suijlen[P]bsponmpi/src/bompiprobe.c | 0x18590 | wijnand-suijlen[P]bsponmpi[P]build_O0[P]bompiprobe |
njoy::ENDFtk::section::Type<2, 151>::RMatrixLimited::ResonanceChannels::generateList(std::vector<unsigned int, std::allocator<unsigned int>>&&, std::vector<unsigned int, std::allocator<unsigned int>>&&, std::vector<double, std::allocator<double>>&&, std::vector<double, std::allocator<double>>&&, std::vector<double, std... | static std::vector< double >
generateList( std::vector< unsigned int >&& ppi,
std::vector< unsigned int >&& l,
std::vector< double >&& s,
std::vector< double >&& b,
std::vector< double >&& ape,
std::vector< double >&& apt ) {
unsigned int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x8(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, %rbp
movq 0x8(%rdx), %rbx
subq (%rdx), %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x2, %rbx
sarq $0x2, %rax
movl %ebx, %ecx
cmpq %rcx, %rax
... | /njoy[P]ENDFtk/src/ENDFtk/section/2/151/RMatrixLimited/ResonanceChannels/src/generateList.hpp | 0x416d4 | njoy[P]ENDFtk[P]build_O3[P]src[P]ENDFtk[P]section[P]2[P]151[P]RMatrixLimited[P]test[P]ENDFtk.section.2.151.RMatrixLimited.test |
google::protobuf::compiler::(anonymous namespace)::GetBootstrapParam(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool GetBootstrapParam(const std::string& parameter) {
std::vector<std::string> parts = absl::StrSplit(parameter, ',');
for (const auto& part : parts) {
if (part == "bootstrap") {
return true;
}
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xda9d50
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movl $0x2c, %ecx
callq 0xe70230
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xe70290
leaq -0x28(%rbp), %rax
movq %r... | /protocolbuffers[P]protobuf/src/google/protobuf/compiler/command_line_interface.cc | 0x149b7a0 | protocolbuffers[P]protobuf[P]build_O0[P]tests |
DecodeRUSBitpInstruction | static DecodeStatus DecodeRUSBitpInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2;
DecodeStatus S = Decode2OpInstruction(Insn, &Op1, &Op2);
if (S != MCDisassembler_Success)
return Decode2OpInstructionFail(Inst, Insn, Address, Decoder);
DecodeGRRegsRegisterClass(Inst... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movl %ebp, %edi
callq 0xc0379
cmpl $0x3, %eax
jne 0xbfd7d
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xbf957
movl 0x8(%rsp), %eax
cmpq $0xb, %rax
ja 0xbfd6f
leaq 0x... | /TriDis[P]capstone/arch/XCore/XCoreDisassembler.c | 0xbfd1e | TriDis[P]capstone[P]build_O3[P]test_x86 |
sarimax_wrapper | sarimax_wrapper_object sarimax_wrapper(sarimax_wrapper_object model,double *y, int N,int *order, int *seasonal, double *xreg, int r, int idrift,int mean,
double *lambda, int biasadj,int method) {
/*
Init here. { sarimax_object,drift}
*/
sarimax_wrapper_object obj = NULL;
int i, p,d,q,P,D,Q,s,ncoeff,drift,rr;
dou... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, -0x48(%rbp)
movq %r8, -0x40(%rbp)
movq %rcx, -0x58(%rbp)
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, %r15
movslq %edx, %rax
movq %rax, -0x70(%rbp)
leaq (,%rax,8), %rbx
movq %rbx, %rdi
callq 0x61e0
movq %rax, %r1... | /rafat[P]ctsa/src/ctsa.c | 0xbae5 | rafat[P]ctsa[P]build_O1[P]Bin[P]sarimatest2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.