name string | code string | asm string | file string |
|---|---|---|---|
cmFileAPI::BuildReply(cmFileAPI::Query const&) | Json::Value cmFileAPI::BuildReply(Query const& q)
{
Json::Value reply = Json::objectValue;
for (Object const& o : q.Known) {
std::string const& name = ObjectName(o);
reply[name] = this->AddReplyIndexObject(o);
}
for (std::string const& name : q.Unknown) {
reply[name] = cmFileAPI::BuildReplyError("u... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x100(%rbp)
movq %rdi, %rax
movq %rax, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x7, %esi
callq 0x8d5360
movq -0x18(%rbp), %... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::AddReplyIndexObject(cmFileAPI::Object const&) | Json::Value const& cmFileAPI::AddReplyIndexObject(Object const& o)
{
Json::Value& indexEntry = this->ReplyIndexObjects[o];
if (!indexEntry.isNull()) {
// The reply object has already been generated.
return indexEntry;
}
// Generate this reply object.
Json::Value const& object = this->BuildObject(o);
... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
addq $0xc8, %rdi
movq -0x18(%rbp), %rsi
callq 0x5d6b40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8d8960
testb $0x1, %al
jne 0x5d3f8c
movq -0x20(%r... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::BuildObject(cmFileAPI::Object const&) | Json::Value cmFileAPI::BuildObject(Object const& object)
{
Json::Value value;
switch (object.Kind) {
case ObjectKind::CodeModel:
value = this->BuildCodeModel(object);
break;
case ObjectKind::Cache:
value = this->BuildCache(object);
break;
case ObjectKind::CMakeFiles:
value... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x118(%rbp)
movq %rdi, %rax
movq %rax, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x108(%rbp)
movb $0x0, -0x19(%rbp)
xorl %esi, %esi
callq 0x8d5360
movq -0x18(%rbp),... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::BuildVersion(unsigned int, unsigned int) | Json::Value cmFileAPI::BuildVersion(unsigned int major, unsigned int minor)
{
Json::Value version;
version["major"] = major;
version["minor"] = minor;
return version;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
xorl %esi, %esi
callq 0x8d5360
movl -0xc(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x8d5570
jmp 0x5d44cc
movq -0x88(%rbp), %r... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::BuildCodeModel(cmFileAPI::Object const&) | Json::Value cmFileAPI::BuildCodeModel(Object const& object)
{
Json::Value codemodel = cmFileAPICodemodelDump(*this, object.Version);
codemodel["kind"] = this->ObjectKindName(object.Kind);
Json::Value& version = codemodel["version"];
if (object.Version == 2) {
version = BuildVersion(2, CodeModelV2Minor);
... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x5dbb90
movq -0x18(%rbp), %rax
movl (%rax), %edi
... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::ReadRequestVersions(Json::Value const&, std::vector<cmFileAPI::RequestVersion, std::allocator<cmFileAPI::RequestVersion>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool cmFileAPI::ReadRequestVersions(Json::Value const& version,
std::vector<RequestVersion>& versions,
std::string& error)
{
if (version.isArray()) {
for (Json::Value const& v : version) {
if (!ReadRequestVersion(v, /*inArray=*/true, ve... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8d8990
testb $0x1, %al
jne 0x5d5306
jmp 0x5d5399
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8dbab0
movb %dl, -0x40(%rbp)
movq %rax, -0x48(%rbp... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::BuildClientRequestCodeModel(cmFileAPI::ClientRequest&, std::vector<cmFileAPI::RequestVersion, std::allocator<cmFileAPI::RequestVersion>> const&) | void cmFileAPI::BuildClientRequestCodeModel(
ClientRequest& r, std::vector<RequestVersion> const& versions)
{
// Select a known version from those requested.
for (RequestVersion const& v : versions) {
if ((v.Major == 2 && v.Minor <= CodeModelV2Minor)) {
r.Version = v.Major;
break;
}
}
if (... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5d70e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5d7110
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp),... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::BuildClientRequestCMakeFiles(cmFileAPI::ClientRequest&, std::vector<cmFileAPI::RequestVersion, std::allocator<cmFileAPI::RequestVersion>> const&) | void cmFileAPI::BuildClientRequestCMakeFiles(
ClientRequest& r, std::vector<RequestVersion> const& versions)
{
// Select a known version from those requested.
for (RequestVersion const& v : versions) {
if ((v.Major == 1 && v.Minor <= CMakeFilesV1Minor)) {
r.Version = v.Major;
break;
}
}
if... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5d70e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5d7110
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp),... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::ReadRequestVersion(Json::Value const&, bool, std::vector<cmFileAPI::RequestVersion, std::allocator<cmFileAPI::RequestVersion>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool cmFileAPI::ReadRequestVersion(Json::Value const& version, bool inArray,
std::vector<RequestVersion>& result,
std::string& error)
{
if (version.isUInt()) {
RequestVersion v;
v.Major = version.asUInt();
result.push_back(v);
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8d75e0
testb $0x1, %al
jne 0x5d5a9b
jmp 0x5d5ac6
leaq -0x30(%rbp), %rdi
callq 0x5d7010
movq -0x10(%rbp), %rdi
callq 0x8d7280... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
cmFileAPI::ReportCapabilities() | Json::Value cmFileAPI::ReportCapabilities()
{
Json::Value capabilities = Json::objectValue;
Json::Value& requests = capabilities["requests"] = Json::arrayValue;
{
Json::Value request = Json::objectValue;
request["kind"] = ObjectKindName(ObjectKind::CodeModel);
Json::Value& versions = request["version... | pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp # imm = 0x3E0
movq %rdi, -0x300(%rbp)
movq %rdi, %rax
movq %rax, -0x2f8(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movl $0x7, %esi
callq 0x8d5360
leaq -0x40(%rbp), %rdi
movl $0x6, %esi
callq 0x8d5360
jmp 0x5d5dee
movq -0x300(%rbp), %rdi
leaq 0x5b3303(%rip),... | /JKorbelRA[P]CMake/Source/cmFileAPI.cxx |
(anonymous namespace)::Cache::DumpEntryProperty(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&) | Json::Value Cache::DumpEntryProperty(std::string const& name,
std::string const& prop)
{
Json::Value property = Json::objectValue;
property["name"] = prop;
cmValue p = this->State->GetCacheEntryProperty(name, prop);
property["value"] = p ? *p : "";
return property;
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movb $0x0, -0x21(%rbp)
movl $0x7, %esi
callq 0x8d53... | /JKorbelRA[P]CMake/Source/cmFileAPICache.cxx |
(anonymous namespace)::Codemodel::DumpPaths() | Json::Value Codemodel::DumpPaths()
{
Json::Value paths = Json::objectValue;
paths["source"] = this->FileAPI.GetCMakeInstance()->GetHomeDirectory();
paths["build"] = this->FileAPI.GetCMakeInstance()->GetHomeOutputDirectory();
return paths;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x7, %esi
callq 0x8d5360
movq -0x88(%rbp), %rax
movq (%rax), %rdi
callq 0x5dbb70
movq %rax, -0... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::Codemodel::DumpConfigurations() | Json::Value Codemodel::DumpConfigurations()
{
Json::Value configurations = Json::arrayValue;
cmGlobalGenerator* gg =
this->FileAPI.GetCMakeInstance()->GetGlobalGenerator();
const auto& makefiles = gg->GetMakefiles();
if (!makefiles.empty()) {
std::vector<std::string> const& configs =
makefiles[0]-... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x6, %esi
callq 0x8d5360
movq -0xb0(%rbp), %rax
movq (%rax), %rdi
callq 0x5dbb70
movq %rax, %r... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::CodemodelConfig::CodemodelConfig(cmFileAPI&, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | CodemodelConfig::CodemodelConfig(cmFileAPI& fileAPI, unsigned long version,
std::string const& config)
: FileAPI(fileAPI)
, Version(version)
, Config(config)
, TopSource(this->FileAPI.GetCMakeInstance()->GetHomeDirectory())
, TopBuild(this->FileAPI.GetCMakeInstance()->GetHomeO... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq %rax,... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::CodemodelConfig::DumpTarget(cmGeneratorTarget*, unsigned int) | Json::Value CodemodelConfig::DumpTarget(cmGeneratorTarget* gt,
Json::ArrayIndex ti)
{
Target t(gt, this->Config);
std::string prefix = "target-" + gt->GetName();
for (char& c : prefix) {
// CMP0037 OLD behavior allows slashes in target names. Remove them.
if (c == ... | pushq %rbp
movq %rsp, %rbp
subq $0x560, %rsp # imm = 0x560
movq %rdi, -0x4d8(%rbp)
movq %rdi, %rax
movq %rax, -0x4d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x4c8(%rbp)
movq -0x18(%rbp), %rsi
movq 0x10(%rax), %rdx
lea... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::Target::Target(cmGeneratorTarget*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Target::Target(cmGeneratorTarget* gt, std::string const& config)
: GT(gt)
, Config(config)
, TopSource(gt->GetGlobalGenerator()->GetCMakeInstance()->GetHomeDirectory())
, TopBuild(
gt->GetGlobalGenerator()->GetCMakeInstance()->GetHomeOutputDirectory())
, SourceGroupsLocal(this->GT->Makefile->GetSourceGr... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x10, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6263a0
... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::Target::DumpDependencies() | Json::Value Target::DumpDependencies()
{
Json::Value dependencies = Json::arrayValue;
cmGlobalGenerator* gg = this->GT->GetGlobalGenerator();
for (cmTargetDepend const& td : gg->GetTargetDirectDepends(this->GT)) {
dependencies.append(this->DumpDependency(td));
}
return dependencies;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x6, %esi
callq 0x8d5360
movq -0x88(%rbp), %rax
movq (%rax), %rdi
callq 0x6263a0
movq %rax, -0... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::BacktraceData::Add(cmListFileBacktrace const&) | JBTIndex BacktraceData::Add(cmListFileBacktrace const& bt)
{
JBTIndex index;
if (bt.Empty()) {
return index;
}
cmListFileContext const* top = &bt.Top();
auto found = this->NodeMap.find(top);
if (found != this->NodeMap.end()) {
index.Index = found->second;
return index;
}
Json::Value entry = ... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x4(%rbp), %rdi
callq 0x5e48c0
movq -0x18(%rbp), %rdi
callq 0x1d7790
testb $0x1, %al
jne 0x5e44e6
jmp 0x5e44eb
jmp 0x5e4885
movq -0x18(%rbp), %rdi
call... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::Target::DumpInstallPrefix() | Json::Value Target::DumpInstallPrefix()
{
Json::Value prefix = Json::objectValue;
std::string p =
this->GT->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
cmSystemTools::ConvertToUnixSlashes(p);
prefix["path"] = p;
return prefix;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x7, %esi
callq 0x8d5360
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %r... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::Target::DumpSysroot(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Json::Value Target::DumpSysroot(std::string const& path)
{
Json::Value sysroot = Json::objectValue;
sysroot["path"] = path;
return sysroot;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x7, %esi
callq 0x8d5360
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x8d5ac0
jmp 0x5e5d7c
movq -0x68(%rbp), ... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::Target::DumpSourceGroup((anonymous namespace)::Target::SourceGroup&) | Json::Value Target::DumpSourceGroup(SourceGroup& sg)
{
Json::Value group = Json::objectValue;
group["name"] = sg.Name;
group["sourceIndexes"] = std::move(sg.SourceIndexes);
return group;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x7, %esi
callq 0x8d5360
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x8d5ac0
jmp 0x5f0b8f
movq -0x68(%rbp), ... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::Target::DumpCompileData((anonymous namespace)::CompileData const&) | Json::Value Target::DumpCompileData(CompileData const& cd)
{
Json::Value result = Json::objectValue;
if (!cd.Language.empty()) {
result["language"] = cd.Language;
}
if (!cd.Sysroot.empty()) {
result["sysroot"] = this->DumpSysroot(cd.Sysroot);
}
if (!cd.Flags.empty()) {
result["compileCommandFra... | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %rdi, -0x238(%rbp)
movq %rdi, %rax
movq %rax, -0x230(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x7, %esi
callq 0x8d5360
movq -0x18(%rbp),... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::Target::DumpDefine((anonymous namespace)::JBT<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) | Json::Value Target::DumpDefine(JBT<std::string> const& def)
{
Json::Value define = Json::objectValue;
define["define"] = def.Value;
this->AddBacktrace(define, def.Backtrace);
return define;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x7, %esi
callq 0x8d5360
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::Target::DumpLanguageStandard((anonymous namespace)::JBTs<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) | Json::Value Target::DumpLanguageStandard(JBTs<std::string> const& standard)
{
Json::Value languageStandard = Json::objectValue;
languageStandard["standard"] = standard.Value;
if (!standard.Backtraces.empty()) {
Json::Value backtraces = Json::arrayValue;
for (JBTIndex backtrace : standard.Backtraces) {
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x7, %esi
callq 0x8d5360
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x8d5ac0
jmp 0x5f20f5
movq -0xd8(%rbp), ... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::CodemodelConfig::DumpMinimumCMakeVersion(cmStateSnapshot) | Json::Value CodemodelConfig::DumpMinimumCMakeVersion(cmStateSnapshot s)
{
Json::Value minimumCMakeVersion;
if (cmValue def = s.GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION")) {
minimumCMakeVersion = Json::objectValue;
minimumCMakeVersion["string"] = *def;
}
return minimumCMakeVersion;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
xorl %esi, %esi
callq 0x8d5360
leaq -0x41(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3c460
movq -0xb0... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::DirectoryObject::DirectoryObject(cmLocalGenerator const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_map<cmGeneratorTarget const*, unsigned int, std::hash<cmGeneratorTarget const*>, std::equal_to<cmGeneratorTarget const*>, std::allocator<... | DirectoryObject::DirectoryObject(cmLocalGenerator const* lg,
std::string const& config,
TargetIndexMapType& targetIndexMap)
: LG(lg)
, Config(config)
, TargetIndexMap(targetIndexMap)
, TopSource(lg->GetGlobalGenerator()->GetCMakeInstance()->GetHo... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x18... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::DirectoryObject::DumpInstaller(cmInstallGenerator*) | Json::Value DirectoryObject::DumpInstaller(cmInstallGenerator* gen)
{
assert(gen);
Json::Value installer = Json::objectValue;
// Exclude subdirectory installers and file(GET_RUNTIME_DEPENDENCIES)
// installers. They are implementation details.
if (dynamic_cast<cmInstallSubdirectoryGenerator*>(gen) ||
d... | pushq %rbp
movq %rsp, %rbp
subq $0x1610, %rsp # imm = 0x1610
movq %rdi, -0x1100(%rbp)
movq %rdi, %rax
movq %rax, -0x10f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10f0(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5fa63c
jmp 0x5fa65b
leaq 0x5b2783(%rip)... | /JKorbelRA[P]CMake/Source/cmFileAPICodemodel.cxx |
(anonymous namespace)::CMakeFiles::DumpInput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Json::Value CMakeFiles::DumpInput(std::string const& file)
{
Json::Value input = Json::objectValue;
bool const isCMake = cmSystemTools::IsSubDirectory(file, this->CMakeModules);
if (isCMake) {
input["isCMake"] = true;
}
if (!cmSystemTools::IsSubDirectory(file, this->TopSource) &&
!cmSystemTools::I... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x120(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x7, %esi
callq 0x8d5360
movq -0x120(%rbp)... | /JKorbelRA[P]CMake/Source/cmFileAPICMakeFiles.cxx |
(anonymous namespace)::Toolchains::DumpToolchains() | Json::Value Toolchains::DumpToolchains()
{
Json::Value toolchains = Json::arrayValue;
for (std::string const& lang :
this->FileAPI.GetCMakeInstance()->GetState()->GetEnabledLanguages()) {
toolchains.append(this->DumpToolchain(lang));
}
return toolchains;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x6, %esi
callq 0x8d5360
movq -0x98(%rbp), %rax
movq (%rax), %rdi
callq 0x5dbb70
movq %rax, -0... | /JKorbelRA[P]CMake/Source/cmFileAPIToolchains.cxx |
(anonymous namespace)::Toolchains::DumpToolchain(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Json::Value Toolchains::DumpToolchain(std::string const& lang)
{
static const std::vector<ToolchainVariable> CompilerVariables{
{ "path", "COMPILER", false },
{ "id", "COMPILER_ID", false },
{ "version", "COMPILER_VERSION", false },
{ "target", "COMPILER_TARGET", false },
};
static const std::vec... | pushq %rbp
movq %rsp, %rbp
subq $0x570, %rsp # imm = 0x570
movq %rdi, -0x368(%rbp)
movq %rdi, %rax
movq %rax, -0x360(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x358(%rbp)
cmpb $0x0, 0x8fbd2e(%rip) # 0xf035b8
jne 0x607c5f
leaq 0x8fbd21(%rip... | /JKorbelRA[P]CMake/Source/cmFileAPIToolchains.cxx |
(anonymous namespace)::Toolchains::DumpToolchainVariables(cmMakefile const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<(anonymous namespace)::ToolchainVariable, std::allocator<(anonymous namespace)::ToolchainVariable>> const&) | Json::Value Toolchains::DumpToolchainVariables(
cmMakefile const* mf, std::string const& lang,
std::vector<ToolchainVariable> const& variables)
{
Json::Value object = Json::objectValue;
for (const auto& variable : variables) {
this->DumpToolchainVariable(mf, object, lang, variable);
}
return object;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x29(%rbp)
movl $0x7, %esi
callq 0x8d5360
m... | /JKorbelRA[P]CMake/Source/cmFileAPIToolchains.cxx |
(anonymous namespace)::Toolchains::DumpToolchainVariable(cmMakefile const*, Json::Value&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, (anonymous namespace)::ToolchainVariable const&) | void Toolchains::DumpToolchainVariable(cmMakefile const* mf,
Json::Value& object,
std::string const& lang,
ToolchainVariable const& variable)
{
std::string const variableName =
cmStrCat("CMAKE_", l... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x78(%rbp), %rdi
leaq 0x5541aa(%rip), %rsi # 0xb5ccc4
callq 0x62090
movq -0x20(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x61ca0
... | /JKorbelRA[P]CMake/Source/cmFileAPIToolchains.cxx |
cmFileCopier::CollectMatchProperties(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | cmFileCopier::MatchProperties cmFileCopier::CollectMatchProperties(
const std::string& file)
{
// Match rules are case-insensitive on some platforms.
#if defined(_WIN32) || defined(__APPLE__) || defined(__CYGWIN__)
const std::string file_to_match = cmSystemTools::LowerCase(file);
#else
const std::string& file_t... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x60d270
movq -0x50(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp... | /JKorbelRA[P]CMake/Source/cmFileCopier.cxx |
cmFileCopier::SetPermissions(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int) | bool cmFileCopier::SetPermissions(const std::string& toFile,
mode_t permissions)
{
if (permissions) {
#ifdef _WIN32
if (Makefile->IsOn("CMAKE_CROSSCOMPILING")) {
// Store the mode in an NTFS alternate stream.
std::string mode_t_adt_filename = toFile + ":cmake_mode_t";... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f8(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x609bac
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
callq 0x7fc030
movq %rax, -0x24(%rbp)... | /JKorbelRA[P]CMake/Source/cmFileCopier.cxx |
cmFileCopier::ReportMissing(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmFileCopier::ReportMissing(const std::string& fromFile)
{
// The input file does not exist and installation is not optional.
std::ostringstream e;
e << this->Name << " cannot find \"" << fromFile
<< "\": " << cmSystemTools::GetLastSystemError() << ".";
this->Status.SetError(e.str());
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x3c530
movq -0x1f0(%rbp), %rax
movq -0x1e8(%rbp), %rdi
movq 0x18(%rax), %rsi
callq 0x3d690
movq %rax, -0... | /JKorbelRA[P]CMake/Source/cmFileCopier.cxx |
cmFileCopier::DefaultFilePermissions() | void cmFileCopier::DefaultFilePermissions()
{
// Use read/write permissions.
this->FilePermissions = 0;
this->FilePermissions |= mode_owner_read;
this->FilePermissions |= mode_owner_write;
this->FilePermissions |= mode_group_read;
this->FilePermissions |= mode_world_read;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x64(%rax)
movl 0x64(%rax), %ecx
orl $0x100, %ecx # imm = 0x100
movl %ecx, 0x64(%rax)
movl 0x64(%rax), %ecx
orl $0x80, %ecx
movl %ecx, 0x64(%rax)
movl 0x64(%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0x64(%rax)
movl 0x64(%rax), %ecx... | /JKorbelRA[P]CMake/Source/cmFileCopier.cxx |
cmFileCopier::GetDefaultDirectoryPermissions(unsigned int**) | bool cmFileCopier::GetDefaultDirectoryPermissions(mode_t** mode)
{
// check if default dir creation permissions were set
cmValue default_dir_install_permissions = this->Makefile->GetDefinition(
"CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS");
if (cmNonempty(default_dir_install_permissions)) {
std::vector<s... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0xe0(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3c460
movq -0xd8(%rbp), %rdx
leaq 0x536a4b(%rip), %rsi #... | /JKorbelRA[P]CMake/Source/cmFileCopier.cxx |
cmGeneratorTarget::cmGeneratorTarget(cmTarget*, cmLocalGenerator*) | cmGeneratorTarget::cmGeneratorTarget(cmTarget* t, cmLocalGenerator* lg)
: Target(t)
{
this->Makefile = this->Target->GetMakefile();
this->LocalGenerator = lg;
this->GlobalGenerator = this->LocalGenerator->GetGlobalGenerator();
this->GlobalGenerator->ComputeTargetObjectDirectory(this);
CreatePropertyGenera... | pushq %rbp
movq %rsp, %rbp
subq $0x360, %rsp # imm = 0x360
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x110(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x20, %rdi
movq %rdi, -0x298(%rbp)
callq 0x3d1f0
movq -0x110(%rbp), %rdi
addq $0x40, %rdi... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
(anonymous namespace)::EvaluateTargetPropertyEntries(cmGeneratorTarget 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&, cmGeneratorExpressionDAGChecker*, std::vector<std::unique_ptr<cmGen... | EvaluatedTargetPropertyEntries EvaluateTargetPropertyEntries(
cmGeneratorTarget const* thisTarget, std::string const& config,
std::string const& lang, cmGeneratorExpressionDAGChecker* dagChecker,
std::vector<std::unique_ptr<cmGeneratorTarget::TargetPropertyEntry>> const&
in)
{
EvaluatedTargetPropertyEntries... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
callq 0x630790
movq -0x30(%rbp), %rdi
callq 0x66eda0
mov... | /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmInstallFileSetGenerator::Compute(cmLocalGenerator*) | bool cmInstallFileSetGenerator::Compute(cmLocalGenerator* lg)
{
this->LocalGenerator = lg;
// Lookup this target in the current directory.
this->Target = lg->FindLocalNonAliasGeneratorTarget(this->TargetName);
if (!this->Target) {
// If no local target has been found, find it in the global scope.
this-... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xe8(%rsi)
movq -0x10(%rbp), %rdi
addq $0xc8, %rsi
callq 0x1e0740
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x120(%rax)
cmpq $0x0, 0x120(%rax)
j... | /JKorbelRA[P]CMake/Source/cmInstallFileSetGenerator.cxx |
cmInstallDirectoryGenerator::cmInstallDirectoryGenerator(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::alloc... | cmInstallDirectoryGenerator::cmInstallDirectoryGenerator(
std::vector<std::string> const& dirs, std::string const& dest,
std::string file_permissions, std::string dir_permissions,
std::vector<std::string> const& configurations, std::string const& component,
MessageLevel message, bool exclude_from_all, std::stri... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %r8, -0xf8(%rbp)
movq %rcx, -0xf0(%rbp)
movq %rdx, %rax
movq -0xf0(%rbp), %rdx
movq %rax, -0xe8(%rbp)
movq %rsi, %rax
movq -0xe8(%rbp), %rsi
movq %rax, -0xe0(%rbp)
movq %rdi, %r10
movq -0xe0(%rbp), %rdi
movq 0x38(%rbp), %rax
movq %rax, -0xd8(%rb... | /JKorbelRA[P]CMake/Source/cmInstallDirectoryGenerator.cxx |
cmWindowsRegistry::ReadValue[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, cmWindowsRegistry::View, std::basic_string_view<char, std::char_traits<char>>) | cm::optional<std::string> cmWindowsRegistry::ReadValue(
cm::string_view key, cm::string_view name, View view,
cm::string_view separator)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
// compute list of registry views
auto views = this->ComputeViews(view);
if (Strucmp(name, "(default)") == 0) {
// handle ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x20(%rbp)
movq %rsi, -0x30(%rbp)
callq 0x3469d0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax... | /JKorbelRA[P]CMake/Source/cmWindowsRegistry.cxx |
(anonymous namespace)::Strucmp(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) | int Strucmp(cm::string_view l, cm::string_view r)
{
if (l.empty() && r.empty()) {
return 0;
}
if (l.empty() || r.empty()) {
return static_cast<int>(l.size() - r.size());
}
int lc;
int rc;
cm::string_view::size_type li = 0;
cm::string_view::size_type ri = 0;
do {
lc = std::tolower(l[li++]... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6d780
testb $0x1, %al
jne 0x72f207
jmp 0x72f222
leaq -0x28(%rbp), %rdi
callq 0x6d780
testb $0x1, %al
jne 0x72f216
jmp 0x72f222
movl $0x0, -0x4(%rbp)
jmp ... | /JKorbelRA[P]CMake/Source/cmWindowsRegistry.cxx |
cmConditionEvaluator::cmArgumentList::CurrentAndTwoMoreIter::CurrentAndTwoMoreIter(std::__cxx11::list<cmExpandedCommandArgument, std::allocator<cmExpandedCommandArgument>>&) | CurrentAndTwoMoreIter(base_t& args)
: current(args.begin())
, next(
std::next(this->current,
static_cast<difference_type>(this->current != args.end())))
, nextnext(std::next(
this->next, static_cast<difference_type>(this->next != args.end())))
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x736dc0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x736e20
movq -0x38(%... | /JKorbelRA[P]CMake/Source/cmConditionEvaluator.cxx |
cmFindBase::FillCMakeEnvironmentPath() | void cmFindBase::FillCMakeEnvironmentPath()
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::CMakeEnvironment];
// Add CMAKE_*_PATH environment variables
std::string var = cmStrCat("CMAKE_", this->CMakePathName, "_PATH");
paths.AddEnvPrefixPath("CMAKE_PREFIX_PATH");
paths.AddEnvPath(var);
if (this->C... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x140(%rbp)
addq $0xf8, %rdi
leaq 0x7bc908(%rip), %rsi # 0xf05890
callq 0x3fbd10
movq %rax, -0x10(%rbp)
leaq 0x413d2c(%rip), %rsi # 0xb5ccc4
leaq -0x60(%rbp), %rdi
movq %rdi, -0x138(%rbp)
... | /JKorbelRA[P]CMake/Source/cmFindBase.cxx |
(anonymous namespace)::entry_to_remove::entry_to_remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmMakefile*) | entry_to_remove(std::string const& name, cmMakefile* makefile)
: value()
{
if (cmValue to_skip = makefile->GetDefinition(
cmStrCat("_CMAKE_SYSTEM_PREFIX_PATH_", name, "_PREFIX_COUNT"))) {
cmStrToLong(to_skip, &count);
}
if (cmValue prefix_value = makefile->GetDefinition(
cmSt... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x150(%rbp)
movq $-0x1, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x148(%rbp)
callq 0x3d1f0
movq -0x18(%rbp), %rax
movq %rax, -0x140(%rbp)
leaq 0x44a248(%r... | /JKorbelRA[P]CMake/Source/cmFindBase.cxx |
cmFindCommon::GetIgnoredPaths(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | void cmFindCommon::GetIgnoredPaths(std::vector<std::string>& ignore)
{
static constexpr const char* paths[] = {
"CMAKE_SYSTEM_IGNORE_PATH",
"CMAKE_IGNORE_PATH",
};
// Construct the list of path roots with no trailing slashes.
for (const char* pathName : paths) {
// Get the list of paths to ignore f... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x7a15fb(%rip), %rax # 0xef0ae0
movq %rax, -0x18(%rbp)
leaq 0x7a15f0(%rip), %rax # 0xef0ae0
movq %rax, -0x20(%rbp)
leaq 0x7a15e5(%rip), %rax # 0xef0ae0
addq $0x10, %rax
mov... | /JKorbelRA[P]CMake/Source/cmFindCommon.cxx |
cmFindCommon::AddPathSuffix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmFindCommon::AddPathSuffix(std::string const& arg)
{
std::string suffix = arg;
// Strip leading and trailing slashes.
if (suffix.empty()) {
return;
}
if (suffix.front() == '/') {
suffix = suffix.substr(1);
}
if (suffix.empty()) {
return;
}
if (suffix.back() == '/') {
suffix = su... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3b400
leaq -0x30(%rbp), %rdi
callq 0x3b870
testb $0x1, %al
jne 0x74fada
jmp 0x74fae6
movl $0x1, -0x34(%rbp)
jmp 0x74fbf0
leaq -0x30(... | /JKorbelRA[P]CMake/Source/cmFindCommon.cxx |
cmScanDepFormat_P1689_Parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmScanDepInfo*) | bool cmScanDepFormat_P1689_Parse(std::string const& arg_pp,
cmScanDepInfo* info)
{
Json::Value ppio;
Json::Value const& ppi = ppio;
cmsys::ifstream ppf(arg_pp.c_str(), std::ios::in | std::ios::binary);
{
Json::Reader reader;
if (!reader.parse(ppf, ppio, false)) {
c... | pushq %rbp
movq %rsp, %rbp
subq $0x1840, %rsp # imm = 0x1840
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x1630(%rbp)
xorl %esi, %esi
callq 0x8d5360
movq -0x1630(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3cc60
movq %rax, -0x1628(%rbp)
movl $0x8, %ed... | /JKorbelRA[P]CMake/Source/cmScanDepFormat.cxx |
cmCommandArgument_yy_flush_buffer(yy_buffer_state*, void*) | void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if ( ! b )
return;
b->yy_n_chars = 0;
/* We always need two end-of-buffer characters. The first causes
* a transition to the end-of-buffer state. The second causes
* a jam in that state... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x757bc4
jmp 0x757c57
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%... | /JKorbelRA[P]CMake/Source/LexerParser/cmCommandArgumentLexer.cxx |
yy_try_NUL_trans(int, void*) | static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
{
int yy_is_jam;
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
char *yy_cp = yyg->yy_c_buf_p;
YY_CHAR yy_c = 1;
if ( yy_accept[yy_current_state] )
{
yyg->... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movb $0x1, -0x29(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x43ab42(%rip), %rax # 0xb94f70
cmpw $0x0, (%rax,%rcx,2)
je 0x75a44b
movl -0x4(... | /JKorbelRA[P]CMake/Source/LexerParser/cmExprLexer.cxx |
cmExpr_yy_init_buffer(yy_buffer_state*, _IO_FILE*, void*) | static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
{
int oerrno = errno;
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
yy_flush_buffer( b , yyscanner);
b->yy_input_file = file;
b->yy_fill_buffer = 1;
/* If b is the current buffer, then yy_init_buffer was _probably_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x3e130
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x75ade0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
mo... | /JKorbelRA[P]CMake/Source/LexerParser/cmExprLexer.cxx |
cmExpr_yylex_init_extra(cmExprParserHelper*, void**) | int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
{
struct yyguts_t dummy_yyguts;
yyset_extra (yy_user_defined, &dummy_yyguts);
if (ptr_yy_globals == NULL){
errno = EINVAL;
return 1;
}
*ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), ... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x75b490
cmpq $0x0, -0x18(%rbp)
jne 0x75b7ce
callq 0x3e130
movl $0x16, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x75b839
movl $0x90, %edi
leaq -0xa8(%rbp), %rsi
callq 0x75acd0
movq %rax,... | /JKorbelRA[P]CMake/Source/LexerParser/cmExprLexer.cxx |
cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool::GetFileInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std:... | bool cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool::GetFileInfo(
std::string const& file, std::vector<std::string>& needed,
std::vector<std::string>& rpaths, std::vector<std::string>& runpaths)
{
cmUVProcessChainBuilder builder;
builder.SetBuiltinStream(cmUVProcessChainBuilder::Stream_OUTPUT);
std::vec... | pushq %rbp
movq %rsp, %rbp
subq $0x800, %rsp # imm = 0x800
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, -0x768(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x760(%rbp)
callq 0x729450
movq -0x760(%rbp), %rdi
mov... | /JKorbelRA[P]CMake/Source/cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool.cxx |
cmBinUtilsMacOSMachOLinker::GetFileDependencies(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char... | bool cmBinUtilsMacOSMachOLinker::GetFileDependencies(
std::vector<std::string> const& names, std::string const& executablePath,
std::string const& loaderPath, std::vector<std::string> const& rpaths)
{
for (std::string const& name : names) {
if (!this->Archive->IsPreExcluded(name)) {
std::string path;
... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
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, -0xd8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x62f40
movq %r... | /JKorbelRA[P]CMake/Source/cmBinUtilsMacOSMachOLinker.cxx |
cmBinUtilsMacOSMachOLinker::ResolveDependency(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<s... | bool cmBinUtilsMacOSMachOLinker::ResolveDependency(
std::string const& name, std::string const& executablePath,
std::string const& loaderPath, std::vector<std::string> const& rpaths,
std::string& path, bool& resolved)
{
resolved = false;
if (cmHasLiteralPrefix(name, "@rpath/")) {
if (!this->ResolveRPathDe... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq 0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x3... | /JKorbelRA[P]CMake/Source/cmBinUtilsMacOSMachOLinker.cxx |
cmBinUtilsMacOSMachOLinker::ResolveRPathDependency(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vec... | bool cmBinUtilsMacOSMachOLinker::ResolveRPathDependency(
std::string const& name, std::string const& executablePath,
std::string const& loaderPath, std::vector<std::string> const& rpaths,
std::string& path, bool& resolved)
{
for (std::string const& rpath : rpaths) {
std::string searchFile = name;
search... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
cal... | /JKorbelRA[P]CMake/Source/cmBinUtilsMacOSMachOLinker.cxx |
cmBinUtilsMacOSMachOLinker::ResolveExecutablePathDependency(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool&... | bool cmBinUtilsMacOSMachOLinker::ResolveExecutablePathDependency(
std::string const& name, std::string const& executablePath,
std::string& path, bool& resolved)
{
if (executablePath.empty()) {
resolved = false;
return true;
}
// 16 is == "@executable_path".length()
path = name;
path.replace(0, 16... | 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 %r8, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3b870
testb $0x1, %al
jne 0x764e7b
jmp 0x764e88
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x764ed0
movq -0... | /JKorbelRA[P]CMake/Source/cmBinUtilsMacOSMachOLinker.cxx |
cmBinUtilsWindowsPELinker::Prepare() | bool cmBinUtilsWindowsPELinker::Prepare()
{
std::string tool = this->Archive->GetGetRuntimeDependenciesTool();
if (tool.empty()) {
std::vector<std::string> command;
if (this->Archive->GetGetRuntimeDependenciesCommand("dumpbin", command)) {
tool = "dumpbin";
} else {
tool = "objdump";
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x238(%rbp)
movq 0x8(%rax), %rdi
callq 0x7233a0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x3b400
leaq -0x30(%rbp), %rdi
callq 0x3b870
testb $0x1, %al
jne 0x767f81
jmp 0x76807c
leaq -0x48(%... | /JKorbelRA[P]CMake/Source/cmBinUtilsWindowsPELinker.cxx |
cmComputeComponentGraph::Tarjan() | void cmComputeComponentGraph::Tarjan()
{
int n = static_cast<int>(this->InputGraph.size());
TarjanEntry entry = { 0, 0 };
this->TarjanEntries.resize(0);
this->TarjanEntries.resize(n, entry);
this->TarjanComponents.resize(0);
this->TarjanComponents.resize(n, -1);
this->TarjanWalkId = 0;
this->TarjanVisit... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rdi
callq 0x577280
movl %eax, -0xc(%rbp)
leaq -0x14(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x3b780
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x76a6a... | /JKorbelRA[P]CMake/Source/cmComputeComponentGraph.cxx |
cmComputeLinkDepends::cmComputeLinkDepends(cmGeneratorTarget 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&) | cmComputeLinkDepends::cmComputeLinkDepends(const cmGeneratorTarget* target,
const std::string& config,
const std::string& linkLanguage)
{
// Store context information.
this->Target = target;
this->Makefile = this->Target->Target... | pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp # imm = 0x450
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2e0(%rbp)
addq $0x20, %rdi
movq %rdi, -0x318(%rbp)
callq 0x3d1f0
movq -0x2e0(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x310... | /JKorbelRA[P]CMake/Source/cmComputeLinkDepends.cxx |
cmComputeLinkDepends::InferDependencies() | void cmComputeLinkDepends::InferDependencies()
{
// The inferred dependency sets for each item list the possible
// dependencies. The intersection of the sets for one item form its
// inferred dependencies.
for (unsigned int depender_index = 0;
depender_index < this->InferredDependSets.size(); ++depende... | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x158(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x160(%rbp)
addq $0x1f0, %rdi # imm = 0x1F0
callq 0x777ca0
movq %rax, %rcx
movq -0x160(%rbp... | /JKorbelRA[P]CMake/Source/cmComputeLinkDepends.cxx |
cmComputeLinkDepends::CleanConstraintGraph() | void cmComputeLinkDepends::CleanConstraintGraph()
{
for (cmGraphEdgeList& edgeList : this->EntryConstraintGraph) {
// Sort the outgoing edges for each graph node so that the
// original order will be preserved as much as possible.
std::sort(edgeList.begin(), edgeList.end());
// Make the edge list uni... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x208, %rax # imm = 0x208
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x778290
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7782c0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rs... | /JKorbelRA[P]CMake/Source/cmComputeLinkDepends.cxx |
cmExportTryCompileFileGenerator::cmExportTryCompileFileGenerator(cmGlobalGenerator*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, cmMakefile*, std::set<std::__cxx11::bas... | cmExportTryCompileFileGenerator::cmExportTryCompileFileGenerator(
cmGlobalGenerator* gg, const std::vector<std::string>& targets,
cmMakefile* mf, std::set<std::string> const& langs)
: Languages(langs.begin(), langs.end())
{
gg->CreateImportedGenerationObjects(mf, targets, this->Exports);
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5a1980
movq -0x68(%rbp), %rdi
leaq 0x750529(%rip), %rax # 0xef1220
movq %rax, (%rdi)
addq $0x118, %rdi ... | /JKorbelRA[P]CMake/Source/cmExportTryCompileFileGenerator.cxx |
cmFileLock::~cmFileLock() | cmFileLock::~cmFileLock()
{
if (!this->Filename.empty()) {
const cmFileLockResult result = this->Release();
static_cast<void>(result);
assert(result.IsOk());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x3b870
testb $0x1, %al
jne 0x7a35f2
movq -0x18(%rbp), %rdi
callq 0x7a3610
movq %rax, -0x20(%rbp)
jmp 0x7a35b0
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0... | /JKorbelRA[P]CMake/Source/cmFileLock.cxx |
cmFileLock::LockWithTimeout(unsigned long) | cmFileLockResult cmFileLock::LockWithTimeout(unsigned long seconds)
{
while (true) {
if (this->LockFile(F_SETLK, F_WRLCK) == -1) {
if (errno != EACCES && errno != EAGAIN) {
return cmFileLockResult::MakeSystem();
}
} else {
return cmFileLockResult::MakeOk();
}
if (seconds == 0... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x6, %esi
movl $0x1, %edx
callq 0x7a3990
cmpl $-0x1, %eax
jne 0x7a38f1
callq 0x3e130
cmpl $0xd, (%rax)
je 0x7a38ef
callq 0x3e130
cmpl $0xb, (%rax)
je 0x7a3... | /JKorbelRA[P]CMake/Source/cmFileLockUnix.cxx |
cmGeneratorExpressionNode::GetNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | const cmGeneratorExpressionNode* cmGeneratorExpressionNode::GetNode(
const std::string& identifier)
{
static std::map<std::string, cmGeneratorExpressionNode const*> const nodeMap{
{ "0", &zeroNode },
{ "1", &oneNode },
{ "AND", &andNode },
{ "OR", &orNode },
{ "NOT", ¬Node },
{ "C_COMPILE... | pushq %rbp
movq %rsp, %rbp
subq $0x1120, %rsp # imm = 0x1120
movq %rdi, -0x10(%rbp)
cmpb $0x0, 0x75c632(%rip) # 0xf066d8
jne 0x7ab25b
leaq 0x75c625(%rip), %rdi # 0xf066d8
callq 0x3d080
cmpl $0x0, %eax
je 0x7ab25b
leaq -0xde0(%rbp), %rdi
movq %rdi, -0xde8(%rbp)
leaq 0x75c252(%rip), %rax # 0xf06328
mov... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
CompilerIdNode::EvaluateWithLanguage(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpression... | std::string EvaluateWithLanguage(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* /*unused*/,
... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x138(%rbp)
movq %rdi, %rax
movq %rax, -0x130(%rbp)
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
ConfigurationTestNode::Evaluate(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGCh... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override
{
if (parameters.empty()) {
return configurationNode.Evaluate(parameters, contex... | pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp # imm = 0x2A0
movq %rdi, -0x230(%rbp)
movq %rdi, %rax
movq %rax, -0x228(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x61d70
testb $0x1, %a... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
CompileLanguageNode::Evaluate(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGChec... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* dagChecker) const override
{
if (context->Language.empty() &&
(!dagChecker || !dagChecker->EvaluatingCompileE... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x128, %rdi ... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
CompileLanguageAndIdNode::Evaluate(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDA... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* dagChecker) const override
{
if (!context->HeadTarget ||
(context->Language.empty() &&
(!dagChecker ... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x148(%rax)
je 0x... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
LinkLanguageAndIdNode::Evaluate(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, cmGeneratorExpressionContext*, GeneratorExpressionContent const*, cmGeneratorExpressionDAGCh... | std::string Evaluate(
const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* dagChecker) const override
{
if (!context->HeadTarget || !dagChecker ||
!(dagChecker->EvaluatingLinkExpressio... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x148(%rbp)
movq %rdi, %rax
movq %rax, -0x140(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x148(%rax)
je 0x... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
TargetFilesystemArtifactResultCreator<ArtifactSonameTag>::Create[abi:cxx11](cmGeneratorTarget*, cmGeneratorExpressionContext*, GeneratorExpressionContent const*) | static std::string Create(cmGeneratorTarget* target,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content)
{
// The target soname file (.so.1).
if (target->IsDLLPlatform()) {
::reportError(context, content->GetOriginalEx... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x170(%rbp)
movq %rdi, %rax
movq %rax, -0x168(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6268d0
testb $0x1, %al
jne 0x7d182e
jmp 0x7d18eb
movq -0x18(%rbp... | /JKorbelRA[P]CMake/Source/cmGeneratorExpressionNode.cxx |
cmLinkItemGraphVisitor::VisitLinks(cmLinkItem const&, cmLinkItem const&) | void cmLinkItemGraphVisitor::VisitLinks(cmLinkItem const& item,
cmLinkItem const& rootItem)
{
if (item.Target == nullptr) {
return;
}
for (auto const& config : item.Target->Makefile->GetGeneratorConfigs(
cmMakefile::IncludeEmptyConfig)) {
this->VisitLinks(... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x7daddc
jmp 0x7dae79
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rsi
leaq -0x38(%rbp), %rdi
xor... | /JKorbelRA[P]CMake/Source/cmLinkItemGraphVisitor.cxx |
cm::uv_handle_ptr_base_<uv_pipe_s>::allocate(void*) | void uv_handle_ptr_base_<T>::allocate(void* data)
{
this->reset();
/*
We use calloc since we know all these types are c structs
and we just want to 0 init them. New would do the same thing;
but casting from uv_handle_t to certain other types -- namely
uv_timer_t -- triggers a cast_align warning on ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x7df200
movl $0x1, %edi
movl $0x108, %esi # imm = 0x108
callq 0x3e570
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x7df220
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %ra... | /JKorbelRA[P]CMake/Source/cmUVHandlePtr.cxx |
cmGccDepfile_yyrestart(_IO_FILE*, void*) | void yyrestart (FILE * input_file , yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if ( ! YY_CURRENT_BUFFER ){
yyensure_buffer_stack (yyscanner);
YY_CURRENT_BUFFER_LVALUE =
yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
}
yy_init_buffer( YY_CURRENT_BUFFER, ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x7e8fdd
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0... | /JKorbelRA[P]CMake/Source/LexerParser/cmGccDepfileLexer.cxx |
kwsysProcessFork | static pid_t kwsysProcessFork(kwsysProcess* cp,
kwsysProcessCreateInformation* si)
{
/* Create a detached process if requested. */
if (cp->OptionDetach) {
/* Create an intermediate process. */
pid_t middle_pid = fork();
if (middle_pid < 0) {
/* Fork failed. Return ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x448(%rax)
je 0x7eea04
callq 0x3dfb0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x7ee91a
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7eea0c
cmpl $0x0, -0x1c(%rbp)
jne 0x7ee989
callq... | /JKorbelRA[P]CMake/Source/kwsys/ProcessUNIX.c |
cmsys::Glob::ProcessDirectory(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<cmsys::Glob::Message, std::allocator<cmsys::Glob::Message>>*) | void Glob::ProcessDirectory(std::string::size_type start,
const std::string& dir, GlobMessages* messages)
{
// std::cout << "ProcessDirectory: " << dir << std::endl;
bool last = (start == this->Internals->Expressions.size() - 1);
if (last && this->Recurse) {
if (kwsys::SystemTools:... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0xf8(%rbp)
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x88960
movq %rax, %rcx
mo... | /JKorbelRA[P]CMake/Source/kwsys/Glob.cxx |
cmsys::RegularExpression::operator==(cmsys::RegularExpression const&) const | bool RegularExpression::operator==(const RegularExpression& rxp) const
{
if (this != &rxp) { // Same address?
int ind = this->progsize; // Get regular expression size
if (ind != rxp.progsize) // If different size regexp
return false; // Return failure
while (ind-- != 0) // ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq -0x18(%rbp), %rax
je 0x7f6212
movq -0x28(%rbp), %rax
movl 0xc8(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc8(%rcx), %eax
je 0x7f61cc
movb $0x0, -0x1(%r... | /JKorbelRA[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::RegExpCompile::reg(int, int*) | char* RegExpCompile::reg(int paren, int* flagp)
{
char* ret;
char* br;
char* ender;
int parno = 0;
int flags;
*flagp = HASWIDTH; // Tentatively.
// Make an OPEN node, if parenthesized.
if (paren) {
if (regnpar >= RegularExpressionMatch::NSUBEXP) {
// RAISE Error, SYM(RegularExpression), SYM(... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
cmpl $0x0, -0x14(%rbp)
je 0x7f665e
movq -0x48(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jl 0x7f6637
leaq 0... | /JKorbelRA[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::regnext(char const*) | static const char* regnext(const char* p)
{
int offset;
if (p == regdummyptr)
return (nullptr);
offset = NEXT(p);
if (offset == 0)
return (nullptr);
if (OP(p) == BACK)
return (p - offset);
else
return (p + offset);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0x710963(%rip), %rax # 0xf071b2
cmpq %rax, -0x10(%rbp)
jne 0x7f685f
movq $0x0, -0x8(%rbp)
jmp 0x7f68c3
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xff, %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
andl $0xff, %ecx
addl %ecx, %eax
m... | /JKorbelRA[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::RegExpCompile::regnode(char) | char* RegExpCompile::regnode(char op)
{
char* ret;
char* ptr;
ret = regcode;
if (ret == regdummyptr) {
regsize += 3;
return (ret);
}
ptr = ret;
*ptr++ = op;
*ptr++ = '\0'; // Null "next" pointer.
*ptr++ = '\0';
regcode = ptr;
return (ret);
} | pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x7108bd(%rip), %rax # 0xf071b2
cmpq %rax, -0x20(%rbp)
jne 0x7f6915
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x3, %rcx
movq ... | /JKorbelRA[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::RegExpFind::regmatch(char const*) | int RegExpFind::regmatch(const char* prog)
{
const char* scan; // Current node.
const char* next; // Next node.
scan = prog;
while (scan != nullptr) {
next = regnext(scan);
switch (OP(scan)) {
case BOL:
if (reginput != regbol)
return (0);
break;
case EOL:
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7f7bd3
movq -0x20(%rbp), %rdi
callq 0x7f6840
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax... | /JKorbelRA[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::kwsysUnPutEnv(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static int kwsysUnPutEnv(const std::string& env)
{
size_t pos = env.find('=');
if (pos != std::string::npos) {
std::string name = env.substr(0, pos);
unsetenv(name.c_str());
} else {
unsetenv(env.c_str());
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3d, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e350
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0x7f84ba
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rcx
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::PathExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool SystemTools::PathExists(const std::string& path)
{
if (path.empty()) {
return false;
}
#if defined(_WIN32)
return (GetFileAttributesW(Encoding::ToWindowsExtendedPath(path).c_str()) !=
INVALID_FILE_ATTRIBUTES);
#else
struct stat st;
return lstat(path.c_str(), &st) == 0;
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b870
testb $0x1, %al
jne 0x7f883e
jmp 0x7f8844
movb $0x0, -0x1(%rbp)
jmp 0x7f8867
movq -0x10(%rbp), %rdi
callq 0x3cc60
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3b610
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al,... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::CapitalizedWords(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SystemTools::CapitalizedWords(const std::string& s)
{
std::string n(s);
for (size_t i = 0; i < s.size(); i++) {
#if defined(_MSC_VER) && defined(_MT) && defined(_DEBUG)
// MS has an assert that will fail if s[i] < 0; setting
// LC_CTYPE using setlocale() does *not* help. Painful.
if ((int)s[... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3b400
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d070
mov... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::AppendStrings(char const*, char const*, char const*) | char* SystemTools::AppendStrings(const char* str1, const char* str2,
const char* str3)
{
if (!str1) {
return SystemTools::AppendStrings(str2, str3);
}
if (!str2) {
return SystemTools::AppendStrings(str1, str3);
}
if (!str3) {
return SystemTools::AppendStrings(str1,... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7f9971
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7f9830
movq %rax, -0x8(%rbp)
jmp 0x7f9a3a
cmpq $0x0, -0x18(%rbp)
jne 0x7f998e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp)... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemTools::CropString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | std::string SystemTools::CropString(const std::string& s, size_t max_len)
{
if (s.empty() || max_len == 0 || max_len >= s.size()) {
return s;
}
std::string n;
n.reserve(max_len);
size_t middle = max_len / 2;
n.assign(s, 0, middle);
n += s.substr(s.size() - (max_len - middle));
if (max_len > 2) {... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b870
testb $0x1, %al
jne 0x7fa1c3
cmpq $0x0, -0x18(%rbp)
je 0x7fa1c3
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)... | /JKorbelRA[P]CMake/Source/kwsys/SystemTools.cxx |
cmsys::SystemInformationImplementation::QueryMemoryBySysconf() | bool SystemInformationImplementation::QueryMemoryBySysconf()
{
#if defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE)
// Assume the mmap() granularity as returned by _SC_PAGESIZE is also
// the system page size. The only known system where this isn't true
// is Cygwin.
long p = sysconf(_SC_PHYS_PAGES);
long m =... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x55, %edi
callq 0x3d530
movq %rax, -0x18(%rbp)
movl $0x1e, %edi
callq 0x3d530
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x809b1e
cmpq $0x0, -0x20(%rbp)
jge 0x809b27
movb $0x0, -0x1(%rbp)
jmp 0x... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::CPUCountWindows() | void SystemInformationImplementation::CPUCountWindows()
{
#if defined(_WIN32)
this->NumberOfPhysicalCPU = 0;
this->NumberOfLogicalCPU = 0;
typedef BOOL(WINAPI * GetLogicalProcessorInformationType)(
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, PDWORD);
static GetLogicalProcessorInformationType pGetLogicalProcesso... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::ExtractValueFromSysCtl[abi:cxx11](char const*) | std::string SystemInformationImplementation::ExtractValueFromSysCtl(
const char* word)
{
size_t pos = this->SysCtlBuffer.find(word);
if (pos != std::string::npos) {
pos = this->SysCtlBuffer.find(": ", pos);
size_t pos2 = this->SysCtlBuffer.find('\n', pos);
if (pos != std::string::npos && pos2 != std::... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0xe0, %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3b3c0
movq %rax, -0x... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::QuerySolarisProcessor() | bool SystemInformationImplementation::QuerySolarisProcessor()
{
if (!this->QueryProcessorBySysconf()) {
return false;
}
// Parse values
this->CPUSpeedInMHz = static_cast<float>(
atoi(this->ParseValueFromKStat("-s clock_MHz").c_str()));
// Chip family
this->ChipID.Family = 0;
// Chip Model
thi... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x808b20
testb $0x1, %al
jne 0x80a89c
movb $0x0, -0x1(%rbp)
jmp 0x80a9ea
movq -0x90(%rbp), %rsi
leaq -0x30(%rbp), %rdi
leaq 0x394aee(%rip), %rdx # 0xb9f39c
callq 0x80a190
leaq -0x30(%rbp), %rdi
call... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::QueryQNXMemory() | bool SystemInformationImplementation::QueryQNXMemory()
{
#if defined(__QNX__)
std::string buffer;
std::vector<const char*> args;
args.clear();
args.push_back("showmem");
args.push_back("-S");
args.push_back(0);
buffer = this->RunProcess(args);
args.clear();
size_t pos = buffer.find("System RAM:");
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
andb $0x1, %al
popq %rbp
retq
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::QueryQNXProcessor() | bool SystemInformationImplementation::QueryQNXProcessor()
{
#if defined(__QNX__)
// the output on my QNX 6.4.1 looks like this:
// Processor1: 686 Pentium II Stepping 3 2175MHz FPU
std::string buffer;
std::vector<const char*> args;
args.clear();
args.push_back("pidin");
args.push_back("info");
args.pus... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
andb $0x1, %al
popq %rbp
retq
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::SystemInformationImplementation::QueryHPUXMemory() | bool SystemInformationImplementation::QueryHPUXMemory()
{
#if defined(__hpux)
unsigned long tv = 0;
unsigned long tp = 0;
unsigned long av = 0;
unsigned long ap = 0;
struct pst_static pst;
struct pst_dynamic pdy;
unsigned long ps = 0;
if (pstat_getstatic(&pst, sizeof(pst), (size_t)1, 0) == -1) {
re... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
andb $0x1, %al
popq %rbp
retq
nop
| /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsys::(anonymous namespace)::SymbolProperties::GetBinary[abi:cxx11]() const | std::string SymbolProperties::GetBinary() const
{
// only linux has proc fs
# if defined(__linux__)
if (this->Binary == "/proc/self/exe") {
std::string binary;
char buf[1024] = { '\0' };
ssize_t ll = 0;
if ((ll = readlink("/proc/self/exe", buf, 1024)) > 0 && ll < 1024) {
buf[ll] = '\0';
b... | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x460(%rbp)
movq %rdi, %rax
movq %rax, -0x458(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x450(%rbp)
leaq 0x394488(%rip), %rsi # 0xb9f3be
callq 0x85b10
testb $0x1, %al
jne 0x80af44
jmp 0x80b01... | /JKorbelRA[P]CMake/Source/kwsys/SystemInformation.cxx |
cmsysEncoding_DupToWide | wchar_t* kwsysEncoding_DupToWide(const char* str)
{
wchar_t* ret = NULL;
size_t length = kwsysEncoding_mbstowcs(NULL, str, 0) + 1;
if (length > 0) {
ret = (wchar_t*)malloc((length) * sizeof(wchar_t));
if (ret) {
ret[0] = 0;
kwsysEncoding_mbstowcs(ret, str, length);
}
}
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
callq 0x80be00
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x80beb8
movq -0x18(%rbp), %rdi
shlq $0x2, %rdi
callq 0x3e578
movq %rax, -0x10(%... | /JKorbelRA[P]CMake/Source/kwsys/EncodingC.c |
curl_global_init_mem | CURLcode curl_global_init_mem(long flags, curl_malloc_callback m,
curl_free_callback f, curl_realloc_callback r,
curl_strdup_callback s, curl_calloc_callback c)
{
CURLcode result;
/* Invalid input, return immediately */
if(!m || !f || !r || !s || !c)
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x80c0d3
cmpq $0x0, -0x20(%rbp)
je 0x80c0d3
cmpq $0x0, -0x28(%rbp)
je 0x80c0d3
cmpq $0x0, -0x30(%rbp)
je 0x80c0d3
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/easy.c |
curl_easy_init | struct Curl_easy *curl_easy_init(void)
{
CURLcode result;
struct Curl_easy *data;
/* Make sure we inited the global SSL stuff */
global_init_lock();
if(!initialized) {
result = global_init(CURL_GLOBAL_DEFAULT, TRUE);
if(result) {
/* something in the global init failed, return nothing */
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x6fb471(%rip) # 0xf07650
jne 0x80c209
movl $0x3, %edi
movl $0x1, %esi
callq 0x80bfc0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x80c207
jmp 0x80c1fb
jmp 0x80c1fd
movq $0x0, -0x8(%rbp)
jmp 0x80c231
jmp 0x80c209
leaq -0x18(%rbp), %rdi
callq 0x835b00
movl %ea... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/easy.c |
curl_easy_cleanup | void curl_easy_cleanup(struct Curl_easy *data)
{
SIGPIPE_VARIABLE(pipe_st);
if(!data)
return;
sigpipe_ignore(data, &pipe_st);
Curl_close(&data);
sigpipe_restore(&pipe_st);
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x80c438
jmp 0x80c45d
movq -0x8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x80c470
leaq -0x8(%rbp), %rdi
callq 0x834e30
leaq -0xa8(%rbp), %rdi
callq 0x80c530
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/easy.c |
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.