name string | code string | asm string | file string |
|---|---|---|---|
Coverage_entityHasParent_Test::TestBody() | TEST(Coverage, entityHasParent)
{
libcellml::ModelPtr m = libcellml::Model::create();
libcellml::ComponentPtr c1 = libcellml::Component::create();
libcellml::ComponentPtr c2 = libcellml::Component::create();
libcellml::ComponentPtr c3 = libcellml::Component::create();
libcellml::VariablePtr v = libc... | pushq %r14
pushq %rbx
subq $0x98, %rsp
leaq 0x88(%rsp), %rdi
callq 0xe120
leaq 0x58(%rsp), %rdi
callq 0xd9d0
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0xd9d0
leaq 0x78(%rsp), %rdi
callq 0xd9d0
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0xd550
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xded0
movq 0x58(%rsp), %rdi
leaq ... | /cellml[P]libcellml/tests/coverage/coverage.cpp |
Coverage_unitsItem_Test::TestBody() | TEST(Coverage, parserBranchesCMetaIdCellml2)
{
libcellml::ParserPtr parser = libcellml::Parser::create();
auto model = parser->parseModel(fileContents("coverage/cmeta_id_cellml2.xml"));
EXPECT_EQ(size_t(0), model->unitsCount());
EXPECT_EQ(size_t(0), model->componentCount());
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x14bc2(%rip), %rsi # 0x25e69
leaq 0x14bc0(%rip), %rdx # 0x25e6e
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x21b06
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0xd180
movq (%rbx), %rdi
cmpq %r14, %rdi
je 0x112dd
movq 0x20(... | /cellml[P]libcellml/tests/coverage/coverage.cpp |
CoverageValidator_invalidXmlIds_Test::TestBody() | TEST(CoverageValidator, invalidXmlIds)
{
auto parser = libcellml::Parser::create();
auto model = parser->parseModel(fileContents("coverage/invalidxmlids.cellml"));
auto validator = libcellml::Validator::create();
validator->validateModel(model);
EXPECT_EQ(size_t(1), validator->errorCount());
E... | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0xdd10
movq (%rbx), %rbx
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8d02(%rip), %rsi # 0x27edd
leaq 0x8d18(%rip), %rdx # 0x27efa
leaq 0x40(%rsp), %rdi
callq 0x21b06
leaq 0x20(%rsp), %rdi
leaq... | /cellml[P]libcellml/tests/coverage/coverage.cpp |
CoverageAnnotator_crossComponentConnectionAndMappingIds_Test::TestBody() | TEST(Coverage, parserBranchesCMetaIdCellml2)
{
libcellml::ParserPtr parser = libcellml::Parser::create();
auto model = parser->parseModel(fileContents("coverage/cmeta_id_cellml2.xml"));
EXPECT_EQ(size_t(0), model->unitsCount());
EXPECT_EQ(size_t(0), model->componentCount());
} | pushq %r14
pushq %rbx
subq $0xc8, %rsp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8556(%rip), %rsi # 0x28246
leaq 0x8554(%rip), %rdx # 0x2824b
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x21b06
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0xd4b0
movq (%rbx), %rdi
cmpq %r14, %rdi
je 0x1fd26
movq 0x18(%... | /cellml[P]libcellml/tests/coverage/coverage.cpp |
testing::Message::~Message() | class GTEST_API_ Message {
private:
// The type of basic IO manipulators (endl, ends, and flush) for
// narrow streams.
typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
public:
// Constructs an empty Message.
Message();
// Copy constructor.
Message(const Message& msg) : ss_(new ::std::strin... | pushq %rax
xorl %esi, %esi
callq 0x210b2
popq %rax
retq
movq %rax, %rdi
callq 0x20f97
| /cellml[P]libcellml/tests/gtest/include/gtest/gtest.h |
Coverage_importWithNonHrefXlink_Test::~Coverage_importWithNonHrefXlink_Test() | TEST(Coverage, importWithNonHrefXlink)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model name=\"\" xmlns=\"http://www.cellml.org/cellml/2.0#\">\n"
" <import xmlns:xlink=\"http://www.w3.org/1999/xlink\" xlink:href=\"some-other-model.xml\" xlink:type=\"simple\">\... | pushq %rbx
movq %rdi, %rbx
callq 0xe140
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xd850
nop
| /cellml[P]libcellml/tests/coverage/coverage.cpp |
Coverage_mathCnWithNamespaceViolations_Test::~Coverage_mathCnWithNamespaceViolations_Test() | TEST(Coverage, mathCnWithNamespaceViolations)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"myModel\">\n"
" <units name=\"a\">\n"
" <unit units=\"\"/>\n"
" </units>\n"
" <compo... | pushq %rbx
movq %rdi, %rbx
callq 0xe140
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xd850
nop
| /cellml[P]libcellml/tests/coverage/coverage.cpp |
Coverage_unitsItem_Test::~Coverage_unitsItem_Test() | TEST(Coverage, unitsItem)
{
auto units = libcellml::Units::create("units");
units->addUnit("second");
auto unitsItemValid = libcellml::UnitsItem::create(units, 0);
auto unitsItemInvalid = libcellml::UnitsItem::create(nullptr, 0);
EXPECT_TRUE(unitsItemValid->isValid());
EXPECT_FALSE(unitsItemIn... | pushq %rbx
movq %rdi, %rbx
callq 0xe140
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xd850
nop
| /cellml[P]libcellml/tests/coverage/coverage.cpp |
Coverage_cellMl20ImportInPermissiveMode_Test::~Coverage_cellMl20ImportInPermissiveMode_Test() | TEST(Coverage, cellMl20ImportInPermissiveMode)
{
auto parser = libcellml::Parser::create();
auto model = parser->parseModel(fileContents("importer/component_importer.cellml"));
auto importer = libcellml::Importer::create(false);
EXPECT_TRUE(model->hasUnresolvedImports());
importer->resolveImports(m... | pushq %rbx
movq %rdi, %rbx
callq 0xe140
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xd850
nop
| /cellml[P]libcellml/tests/coverage/coverage.cpp |
Coverage_sha1_Test::~Coverage_sha1_Test() | TEST(Coverage, sha1)
{
auto parser = libcellml::Parser::create();
auto model = parser->parseModel(fileContents("generator/algebraic_eqn_const_var_on_rhs/model.cellml"));
EXPECT_EQ(size_t(0), parser->issueCount());
auto analyser = libcellml::Analyser::create();
analyser->analyseModel(model);
... | pushq %rbx
movq %rdi, %rbx
callq 0xe140
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xd850
nop
| /cellml[P]libcellml/tests/coverage/coverage.cpp |
ImporterCoverage_importingComponentWithCnUnitsThatReferenceEmptyNamedUnits_Test::~ImporterCoverage_importingComponentWithCnUnitsThatReferenceEmptyNamedUnits_Test() | TEST(ImporterCoverage, importingComponentWithCnUnitsThatReferenceEmptyNamedUnits)
{
const std::vector<std::string> expectedIssuesModel = {
"Imported component 'c' is not valid because:\n"
" -> Component 'c' importing 'myComponent' from 'not_required_resolving_import_manually' has an error:\n"
... | pushq %rbx
movq %rdi, %rbx
callq 0xe140
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xd850
nop
| /cellml[P]libcellml/tests/coverage/coverage.cpp |
Coverage_analyserExternalVariable_Test::~Coverage_analyserExternalVariable_Test() | TEST(Coverage, analyserExternalVariable)
{
auto externalVariable = libcellml::AnalyserExternalVariable::create(nullptr);
EXPECT_EQ(nullptr, externalVariable->variable());
EXPECT_EQ(false, externalVariable->addDependency(nullptr));
auto parser = libcellml::Parser::create();
auto model = parser->par... | pushq %rbx
movq %rdi, %rbx
callq 0xe140
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xd850
nop
| /cellml[P]libcellml/tests/coverage/coverage.cpp |
Coverage_generator_Test::~Coverage_generator_Test() | TEST(Coverage, generator)
{
static const std::string EMPTY_STRING;
auto parser = libcellml::Parser::create();
auto model = parser->parseModel(fileContents("coverage/generator/model.cellml"));
EXPECT_EQ(size_t(0), parser->issueCount());
auto analyser = libcellml::Analyser::create();
analyser-... | pushq %rbx
movq %rdi, %rbx
callq 0xe140
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xd850
nop
| /cellml[P]libcellml/tests/coverage/coverage.cpp |
CoverageValidator_invalidXmlIds_Test::~CoverageValidator_invalidXmlIds_Test() | TEST(CoverageValidator, invalidXmlIds)
{
auto parser = libcellml::Parser::create();
auto model = parser->parseModel(fileContents("coverage/invalidxmlids.cellml"));
auto validator = libcellml::Validator::create();
validator->validateModel(model);
EXPECT_EQ(size_t(1), validator->errorCount());
E... | pushq %rbx
movq %rdi, %rbx
callq 0xe140
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xd850
nop
| /cellml[P]libcellml/tests/coverage/coverage.cpp |
CoverageAnnotator_crossComponentConnectionAndMappingIds_Test::~CoverageAnnotator_crossComponentConnectionAndMappingIds_Test() | TEST(CoverageAnnotator, crossComponentConnectionAndMappingIds)
{
auto model = libcellml::Model::create("model");
auto component1 = libcellml::Component::create("component1");
auto component2 = libcellml::Component::create("component2");
auto component3 = libcellml::Component::create("component3");
... | pushq %rbx
movq %rdi, %rbx
callq 0xe140
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xd850
nop
| /cellml[P]libcellml/tests/coverage/coverage.cpp |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [1], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [1], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x21e43
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x21f6e
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %... | /cellml[P]libcellml/tests/gtest/include/gtest/gtest.h |
ext_loader_print_info | const char *ext_loader_print_info(void)
{
static const char ext_loader_info[] =
"Extension Loader Plugin " METACALL_VERSION "\n"
"Copyright (C) 2016 - 2025 Vicente Eduardo Ferrer Garcia <vic798@gmail.com>\n"
#ifdef FILE_LOADER_STATIC_DEFINE
"Compiled as static library type\n"
#else
"Compiled as shared library... | leaq 0x29d5(%rip), %rax # 0x6000
retq
| /metacall[P]core/source/loaders/ext_loader/source/ext_loader.c |
ext_loader_impl_initialize_types(loader_impl_type*) | int ext_loader_impl_initialize_types(loader_impl impl)
{
for (type_id index = 0; index < TYPE_SIZE; ++index)
{
type t = type_create(index, type_id_name(index), NULL, NULL);
if (t != NULL)
{
if (loader_impl_type_define(impl, type_name(t), t) != 0)
{
type_destroy(t);
return 1;
}
}
}
return ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
cmpl $0x13, %ebx
je 0x367e
movl %ebx, %edi
callq 0x3290
movl %ebx, %edi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3470
testq %rax, %rax
je 0x3672
movq %rax, %r15
movq %rax, %rdi
callq 0x33f0
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
ca... | /metacall[P]core/source/loaders/ext_loader/source/ext_loader_impl.cpp |
ext_loader_impl_initialize | loader_impl_data ext_loader_impl_initialize(loader_impl impl, configuration config)
{
loader_impl_ext ext_impl = new loader_impl_ext_type();
(void)impl;
(void)config;
if (ext_impl == nullptr)
{
return NULL;
}
if (ext_loader_impl_initialize_types(impl) != 0)
{
delete ext_impl;
return NULL;
}
/* Regi... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x60
popq %rdi
callq 0x3310
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movq %rax, %rdi
callq 0x40d8
movq %r14, %rdi
callq 0x36... | /metacall[P]core/source/loaders/ext_loader/source/ext_loader_impl.cpp |
ext_loader_impl_execution_path | int ext_loader_impl_execution_path(loader_impl impl, const loader_path path)
{
loader_impl_ext ext_impl = static_cast<loader_impl_ext>(loader_impl_get(impl));
ext_impl->paths.insert(fs::path(path));
return 0;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsp, %rbx
movq %rsi, (%rbx)
callq 0x3280
movq %rax, %r14
leaq 0x8(%rsp), %r15
pushq $0x2
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3390
movq %r14, %rdi
movq %r15, %rsi
callq 0x3420
leaq 0x8(%rsp), %rdi
callq 0x3300
xorl %eax, %eax
addq $0x30, %rsp
popq %rb... | /metacall[P]core/source/loaders/ext_loader/source/ext_loader_impl.cpp |
ext_loader_impl_load_from_file | loader_handle ext_loader_impl_load_from_file(loader_impl impl, const loader_path paths[], size_t size)
{
loader_impl_ext ext_impl = static_cast<loader_impl_ext>(loader_impl_get(impl));
if (ext_impl == NULL)
{
return NULL;
}
loader_impl_ext_handle ext_handle = new loader_impl_ext_handle_type();
if (ext_handle... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x3280
testq %rax, %rax
je 0x37ac
movq %rax, %r15
pushq $0x18
popq %rdi
callq 0x3310
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
incq %rbx
decq %rbx
je 0x37af
leaq 0x1000(%r14), %r13
movq %r15,... | /metacall[P]core/source/loaders/ext_loader/source/ext_loader_impl.cpp |
ext_loader_impl_clear | int ext_loader_impl_clear(loader_impl impl, loader_handle handle)
{
loader_impl_ext ext_impl = static_cast<loader_impl_ext>(loader_impl_get(impl));
if (ext_impl == NULL)
{
return 1;
}
loader_impl_ext_handle ext_handle = static_cast<loader_impl_ext_handle>(handle);
if (ext_handle != NULL)
{
for (size_t i =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x3280
movq %rax, %r14
testq %rax, %rax
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
je 0x3d8b
pushq $0x1
popq %rax
jmp 0x3e2f
addq $0x30, %r14
leaq 0x238b(%rip), %rbp # 0x6121
xorl %r12d, %r12d
xorl %r13d, %r13d
... | /metacall[P]core/source/loaders/ext_loader/source/ext_loader_impl.cpp |
ext_loader_impl_discover | int ext_loader_impl_discover(loader_impl impl, loader_handle handle, context ctx)
{
loader_impl_ext_handle ext_handle = static_cast<loader_impl_ext_handle>(handle);
(void)ctx; /* We have opted by pass the handle instead of the context of the handle */
for (auto ext : ext_handle->extensions)
{
loader_impl_functi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq 0x8(%rsi), %r13
leaq 0x8(%rsp), %r15
movq %rax, %r12
cmpq %r13, %rax
je 0x3e9c
movq %r15, %rdi
movq %r12, %rsi
callq 0x4236
movq 0x30(%rsp), %rbp
movq %r14, %rdi
movq %rbx, %rsi
call... | /metacall[P]core/source/loaders/ext_loader/source/ext_loader_impl.cpp |
ext_loader_impl_destroy | int ext_loader_impl_destroy(loader_impl impl)
{
loader_impl_ext ext_impl = static_cast<loader_impl_ext>(loader_impl_get(impl));
if (ext_impl != NULL)
{
/* Destroy children loaders */
loader_unload_children(impl);
/* Destroy all handles */
if (!ext_impl->destroy_list.empty())
{
for (auto iterator : ext... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0x3280
testq %rax, %rax
je 0x3f9c
movq %rax, %r14
movq %rbx, %rdi
callq 0x3440
movq %r14, (%rsp)
cmpq $0x0, 0x58(%r14)
je 0x3f81
movq (%rsp), %r12
movq 0x48(%r12), %r15
addq $0x38, %r12
leaq 0x8(%rsp), %r14
leaq 0x2... | /metacall[P]core/source/loaders/ext_loader/source/ext_loader_impl.cpp |
ext_loader_impl_destroy_handle(loader_impl_ext_handle_type*) | void ext_loader_impl_destroy_handle(loader_impl_ext_handle ext_handle)
{
for (auto ext : ext_handle->extensions)
{
if (ext.handle != NULL)
{
dynlink_unload(ext.handle);
}
}
delete ext_handle;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r12
leaq 0x8(%rsp), %r15
cmpq %r12, %r14
je 0x400a
movq %r15, %rdi
movq %r14, %rsi
callq 0x4236
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3ffc
callq 0x3330
movq %r15, %rdi
callq 0x3150
addq $0x30, %r14
jmp ... | /metacall[P]core/source/loaders/ext_loader/source/ext_loader_impl.cpp |
ext_loader_impl_load_from_file_dynlink(char const*, char const*) | dynlink ext_loader_impl_load_from_file_dynlink(const char *path, const char *library_name)
{
/* This function will try to check if the library exists before loading it,
so we avoid error messages from dynlink when guessing the file path for relative load from file */
dynlink_name_impl platform_name;
dynlink_platfo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1038, %rsp # imm = 0x1038
movq %rsi, %rbx
movq %rsp, %r14
movq %rdi, (%r14)
leaq 0x30(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x33c0
leaq 0x8(%rsp), %r12
pushq $0x2
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x3390
movq %r12, %rdi
movq %r15, %... | /metacall[P]core/source/loaders/ext_loader/source/ext_loader_impl.cpp |
main | int main(int argc, char** argv){
auto args {get_args(argc, argv)};
if (args.size() == 2){
std::string str {args[1]};
auto compressed {compress_string(str)};
std::cout << "compressing " << str << " as " << compressed << '\n';
}
return 0;
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movslq %edi, %rax
leaq (%rsi,%rax,8), %rdx
leaq 0x50(%rsp), %rbx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x2616
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
cmpq $0x40, %rcx
jne 0x25b1
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x20(%rax), %rsi
movq 0x28(%rax)... | /luizalbertocviana[P]cracking-coding-problems/ch1/q6.cpp |
(anonymous namespace)::MurmurHash64A(void const*, unsigned long) | inline
uint64_t MurmurHash64A(const void* key, size_t len) {
static const uint64_t seed = 0xDECAFBADDECAFBADull;
const uint64_t m = BIG_CONSTANT(0xc6a4a7935bd1e995);
const int r = 47;
uint64_t h = seed ^ (len * m);
const unsigned char* data = (const unsigned char*)key;
while (len >= 8) {
uint64_t k;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movabsq $-0x395b586ca42e166b, %rax # imm = 0xC6A4A7935BD1E995
movq %rax, -0x18(%rbp)
movl $0x2f, -0x1c(%rbp)
movabsq $-0x395b586ca42e166b, %rax # imm = 0xC6A4A7935BD1E995
imulq -0x10(%rbp), %rax
movabsq $-0x2135045221350453, %rcx # imm = 0xDECAFBAD... | /adityavs[P]ninja/src/build_log.cc |
BuildLog::OpenForWrite(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BuildLogUser const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool BuildLog::OpenForWrite(const string& path, const BuildLogUser& user,
string* err) {
if (needs_recompaction_) {
if (!Recompact(path, user, err))
return false;
}
assert(!log_file_);
log_file_path_ = path; // we don't actually open the file right now, but will
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x60(%rax)
je 0x93c7
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x9420
... | /adityavs[P]ninja/src/build_log.cc |
BuildLog::Recompact(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BuildLogUser const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool BuildLog::Recompact(const string& path, const BuildLogUser& user,
string* err) {
METRIC_RECORD(".ninja_log recompact");
Close();
string temp_path = path + ".recompact";
FILE* f = fopen(temp_path.c_str(), "wb");
if (!f) {
*err = strerror(errno);
return false;
}
if (f... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
cmpb $0x0, 0x64103(%rip) # 0x6d550
jne 0x9540
leaq 0x640f6(%rip), %rdi # 0x6d550
callq 0x5940
cmpl $0x0,... | /adityavs[P]ninja/src/build_log.cc |
BuildLog::RecordCommand(Edge*, int, int, long) | bool BuildLog::RecordCommand(Edge* edge, int start_time, int end_time,
TimeStamp mtime) {
string command = edge->EvaluateCommand(true);
uint64_t command_hash = LogEntry::HashCommand(command);
for (vector<Node*>::iterator out = edge->outputs_.begin();
out != edge->outputs_.end()... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
movl $0x1, %edx
callq... | /adityavs[P]ninja/src/build_log.cc |
BuildLog::OpenForWriteIfNeeded() | bool BuildLog::OpenForWriteIfNeeded() {
if (log_file_path_.empty()) {
return true;
}
log_file_ = fopen(log_file_path_.c_str(), "ab");
if (!log_file_) {
return false;
}
if (setvbuf(log_file_, NULL, _IOLBF, BUFSIZ) != 0) {
return false;
}
SetCloseOnExec(fileno(log_file_));
// Opening a file... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x40, %rdi
callq 0x58c0
testb $0x1, %al
jne 0x9d23
jmp 0x9d2c
movb $0x1, -0x1(%rbp)
jmp 0x9dff
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x51c0
movq %rax, %rdi
leaq 0x41595(%rip), %rsi # 0x4b2d... | /adityavs[P]ninja/src/build_log.cc |
BuildLog::WriteEntry(_IO_FILE*, BuildLog::LogEntry const&) | bool BuildLog::WriteEntry(FILE* f, const LogEntry& entry) {
return fprintf(f, "%d\t%d\t%" PRId64 "\t%s\t%" PRIx64 "\n",
entry.start_time, entry.end_time, entry.mtime,
entry.output.c_str(), entry.command_hash) > 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
mov... | /adityavs[P]ninja/src/build_log.cc |
MurmurHash2(void const*, unsigned long) | static inline
unsigned int MurmurHash2(const void* key, size_t len) {
static const unsigned int seed = 0xDECAFBAD;
const unsigned int m = 0x5bd1e995;
const int r = 24;
unsigned int h = seed ^ len;
const unsigned char* data = (const unsigned char*)key;
while (len >= 4) {
unsigned int k;
memcpy(&k, da... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x5bd1e995, -0x14(%rbp) # imm = 0x5BD1E995
movl $0x18, -0x18(%rbp)
movabsq $0xdecafbad, %rax # imm = 0xDECAFBAD
xorq -0x10(%rbp), %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x4, -0x10(%rbp)
jb 0xad90
... | /adityavs[P]ninja/src/hash_map.h |
BuildStatus::BuildEdgeStarted(Edge const*) | void BuildStatus::BuildEdgeStarted(const Edge* edge) {
assert(running_edges_.find(edge) == running_edges_.end());
int start_time = (int)(GetTimeMillis() - start_time_millis_);
running_edges_.insert(make_pair(edge, start_time));
++started_edges_;
if (edge->use_console() || printer_.is_smart_terminal())
Pr... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x13290
movq -0x60(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x20, %rdi
callq 0x132c0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x2... | /adityavs[P]ninja/src/build.cc |
BuildStatus::PrintStatus(Edge const*, BuildStatus::EdgeStatus) | void BuildStatus::PrintStatus(const Edge* edge, EdgeStatus status) {
if (config_.verbosity == BuildConfig::QUIET)
return;
bool force_full_command = config_.verbosity == BuildConfig::VERBOSE;
string to_print = edge->GetBinding("description");
if (to_print.empty() || force_full_command)
to_print = edge-... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0xde0e
jmp 0xe052
movq -0x120(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
subl $0x2, %eax
se... | /adityavs[P]ninja/src/build.cc |
BuildStatus::BuildEdgeFinished(Edge*, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int*, int*) | void BuildStatus::BuildEdgeFinished(Edge* edge,
bool success,
const string& output,
int* start_time,
int* end_time) {
int64_t now = GetTimeMillis();
++finished_edges_;
... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
callq 0x3c280
movq -0x1c0(%rbp), %rdi
mov... | /adityavs[P]ninja/src/build.cc |
BuildStatus::BuildLoadDyndeps() | void BuildStatus::BuildLoadDyndeps() {
// The DependencyScan calls EXPLAIN() to print lines explaining why
// it considers a portion of the graph to be out of date. Normally
// this is done before the build starts, but our caller is about to
// load a dyndep file during the build. Doing so may generate more
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x5ef8d(%rip), %rax # 0x6d598
testb $0x1, (%rax)
je 0xe694
movq -0x48(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5910
movq -0x50(%rbp), %... | /adityavs[P]ninja/src/build.cc |
BuildStatus::FormatProgressStatus[abi:cxx11](char const*, BuildStatus::EdgeStatus) const | string BuildStatus::FormatProgressStatus(
const char* progress_status_format, EdgeStatus status) const {
string out;
char buf[32];
int percent;
for (const char* s = progress_status_format; *s != '\0'; ++s) {
if (*s == '%') {
++s;
switch (*s) {
case '%':
out.push_back('%');
... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5710
movq -0x18(%rbp... | /adityavs[P]ninja/src/build.cc |
Plan::AddSubTarget(Node const*, Node const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::set<Edge*, std::less<Edge*>, std::allocator<Edge*>>*) | bool Plan::AddSubTarget(const Node* node, const Node* dependent, string* err,
set<Edge*>* dyndep_walk) {
Edge* edge = node->in_edge();
if (!edge) { // Leaf node.
if (node->dirty()) {
string referenced;
if (dependent)
referenced = ", needed by '" + dependent->path() +... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1a8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13840
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x... | /adityavs[P]ninja/src/build.cc |
Plan::ScheduleWork(std::_Rb_tree_iterator<std::pair<Edge* const, Plan::Want>>) | void Plan::ScheduleWork(map<Edge*, Want>::iterator want_e) {
if (want_e->second == kWantToFinish) {
// This edge has already been scheduled. We can get here again if an edge
// and one of its dependencies share an order-only input, or if a node
// duplicates an out edge (see https://github.com/ninja-buil... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x13910
cmpl $0x2, 0x8(%rax)
jne 0xf17c
jmp 0xf22d
leaq -0x8(%rbp), %rdi
callq 0x13910
cmpl $0x1, 0x8(%rax)
jne 0xf18d
jmp 0xf1ac
leaq 0x3c522(%rip), %rdi ... | /adityavs[P]ninja/src/build.cc |
Plan::FindWork() | Edge* Plan::FindWork() {
if (ready_.empty())
return NULL;
set<Edge*>::iterator e = ready_.begin();
Edge* edge = *e;
ready_.erase(e);
return edge;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x30, %rdi
callq 0x13980
testb $0x1, %al
jne 0xf263
jmp 0xf26d
movq $0x0, -0x8(%rbp)
jmp 0xf2b3
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0x139a0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq... | /adityavs[P]ninja/src/build.cc |
Plan::EdgeFinished(Edge*, Plan::EdgeResult, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool Plan::EdgeFinished(Edge* edge, EdgeResult result, string* err) {
map<Edge*, Want>::iterator e = want_.find(edge);
assert(e != want_.end());
bool directly_wanted = e->second != kWantNothing;
// See if this job frees up any delayed jobs.
if (directly_wanted)
edge->pool()->EdgeFinished(*edge);
edge->... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x13a70
movq -0x68(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x13ad0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), ... | /adityavs[P]ninja/src/build.cc |
Plan::NodeFinished(Node*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool Plan::NodeFinished(Node* node, string* err) {
// If this node provides dyndep info, load it now.
if (node->dyndep_pending()) {
assert(builder_ && "dyndep requires Plan to have a Builder");
// Load the now-clean dyndep file. This will also update the
// build plan and schedule any new work that is ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13b40
testb $0x1, %al
jne 0xf45b
jmp 0xf4bb
movq -0x50(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x60(%rcx)
movb %al, -0x51(%rbp)
je ... | /adityavs[P]ninja/src/build.cc |
Builder::LoadDyndeps(Node*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool Builder::LoadDyndeps(Node* node, string* err) {
status_->BuildLoadDyndeps();
// Load the dyndep information provided by this node.
DyndepFile ddf;
if (!scan_.LoadDyndeps(node, &ddf, err))
return false;
// Update the build plan to account for dyndep modifications to the graph.
if (!plan_.DyndepsLo... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq 0x88(%rax), %rdi
callq 0xe5f0
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x15080
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
addq $0x98, %rdi
mov... | /adityavs[P]ninja/src/build.cc |
DependencyScan::VerifyDAG(Node*, std::vector<Node*, std::allocator<Node*>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool DependencyScan::VerifyDAG(Node* node, vector<Node*>* stack, string* err) {
Edge* edge = node->in_edge();
assert(edge != NULL);
// If we have no temporary mark on the edge then we do not yet have a cycle.
if (edge->mark_ != Edge::VisitInStack)
return true;
// We have this edge earlier in the call st... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13840
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x31b61
jmp 0x31b80
leaq 0x1aa5c(%rip), %rdi # 0x4c5c4
leaq 0x1a9b8(%rip), %rsi # 0x4c527
... | /adityavs[P]ninja/src/graph.cc |
ImplicitDepLoader::LoadDeps(Edge*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool ImplicitDepLoader::LoadDeps(Edge* edge, string* err) {
string deps_type = edge->GetBinding("deps");
if (!deps_type.empty())
return LoadDepsFromLog(edge, err);
string depfile = edge->GetUnescapedDepfile();
if (!depfile.empty())
return LoadDepFile(edge, depfile, err);
// No deps to load.
return... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5910
movq -0xa0(%rbp), %rdx
leaq 0x19b55(%rip), %rsi # 0x... | /adityavs[P]ninja/src/graph.cc |
ImplicitDepLoader::LoadDepsFromLog(Edge*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool ImplicitDepLoader::LoadDepsFromLog(Edge* edge, string* err) {
// NOTE: deps are only supported for single-target edges.
Node* output = edge->outputs_[0];
DepsLog::Deps* deps = deps_log_ ? deps_log_->GetDeps(output) : NULL;
if (!deps) {
EXPLAIN("deps for '%s' are missing", output->path().c_str());
r... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x140f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x28(%... | /adityavs[P]ninja/src/graph.cc |
LinePrinter::SetConsoleLocked(bool) | void LinePrinter::SetConsoleLocked(bool locked) {
if (locked == console_locked_)
return;
if (locked)
PrintOnNewLine("");
console_locked_ = locked;
if (!locked) {
PrintOnNewLine(output_buffer_);
if (!line_buffer_.empty()) {
Print(line_buffer_, line_type_);
}
output_buffer_.clear(... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x3(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x376a9
jmp 0x377c1
testb $0x1, -... | /adityavs[P]ninja/src/line_printer.cc |
Metrics::Report() | void Metrics::Report() {
int width = 0;
for (vector<Metric*>::iterator i = metrics_.begin();
i != metrics_.end(); ++i) {
width = max((int)(*i)->name.size(), width);
}
printf("%-*s\t%-6s\t%-9s\t%s\n", width,
"metric", "count", "avg (us)", "total (ms)");
for (vector<Metric*>::iterator i = m... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x3c330
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3c3a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3c360
testb $0x1, %al
jne 0x3c134
jm... | /adityavs[P]ninja/src/metrics.cc |
Parser::Load(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>>*, Lexer*) | bool Parser::Load(const string& filename, string* err, Lexer* parent) {
METRIC_RECORD(".ninja parse");
string contents;
string read_err;
if (file_reader_->ReadFile(filename, &contents, &read_err) !=
FileReader::Okay) {
*err = "loading '" + filename + "': " + read_err;
if (parent)
parent->Err... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x140(%rbp)
cmpb $0x0, 0x30a63(%rip) # 0x6d5f0
jne 0x3cc80
leaq 0x30a56(%rip), %rdi # 0x6d5f0
callq 0x5940
cmpl $0x... | /adityavs[P]ninja/src/parser.cc |
Pool::Dump() const | void Pool::Dump() const {
printf("%s (%d/%d) ->\n", name_.c_str(), current_use_, depth_);
for (DelayedEdges::const_iterator it = delayed_.begin();
it != delayed_.end(); ++it)
{
printf("\t");
(*it)->Dump();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x51c0
movq %rax, %rsi
movq -0x20(%rbp), %rax
movl 0x20(%rax), %edx
movl 0x24(%rax), %ecx
leaq 0xfb19(%rip), %rdi # 0x4cea6
movb $0x0, %al
callq 0x50b0
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq ... | /adityavs[P]ninja/src/state.cc |
State::GetNode(StringPiece, unsigned long) | Node* State::GetNode(StringPiece path, uint64_t slash_bits) {
Node* node = LookupNode(path);
if (node)
return node;
node = new Node(path.AsString(), slash_bits);
paths_[node->path()] = node;
return node;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
... | /adityavs[P]ninja/src/state.cc |
State::SpellcheckNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Node* State::SpellcheckNode(const string& path) {
const bool kAllowReplacements = true;
const int kMaxValidEditDistance = 3;
int min_distance = kMaxValidEditDistance + 1;
Node* result = NULL;
for (Paths::iterator i = paths_.begin(); i != paths_.end(); ++i) {
int distance = EditDistance(
i->first,... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movb $0x1, -0x11(%rbp)
movl $0x3, -0x18(%rbp)
movl $0x4, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
callq 0x3e8b0
movq %rax, -0x30(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3e8e0
movq %rax, -0x38(%rb... | /adityavs[P]ninja/src/state.cc |
State::AddOut(Edge*, StringPiece, unsigned long) | bool State::AddOut(Edge* edge, StringPiece path, uint64_t slash_bits) {
Node* node = GetNode(path, slash_bits);
if (node->in_edge())
return false;
edge->outputs_.push_back(node);
node->set_in_edge(edge);
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %rsi
m... | /adityavs[P]ninja/src/state.cc |
State::AddDefault(StringPiece, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool State::AddDefault(StringPiece path, string* err) {
Node* node = LookupNode(path);
if (!node) {
*err = "unknown target '" + path.AsString() + "'";
return false;
}
defaults_.push_back(node);
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
... | /adityavs[P]ninja/src/state.cc |
MurmurHash2(void const*, unsigned long) | static inline
unsigned int MurmurHash2(const void* key, size_t len) {
static const unsigned int seed = 0xDECAFBAD;
const unsigned int m = 0x5bd1e995;
const int r = 24;
unsigned int h = seed ^ len;
const unsigned char* data = (const unsigned char*)key;
while (len >= 4) {
unsigned int k;
memcpy(&k, da... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x5bd1e995, -0x14(%rbp) # imm = 0x5BD1E995
movl $0x18, -0x18(%rbp)
movabsq $0xdecafbad, %rax # imm = 0xDECAFBAD
xorq -0x10(%rbp), %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x4, -0x10(%rbp)
jb 0x3e300... | /adityavs[P]ninja/src/hash_map.h |
Warning(char const*, ...) | void Warning(const char* msg, ...) {
va_list ap;
fprintf(stderr, "ninja: warning: ");
va_start(ap, msg);
vfprintf(stderr, msg, ap);
va_end(ap);
fprintf(stderr, "\n");
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x42225
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp... | /adityavs[P]ninja/src/util.cc |
Error(char const*, ...) | void Error(const char* msg, ...) {
va_list ap;
fprintf(stderr, "ninja: error: ");
va_start(ap, msg);
vfprintf(stderr, msg, ap);
va_end(ap);
fprintf(stderr, "\n");
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x42305
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp... | /adityavs[P]ninja/src/util.cc |
SpellcheckStringV(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<char const*, std::allocator<char const*>> const&) | const char* SpellcheckStringV(const string& text,
const vector<const char*>& words) {
const bool kAllowReplacements = true;
const int kMaxValidEditDistance = 3;
int min_distance = kMaxValidEditDistance + 1;
const char* result = NULL;
for (vector<const char*>::const_iterator i = ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movl $0x3, -0x18(%rbp)
movl $0x4, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43c30
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43ca0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %... | /adityavs[P]ninja/src/util.cc |
SubprocessSet::HandlePendingInterruption() | void SubprocessSet::HandlePendingInterruption() {
sigset_t pending;
sigemptyset(&pending);
if (sigpending(&pending) == -1) {
perror("ninja: sigpending");
return;
}
if (sigismember(&pending, SIGINT))
interrupted_ = SIGINT;
else if (sigismember(&pending, SIGTERM))
interrupted_ = SIGTERM;
els... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x80(%rbp), %rdi
callq 0x5620
leaq -0x80(%rbp), %rdi
callq 0x5140
cmpl $-0x1, %eax
jne 0x45030
leaq 0x83a0(%rip), %rdi # 0x4d3c9
callq 0x53a0
jmp 0x4508f
leaq -0x80(%rbp), %rdi
movl $0x2, %esi
callq 0x5230
cmpl $0x0, %eax
je 0x4504f
movl $0x2, 0x286db(%rip) # 0... | /adityavs[P]ninja/src/subprocess-posix.cc |
Lexer::Error(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>>*) | bool Lexer::Error(const string& message, string* err) {
// Compute line/column.
int line = 1;
const char* line_start = input_.str_;
for (const char* p = input_.str_; p < last_token_; ++p) {
if (*p == '\n') {
++line;
line_start = p + 1;
}
}
int col = last_token_ ? (int)(last_token_ - line... | pushq %rbp
movq %rsp, %rbp
subq $0x540, %rsp # imm = 0x540
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x4f0(%rbp)
movl $0x1, -0x1c(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x4f0(%rbp), %rcx... | /adityavs[P]ninja/src/lexer.cc |
Lexer::TokenName(Lexer::Token) | const char* Lexer::TokenName(Token t) {
switch (t) {
case ERROR: return "lexing error";
case BUILD: return "'build'";
case COLON: return "':'";
case DEFAULT: return "'default'";
case EQUALS: return "'='";
case IDENT: return "identifier";
case INCLUDE: return "'include'";
case INDENT: ... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xe, %rax
ja 0x48d2e
movq -0x18(%rbp), %rax
leaq 0x490d(%rip), %rcx # 0x4d560
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4d51(%rip), %rax # 0x4d9b4
movq %rax, -0x8(%rbp)
jmp 0x48d36
leaq 0x4d4... | /adityavs[P]ninja/src/lexer.cc |
arangodb::velocypack::Builder::Builder(std::shared_ptr<arangodb::velocypack::Buffer<unsigned char>>) | Builder::Builder(std::shared_ptr<Buffer<uint8_t>> buffer)
: _buffer(std::move(buffer)),
_bufferPtr(_buffer.get()),
_start(nullptr),
_pos(0),
_arena(),
_stack(_arena),
_keyWritten(false),
options(&Options::Defaults) {
if (VELOCYPACK_UNLIKELY(_bufferPtr == nullptr)) {
t... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movups (%rsi), %xmm0
andq $0x0, 0x8(%rsi)
movups %xmm0, (%rdi)
andq $0x0, (%rsi)
leaq 0x8(%rdi), %r14
movq (%rdi), %rax
movq %rax, 0x10(%rdi)
leaq 0x28(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq %rcx, 0x68(%rdi... | /arangodb[P]velocypack/src/Builder.cpp |
arangodb::velocypack::Builder::Builder(arangodb::velocypack::Buffer<unsigned char>&) | Builder::Builder(Buffer<uint8_t>& buffer) noexcept
: _bufferPtr(&buffer),
_start(_bufferPtr->data()),
_pos(buffer.size()),
_arena(),
_stack(_arena),
_keyWritten(false),
options(&Options::Defaults) {
// do a full initial allocation in the arena, so we can maximize its usage
_s... | pushq %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
movq (%rsi), %rax
movq %rax, 0x18(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, 0x68(%rdi)
leaq 0x70(%rdi), %rax
movq %rcx, 0x70(%rdi)
movups %xmm0, 0x78(%rdi)
movups %xmm0, 0x88(%rdi)
movups %xmm0, 0x98(%rdi)
... | /arangodb[P]velocypack/src/Builder.cpp |
arangodb::velocypack::Builder::toJson[abi:cxx11]() const | std::string Builder::toJson() const {
std::string buffer;
StringSink sink(&buffer);
Dumper::dump(slice(), &sink);
return buffer;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x167cd(%rip), %rax # 0x1bc80
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rsi, %rdi
callq 0x4404
leaq 0x16c90(%rip), %rdx # 0x1c160
leaq 0x8(%rsp),... | /arangodb[P]velocypack/src/Builder.cpp |
(anonymous namespace)::findAttrName(unsigned char const*, unsigned long&) | uint8_t const* findAttrName(uint8_t const* base, uint64_t& len) {
uint8_t const b = *base;
if (b >= 0x40 && b <= 0xbe) {
// short UTF-8 string
len = b - 0x40;
return base + 1;
}
if (b == 0xbf) {
// long UTF-8 string
len = 0;
// read string length
for (std::size_t i = 8; i >= 1; i--) ... | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %rax
movzbl (%rdi), %ecx
leal -0x40(%rcx), %edx
cmpb $0x7e, %dl
ja 0x58f9
addl $-0x40, %ecx
movq %rcx, (%rbx)
incq %rax
jmp 0x5944
cmpl $0xbf, %ecx
jne 0x5926
andq $0x0, (%rbx)
pushq $0x8
popq %rsi
xorl %ecx, %ecx
movq %rsi, %rdx
subq $0x1, %rdx
jb 0x5940
shlq $0x8... | /arangodb[P]velocypack/src/Builder.cpp |
arangodb::velocypack::Builder::closeLevel() | void Builder::closeLevel() noexcept {
VELOCYPACK_ASSERT(!_stack.empty());
ValueLength const indexStartPos = _stack.back().indexStartPos;
_stack.pop_back();
_indexes.erase(_indexes.begin() + indexStartPos, _indexes.end());
} | pushq %rax
movq 0x80(%rdi), %rax
movq 0x98(%rdi), %rdx
movq -0x8(%rax), %rsi
addq $-0x10, %rax
movq %rax, 0x80(%rdi)
shlq $0x3, %rsi
addq 0x90(%rdi), %rsi
addq $0x90, %rdi
callq 0x838c
popq %rax
retq
movq %rax, %rdi
callq 0x3926
nop
| /arangodb[P]velocypack/src/Builder.cpp |
arangodb::velocypack::Builder::appendUInt(unsigned long, unsigned char) | void appendUInt(uint64_t v, uint8_t base) {
reserve(9);
ValueLength save = _pos;
advance(1);
uint8_t vSize = 0;
do {
vSize++;
appendByteUnchecked(static_cast<uint8_t>(v & 0xff));
v >>= 8;
} while (v != 0);
_start[save] = base + vSize;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x9
popq %rsi
callq 0x3b7a
movq 0x10(%r14), %rax
movq 0x20(%r14), %r12
leaq 0x1(%r12), %rcx
movq %rcx, 0x20(%r14)
incq 0x10(%rax)
movq %r15, %r13
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x815e
shrq $0x8, %r13
... | /arangodb[P]velocypack/include/velocypack/Builder.h |
arangodb::velocypack::Builder::appendInt(long, unsigned char) | void appendInt(int64_t v, uint8_t base) {
uint8_t vSize = intLength(v);
uint64_t x;
if (vSize == 8) {
x = toUInt64(v);
} else {
int64_t shift = 1LL << (vSize * 8 - 1); // will never overflow!
x = v >= 0 ? static_cast<uint64_t>(v)
: static_cast<uint64_t>(v + shift) + s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x84c4
movzbl %al, %r15d
cmpb $0x8, %r15b
je 0x8486
leal (,%r15,8), %ecx
decb %cl
pushq $0x2
popq %rax
shlq %cl, %rax
movq %rbx, %rcx
sarq $0x3f, %rcx
andq %rax, %rcx
addq %rcx, %rbx
movl %r15d, ... | /arangodb[P]velocypack/include/velocypack/Builder.h |
VELOCYPACK_XXH3_64bits_reset_withSeed | XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSeed(XXH3_state_t* statePtr,
XXH64_hash_t seed) {
if (statePtr == NULL) return XXH_ERROR;
if (seed == 0) return XXH3_64bits_reset(statePtr);
if (seed != statePtr->seed)
XXH3_initCustomSecret(statePtr->cu... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xf5ff
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xf60c
cmpq %rbx, 0x228(%r14)
je 0xf5e8
leaq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0xf619
xorl %r15d, %r15d
movl $0xc0, %ecx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xf4eb
jmp 0xf603
pushq $0x1... | /arangodb[P]velocypack/src/xxhash.h |
main | int main(int argc, char** argv) {
if(argc != 4) {
fprintf(stderr, "Usage: %s <resource_name> <infile> <outfile.h>\n", argv[0]);
return 1;
}
FILE *in, *out;
int c;
in = fopen(argv[2], "r");
if(in == NULL) {
perror("could not open input file");
return 1;
}
out = fopen(argv[3], "w");
if(out == NULL) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
cmpl $0x4, %edi
jne 0x1274
movq 0x10(%r15), %rdi
leaq 0xe6a(%rip), %rsi # 0x2034
callq 0x1060
testq %rax, %rax
je 0x127e
movq %rax, %rbx
movq 0x18(%r15), %rdi
leaq 0xe6a(%rip), %rsi # 0x2050
callq 0x1060
testq %rax, %rax
je 0x1287
movq %... | /Artefact2[P]libxm/examples/filetoh.c |
doctest::detail::getTlsOssResult() | String getTlsOssResult() {
//g_oss << std::ends; // needed - as shown here: https://stackoverflow.com/a/624291/3162383
return g_oss.str().c_str();
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x1356e
movq %fs:0x0, %rax
leaq -0x1a8(%rax), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x44d0
movq (%r14), %r14
movq %r14, %rdi
callq 0x4150
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x50aa
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq ... | /ad65537[P]moptional/include/doctest.h |
doctest::String::copy(doctest::String const&) | void String::copy(const String& other) {
using namespace std;
if(other.isOnStack()) {
memcpy(buf, other.buf, len);
} else {
setOnHeap();
data.size = other.data.size;
data.capacity = data.size + 1;
data.ptr = new char[data.capacity];
memcpy(data.ptr, o... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x17(%rsi)
js 0x5036
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movups (%rbx), %xmm0
movups %xmm0, (%r14)
popq %rbx
popq %r14
popq %r15
retq
movb $-0x80, 0x17(%r14)
movl 0x8(%rbx), %r15d
movl %r15d, 0x8(%r14)
incl %r15d
movl %r15d, 0xc(%r14)
m... | /ad65537[P]moptional/include/doctest.h |
doctest::String::operator+=(doctest::String const&) | String& String::operator+=(const String& other) {
const unsigned my_old_size = size();
const unsigned other_size = other.size();
const unsigned total_size = my_old_size + other_size;
using namespace std;
if(isOnStack()) {
if(total_size < len) {
// append to the current stack sp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x17(%rdi), %eax
movl $0x17, %r15d
testb %al, %al
jns 0x517e
movl 0x8(%rbx), %ebp
jmp 0x518a
movl %eax, %ecx
andl $0x1f, %ecx
movl $0x17, %ebp
subl %ecx, %ebp
movzbl 0x17(%r14), %ecx
testb %cl, %cl
jns 0x... | /ad65537[P]moptional/include/doctest.h |
doctest::String::operator=(doctest::String&&) | String& String::operator=(String&& other) {
using namespace std;
if(this != &other) {
if(!isOnStack())
delete[] data.ptr;
memcpy(buf, other.buf, len);
other.buf[0] = '\0';
other.setLast();
}
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x53c0
movq %rsi, %r14
cmpb $0x0, 0x17(%rbx)
jns 0x53a8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x53a8
callq 0x4410
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movb $0x0, (%r14)
movb $0x17, 0x17(%r14)
movq %rbx, ... | /ad65537[P]moptional/include/doctest.h |
doctest::operator<<(std::ostream&, doctest::String const&) | std::ostream& operator<<(std::ostream& s, const String& in) { return s << in.c_str(); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x17(%rsi)
jns 0x557d
movq (%r14), %r14
testq %r14, %r14
je 0x559a
movq %r14, %rdi
callq 0x4150
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x43b0
jmp 0x55b1
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%r... | /ad65537[P]moptional/include/doctest.h |
doctest::Color::operator<<(std::ostream&, doctest::Color::Enum) | std::ostream& operator<<(std::ostream& s, Color::Enum code) {
color_to_stream(s, code);
return s;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, %fs:-0x38
jne 0x5636
movl %esi, %ebp
movl $0x1, %edi
callq 0x4560
testl %eax, %eax
jne 0x55eb
movq 0x1bd7b(%rip), %rax # 0x21360
cmpb $0x0, 0x7d(%rax)
je 0x5636
addl $-0x2, %ebp
cmpl $0x15, %ebp
ja 0x5605
movl %ebp, %eax
leaq 0x11b6c(%rip), %rcx # 0x17... | /ad65537[P]moptional/include/doctest.h |
doctest::assertString(doctest::assertType::Enum) | const char* assertString(assertType::Enum at) {
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4062) // enum 'x' in switch of enum 'y' is not handled
switch(at) { //!OCLINT missing default in switch statements
case assertType::DT_WARN : return "WARN";
case assertType::DT_CHECK ... | cmpl $0x20b, %edi # imm = 0x20B
jg 0x5678
cmpl $0x60, %edi
jg 0x56c8
cmpl $0x20, %edi
jg 0x5750
addl $-0x9, %edi
cmpl $0xb, %edi
ja 0x5a0f
leaq 0x119a9(%rip), %rax # 0x17010
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x11bb4(%rip), %rax # 0x1722b
retq
cmpl $0x1009, %edi # im... | /ad65537[P]moptional/include/doctest.h |
doctest::failureString(doctest::assertType::Enum) | const char* failureString(assertType::Enum at) {
if(at & assertType::is_warn) //!OCLINT bitwise operator in conditional
return "WARNING";
if(at & assertType::is_check) //!OCLINT bitwise operator in conditional
return "ERROR";
if(at & assertType::is_require) //!OCLINT bitwise operator in cond... | testb $0x1, %dil
jne 0x5a3a
testb $0x2, %dil
jne 0x5a42
testb $0x4, %dil
leaq 0x11b2b(%rip), %rcx # 0x17559
leaq 0x11a35(%rip), %rax # 0x1746a
cmoveq %rcx, %rax
retq
leaq 0x11a21(%rip), %rax # 0x17462
retq
leaq 0x11a27(%rip), %rax # 0x17470
retq
| /ad65537[P]moptional/include/doctest.h |
doctest::toString(double) | String toString(double in) { return fpToString(in, 10); } | pushq %r14
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movsd %xmm0, 0x28(%rsp)
movq %rdi, %rbx
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x4430
movq (%r14), %rax
movq -0x18(%rax), %rcx
movq $0xa, 0x58(%rsp,%rcx)
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx # imm = 0xFFFFFEFB
andl 0x68(%rsp,%rax), %ec... | /ad65537[P]moptional/include/doctest.h |
doctest::toString(char) | DOCTEST_TO_STRING_OVERLOAD(char, "%d")
DOCTEST_TO_STRING_OVERLOAD(char signed, "%d")
DOCTEST_TO_STRING_OVERLOAD(char unsigned, "%u")
DOCTEST_TO_STRING_OVERLOAD(int short, "%d")
DOCTEST_TO_STRING_OVERLOAD(int short unsigned, "%u")
DOCTEST_TO_STRING_OVERLOAD(int, "%d")
DOCTEST_TO_STRING_OVERLOAD(unsigned, "%u")
DOCTEST_T... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %edx
movq %rdi, %rbx
leaq 0x11416(%rip), %rsi # 0x17481
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x4090
movq %r14, %rdi
callq 0x4150
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x50aa
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
| /ad65537[P]moptional/include/doctest.h |
doctest::toString(signed char) | DOCTEST_TO_STRING_OVERLOAD(char, "%d")
DOCTEST_TO_STRING_OVERLOAD(char signed, "%d")
DOCTEST_TO_STRING_OVERLOAD(char unsigned, "%u")
DOCTEST_TO_STRING_OVERLOAD(int short, "%d")
DOCTEST_TO_STRING_OVERLOAD(int short unsigned, "%u")
DOCTEST_TO_STRING_OVERLOAD(int, "%d")
DOCTEST_TO_STRING_OVERLOAD(unsigned, "%u")
DOCTEST_T... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %edx
movq %rdi, %rbx
leaq 0x113d6(%rip), %rsi # 0x17481
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x4090
movq %r14, %rdi
callq 0x4150
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x50aa
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
| /ad65537[P]moptional/include/doctest.h |
doctest::detail::Subcase::~Subcase() | Subcase::~Subcase() {
if(m_entered) {
// only mark the subcase stack as passed if no subcases have been skipped
if(g_cs->should_reenter == false)
g_cs->subcasesPassed.insert(g_cs->subcasesStack);
g_cs->subcasesStack.pop_back();
#if defined(__cpp_lib_uncaught_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x6c9d
movq 0x1a7cc(%rip), %rsi # 0x21360
cmpb $0x0, 0x1164(%rsi)
jne 0x6bb0
leaq 0x1130(%rsi), %rdi
addq $0x1118, %rsi # imm = 0x1118
callq 0x14934
movq 0x1a7a9(%rip), %rcx # 0... | /ad65537[P]moptional/include/doctest.h |
doctest::detail::TestCase::operator=(doctest::detail::TestCase const&) | TestCase& TestCase::operator=(const TestCase& other) {
static_cast<TestCaseData&>(*this) = static_cast<const TestCaseData&>(other);
m_test = other.m_test;
m_type = other.m_type;
m_template_id = other.m_template_id;
m_full_name = other.m_full_name;
if(m_t... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x5122
movups 0x18(%r15), %xmm0
movups 0x28(%r15), %xmm1
movups 0x38(%r15), %xmm2
movups %xmm0, 0x18(%rbx)
movups %xmm1, 0x28(%rbx)
movups %xmm2, 0x38(%rbx)
movq 0x48(%r15), %rax
movq %rax, 0x48(%rbx)
movq 0x50(%r15), %rax
movq %rax, 0x50(%rbx)
movq... | /ad65537[P]moptional/include/doctest.h |
doctest::detail::ContextScopeBase::destroy() | void ContextScopeBase::destroy() {
#if defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
if(std::uncaught_exceptions() > 0) {
#else
if(std::uncaught_exception()) {
#endif
... | pushq %r14
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, %rbx
callq 0x43e0
testl %eax, %eax
jle 0x73de
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x4430
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movl $0x1100, %ebx # imm = 0x1100
addq 0x1a009(%rip), %rbx # 0x21... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::translateActiveException() | String translateActiveException() {
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
String res;
auto& translators = getExceptionTranslators();
for(auto& curr : translators)
if(curr->translate(res))
return res;
// clang-format off
DOCTEST_GCC_SUPPRESS_WARNING_WIT... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movb $0x0, (%rsp)
movb $0x17, 0x17(%rsp)
callq 0x7220
movq 0x19eab(%rip), %r15 # 0x213e0
movq 0x19eac(%rip), %r12 # 0x213e8
cmpq %r12, %r15
je 0x755d
movq %rsp, %r14
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)... | /ad65537[P]moptional/include/doctest.h |
doctest::detail::MessageBuilder::MessageBuilder(char const*, int, doctest::assertType::Enum) | MessageBuilder::MessageBuilder(const char* file, int line, assertType::Enum severity) {
m_stream = getTlsOss();
m_file = file;
m_line = line;
m_severity = severity;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movb $0x0, (%rdi)
movb $0x17, 0x17(%rdi)
callq 0x4e97
movq %rax, 0x28(%rbx)
movq %r15, 0x18(%rbx)
movl %r14d, 0x20(%rbx)
movl %ebp, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
r... | /ad65537[P]moptional/include/doctest.h |
doctest::detail::IExceptionTranslator::~IExceptionTranslator() | bool MessageBuilder::log() {
m_string = getTlsOssResult();
DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);
const bool isWarn = m_severity & assertType::is_warn;
// warn is just a message in this context so we don't treat it as an assert
if(!isWarn) {
addAsser... | ud2
| /ad65537[P]moptional/include/doctest.h |
doctest::Context::applyCommandLine(int, char const* const*) | void Context::applyCommandLine(int argc, const char* const* argv) {
parseArgs(argc, argv);
if(argc)
p->binary_name = argv[0];
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
xorl %ecx, %ecx
callq 0x7f7e
testl %ebp, %ebp
je 0x9286
movq (%r14), %r14
movq %r14, %rdi
callq 0x4150
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x50aa
movq (%rbx), %rax
leaq 0x10(%rax), %rbx
cmpb $0x0, 0x... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::parseOption(int, char const* const*, char const*, doctest::String*, doctest::String const&) | bool parseOption(int argc, const char* const* argv, const char* pattern, String* value = nullptr,
const String& defaultVal = String()) {
if(value)
*value = defaultVal;
#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
// offset (normally 3 for "dt-") to skip prefix
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
testq %rcx, %rcx
je 0x93d9
movq %rbx, %rdi
movq %r8, %rsi
callq 0x5122
leaq 0x3(%r14), %rdx
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rcx
callq 0xb2c7
testb %al, %al
je 0x93fb
movb $0x1, %al
addq $0x... | /ad65537[P]moptional/include/doctest.h |
doctest::Context::run() | int Context::run() {
using namespace detail;
// save the old context state in case such was setup - for using asserts out of a testing context
auto old_cs = g_cs;
// this is the current contest
g_cs = p;
is_running_in_test = true;
g_no_colors = p->no_colors;
p->resetRunDa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x368, %rsp # imm = 0x368
movq %rdi, %rbx
movq 0x17a5b(%rip), %r15 # 0x21360
movq (%rdi), %rax
movq %rax, 0x17a51(%rip) # 0x21360
movb $0x1, 0x17a42(%rip) # 0x21358
movq (%rdi), %rax
movb 0x7c(%rax), %cl
movb %cl, %fs:-0x38
x... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::XmlWriter::XmlWriter(std::ostream&) | XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
{
writeDeclaration();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %r14
movw $0x0, (%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x18(%rdi)
leaq 0x30(%rdi), %r12
movq %r12, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
movq %rsi, 0x40(%rdi)
lea... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::XmlReporter::report_query(doctest::QueryData const&) | void report_query(const QueryData& in) override {
test_run_start();
if(opt.list_reporters) {
for(auto& curr : getListeners())
xml.scopedElement("Listener")
.writeAttribute("priority", curr.first.first)
.w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, 0x48(%rsp)
movq 0x78(%rbx), %rax
cmpb $0x1, 0x8b(%rax)
jne 0xb9ac
callq 0xa76b
movq 0x15d1d(%rip), %rbx # 0x21458
leaq 0x15d06(%rip), %rax # 0x21448
cm... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::XmlReporter::test_run_start() | void test_run_start() override {
// remove .exe extension - mainly to have the same output on UNIX and Windows
std::string binary_name = skipPathFromFilename(opt.binary_name.c_str());
#ifdef DOCTEST_PLATFORM_WINDOWS
if(binary_name.rfind(".exe") != std::string::npos)
b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
cmpb $0x0, 0x27(%rdi)
jns 0xc0b2
movq 0x10(%rdi), %rdi
jmp 0xc0b6
addq $0x10, %rdi
callq 0x5a4a
leaq 0x148(%rsp), %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x1359e
leaq 0x1... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::XmlReporter::test_case_end(doctest::CurrentTestCaseStats const&) | void test_case_end(const CurrentTestCaseStats& st) override {
xml.startElement("OverallResultsAsserts")
.writeAttribute("successes",
st.numAssertsCurrentTest - st.numAssertsFailedCurrentTest)
.writeAttribute("failures", st.numAssert... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xb445(%rip), %rsi # 0x17ee0
leaq 0xb453(%rip), %rdx # 0x17ef5
movq %rsp, %rdi
callq 0x1450c
leaq 0x8(%r14), %rbx
movq %rsp, %rsi
movq %rbx, %rdi... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::XmlWriter& doctest::(anonymous namespace)::XmlWriter::writeAttribute<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
std::stringstream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4260
leaq 0x38(%rsp), %rdi
movl (%r15), %esi
callq 0x4550
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x44d0
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::XmlWriter& doctest::(anonymous namespace)::XmlWriter::writeAttribute<doctest::String>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, doctest::String const&) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
std::stringstream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4260
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x556a
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x44d0
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
c... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::XmlReporter::test_case_start_impl(doctest::TestCaseData const&) | void test_case_start_impl(const TestCaseData& in) {
bool open_ts_tag = false;
if(tc != nullptr) { // we have already opened a test suite
if(std::strcmp(tc->m_test_suite, in.m_test_suite) != 0) {
xml.endElement();
open_ts_tag = true;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0xe69f
movq 0x28(%rax), %rdi
movq 0x28(%rbx), %rsi
callq 0x4440
testl %eax, %eax
je 0xe722
leaq 0x8(%r15), %rdi
callq 0xdb08
leaq 0x10(%rsp), %r12
movq %r12, -0x10... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::XmlWriter::ScopedElement::writeText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, bool indent ) {
m_writer->writeText( text, indent );
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0xec3c
movl %edx, %ebp
movq %rsi, %r15
movq (%rbx), %r14
andb (%r14), %bpl
movq %r14, %rdi
callq 0xdca2
cmpb $0x1, %bpl
jne 0xebec
movq 0x40(%r14), %rdi
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
... | /ad65537[P]moptional/include/doctest.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.