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 |
End of preview. Expand in Data Studio
No dataset card yet
- Downloads last month
- 4