name string | code string | asm string | file string |
|---|---|---|---|
cmSourceGroupCommand(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&, cmExecutionStatus&) | bool cmSourceGroupCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
status.SetError("called with incorrect number of arguments");
return false;
}
cmMakefile& mf = status.GetMakefile();
// If only two arguments are given, the pre-1.... | pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp # imm = 0x2A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61d70
testb $0x1, %al
jne 0x4929d5
jmp 0x492a67
movq -0x18(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0x3c460
movq -0x1e0(%rbp)... | /JKorbelRA[P]CMake/Source/cmSourceGroupCommand.cxx |
processTree(cmMakefile&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>>>, std::less<std::__... | static bool processTree(cmMakefile& mf, ParsedArguments& parsedArguments,
std::string& errorMsg)
{
const std::string root =
cmSystemTools::CollapseFullPath(parsedArguments[kTreeOptionName].front());
std::string prefix = parsedArguments[kPrefixOptionName].empty()
? ""
: parsedArgu... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xa6f6ae(%rip), %rsi # 0xf02a50
callq 0x494050
movq %rax, %rdi
callq 0x1a0d40
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x7fce70
movq -0x18(%rbp), %rdi
movb $0x0, -0x6e(%rbp... | /JKorbelRA[P]CMake/Source/cmSourceGroupCommand.cxx |
checkSingleParameterArgumentPreconditions(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::alloc... | static bool checkSingleParameterArgumentPreconditions(
const std::string& argument, const ParsedArguments& parsedArguments,
std::string& errorMsg)
{
auto foundArgument = parsedArguments.find(argument);
if (foundArgument != parsedArguments.end()) {
const std::vector<std::string>& optionArguments = foundArgum... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4941c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3da4c0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4941f0
t... | /JKorbelRA[P]CMake/Source/cmSourceGroupCommand.cxx |
(anonymous namespace)::rootIsPrefix(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::allocator<char>>>> const&, s... | bool rootIsPrefix(const std::string& root,
const std::vector<std::string>& files, std::string& error)
{
for (std::string const& file : files) {
if (!cmHasPrefix(file, root)) {
error = cmStrCat("ROOT: ", root, " is not a prefix of file: ", file);
return false;
}
}
return true... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x62f40
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x62f70
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), ... | /JKorbelRA[P]CMake/Source/cmSourceGroupCommand.cxx |
(anonymous namespace)::getSourceGroupFilesPaths(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::allocator<char>>... | std::set<std::string> getSourceGroupFilesPaths(
const std::string& root, const std::vector<std::string>& files)
{
std::set<std::string> ret;
const std::string::size_type rootLength = root.length();
for (std::string const& file : files) {
ret.insert(file.substr(rootLength + 1)); // +1 to also omnit last '/'... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xdefc0
movq -0x10(%rbp), %rdi
callq 0x3be30
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
mov... | /JKorbelRA[P]CMake/Source/cmSourceGroupCommand.cxx |
(anonymous namespace)::HandleReplaceCommand(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&, cmExecutionStatus&) | bool HandleReplaceCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 5) {
status.SetError("sub-command REPLACE requires at least four arguments.");
return false;
}
const std::string& matchExpression = args[1];
const std::string& replac... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x5, %rax
jae 0x4982f8
movq -0x18(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x3c460
movq -0x100(%rbp), %rdx
leaq 0... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleLengthCommand(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&, cmExecutionStatus&) | bool HandleLengthCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 3) {
status.SetError("sub-command LENGTH requires two arguments.");
return false;
}
const std::string& stringValue = args[1];
const std::string& variableName = args[2]... | pushq %rbp
movq %rsp, %rbp
subq $0x4a0, %rsp # imm = 0x4A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
je 0x499608
movq -0x18(%rbp), %rax
movq %rax, -0x490(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x488(%rbp)
callq 0x3c460
movq -0x488(%rbp), %rdx
leaq 0x... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandlePrependCommand(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&, cmExecutionStatus&) | bool HandlePrependCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 2) {
status.SetError("sub-command PREPEND requires at least one argument.");
return false;
}
// Skip if nothing to prepend.
if (args.size() < 3) {
return true;
... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x2, %rax
jae 0x4999b8
movq -0x18(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x3c460
movq -0xf8(%rbp), %rdx
leaq 0x6... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleSubstringCommand(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&, cmExecutionStatus&) | bool HandleSubstringCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 5) {
status.SetError("sub-command SUBSTRING requires four arguments.");
return false;
}
const std::string& stringValue = args[1];
int begin = atoi(args[2].c_str(... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x5, %rax
je 0x499e88
movq -0x18(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x3c460
movq -0x1b0(%rbp), %rdx
leaq 0x... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleStripCommand(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&, cmExecutionStatus&) | bool HandleStripCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 3) {
status.SetError("sub-command STRIP requires two arguments.");
return false;
}
const std::string& stringValue = args[1];
const std::string& variableName = args[2];
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
je 0x49a1e8
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3c460
movq -0xc8(%rbp), %rdx
leaq 0x6df7f7(%rip), %rsi # 0xb79... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleTimestampCommand(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&, cmExecutionStatus&) | bool HandleTimestampCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 2) {
status.SetError("sub-command TIMESTAMP requires at least one argument.");
return false;
}
if (args.size() > 4) {
status.SetError("sub-command TIMESTAMP take... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x2, %rax
jae 0x49b378
movq -0x18(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x3c460
movq -0x128(%rbp), %rdx
leaq 0... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleMakeCIdentifierCommand(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&, cmExecutionStatus&) | bool HandleMakeCIdentifierCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 3) {
status.SetError("sub-command MAKE_C_IDENTIFIER requires two arguments.");
return false;
}
const std::string& input = args[1];
const std::string&... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
je 0x49b768
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3c460
movq -0x98(%rbp), %rdx
leaq 0x6de4d4(%rip), %rsi # 0xb79... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleUuidCommand(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&, cmExecutionStatus&) | bool HandleUuidCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
#if !defined(CMAKE_BOOTSTRAP)
unsigned int argsIndex = 1;
if (args.size() < 2) {
status.SetError("UUID sub-command requires an output variable.");
return false;
}
const std::string& outputV... | pushq %rbp
movq %rsp, %rbp
subq $0x360, %rsp # imm = 0x360
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x2, %rax
jae 0x49ba8f
movq -0x18(%rbp), %rax
movq %rax, -0x2d0(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
callq 0x3c460
movq -0... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleJSONCommand(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&, cmExecutionStatus&) | bool HandleJSONCommand(std::vector<std::string> const& arguments,
cmExecutionStatus& status)
{
#if !defined(CMAKE_BOOTSTRAP)
auto& makefile = status.GetMakefile();
Args args{ arguments.begin() + 1, arguments.end() };
const std::string* errorVariable = nullptr;
const std::string* outputV... | pushq %rbp
movq %rsp, %rbp
subq $0x11b0, %rsp # imm = 0x11B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2bfb20
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x62f40
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x23ef70
movq %rax, -0x30(%rbp)
movq -0... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::RegexMatch(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&, cmExecutionStatus&) | bool RegexMatch(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
//"STRING(REGEX MATCH <regular_expression> <output variable>
// <input> [<input>...])\n";
std::string const& regex = args[2];
std::string const& outvar = args[3];
status.GetMakefile().ClearMatches();
// Compi... | pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp # imm = 0x2E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6d540
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x6d540
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bfb20
movq %rax, %rd... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::RegexMatchAll(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&, cmExecutionStatus&) | bool RegexMatchAll(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
//"STRING(REGEX MATCHALL <regular_expression> <output variable> <input>
// [<input>...])\n";
std::string const& regex = args[2];
std::string const& outvar = args[3];
status.GetMakefile().ClearMatches();
... | pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6d540
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x6d540
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bfb20
movq %rax, %rd... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::HandleToUpperLowerCommand(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&, bool, cmExecutionStatus&) | bool HandleToUpperLowerCommand(std::vector<std::string> const& args,
bool toUpper, cmExecutionStatus& status)
{
if (args.size() < 3) {
status.SetError("no output variable specified");
return false;
}
std::string const& outvar = args[2];
std::string output;
if (toUpper)... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c70
cmpq $0x3, %rax
jae 0x49fcf0
movq -0x20(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3c460
movq -... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::joinImpl(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>> const&, unsig... | bool joinImpl(std::vector<std::string> const& args, std::string const& glue,
const size_t varIdx, cmMakefile& makefile)
{
std::string const& variableName = args[varIdx];
// NOTE Items to concat/join placed right after the variable for
// both `CONCAT` and `JOIN` sub-commands.
std::string value = c... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6d540
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2dd7a0
movq %rax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq -0x18(%rbp), %r... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::ResolvePath(Json::Value&, (anonymous namespace)::Args) | Json::Value& ResolvePath(Json::Value& json, Args path)
{
Json::Value* search = &json;
for (auto curr = path.begin(); curr != path.end(); ++curr) {
const std::string& field = *curr;
Args progress{ path.begin(), curr + 1 };
if (search->isArray()) {
auto index = ParseIndex(field, progress, search->... | pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2cea00
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2cea20
movq %rax, -0x30(%rbp)
leaq -0x28(%rb... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::JsonTypeToString(Json::ValueType) | cm::string_view JsonTypeToString(Json::ValueType type)
{
switch (type) {
case Json::ValueType::nullValue:
return "NULL"_s;
case Json::ValueType::intValue:
case Json::ValueType::uintValue:
case Json::ValueType::realValue:
return "NUMBER"_s;
case Json::ValueType::stringValue:
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movl %edi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0xe8(%rbp)
subq $0x7, %rax
ja 0x4a0e5d
movq -0xe8(%rbp), %rax
leaq 0x6d8680(%rip), %rcx # 0xb793c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x73cd75(%rip), %rdi # 0xbdd... | /JKorbelRA[P]CMake/Source/cmStringCommand.cxx |
(anonymous namespace)::TargetCompileDefinitionsImpl::Join(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::string Join(const std::vector<std::string>& content) override
{
std::string defs;
std::string sep;
for (std::string const& it : content) {
if (cmHasLiteralPrefix(it, "-D")) {
defs += sep + it.substr(2);
} else {
defs += sep + it;
}
sep = ";";
}
return d... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3d1f0
leaq -0x40(%rbp), %rdi
callq 0x3d1f0
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
... | /JKorbelRA[P]CMake/Source/cmTargetCompileDefinitionsCommand.cxx |
cmTargetIncludeDirectoriesCommand(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&, cmExecutionStatus&) | bool cmTargetIncludeDirectoriesCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
return TargetIncludeDirectoriesImpl(status).HandleArguments(
args, "INCLUDE_DIRECTORIES",
static_cast<TargetIncludeDirectoriesImpl::ArgumentFlags>(
TargetInclu... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x4a59e0
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3c460
movq -0x90(%rbp), %rdx
leaq 0x6ab90e(%rip), %rsi # 0xb51247
le... | /JKorbelRA[P]CMake/Source/cmTargetIncludeDirectoriesCommand.cxx |
(anonymous namespace)::TargetIncludeDirectoriesImpl::HandleInterfaceContent(cmTarget*, 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&, bool, bool) | void TargetIncludeDirectoriesImpl::HandleInterfaceContent(
cmTarget* tgt, const std::vector<std::string>& content, bool prepend,
bool system)
{
this->cmTargetPropCommandBase::HandleInterfaceContent(tgt, content, prepend,
system);
if (system) {
std::str... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %cl
movb -... | /JKorbelRA[P]CMake/Source/cmTargetIncludeDirectoriesCommand.cxx |
LinkLibraryTypeSpecifierWarning(cmMakefile&, int, int) | static void LinkLibraryTypeSpecifierWarning(cmMakefile& mf, int left,
int right)
{
mf.IssueMessage(
MessageType::AUTHOR_WARNING,
cmStrCat(
"Link library type specifier \"", LinkLibraryTypeNames[left],
"\" is followed by specifier \"", LinkLibraryTypeName... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq 0x6d1983(%rip), %rsi # 0xb7a77a
leaq -0x60(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x62090
movslq -0xc(%rbp), %rcx
leaq 0xa531de(%rip), %rax # 0xefbff0
... | /JKorbelRA[P]CMake/Source/cmTargetLinkLibrariesCommand.cxx |
(anonymous namespace)::TLL::HandleLibrary((anonymous namespace)::ProcessingState, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmTargetLinkLibraryType) | bool TLL::HandleLibrary(ProcessingState currentProcessingState,
const std::string& lib, cmTargetLinkLibraryType llt)
{
if (this->Target->GetType() == cmStateEnums::INTERFACE_LIBRARY &&
currentProcessingState != ProcessingKeywordLinkInterface) {
this->Makefile.IssueMessage(
Mess... | pushq %rbp
movq %rsp, %rbp
subq $0x820, %rsp # imm = 0x820
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x6c8(%rbp)
movq 0x8(%rax), %rdi
callq 0x2ebc90
cmpl $0x7, %eax
jne 0x4a8f9d
cmpl $0x2, -0x14(%rbp)
je 0x4a8f9d
movq -0x6c8... | /JKorbelRA[P]CMake/Source/cmTargetLinkLibrariesCommand.cxx |
(anonymous namespace)::TLL::AffectsProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void TLL::AffectsProperty(std::string const& prop)
{
if (!this->EncodeRemoteReference) {
return;
}
// Add a wrapper to the expression to tell LookupLinkItem to look up
// names in the caller's directory.
if (this->Props.insert(prop).second) {
this->Target->AppendProperty(prop, this->DirectoryId,
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
testb $0x1, 0x12(%rax)
jne 0x4aa1b6
jmp 0x4aa283
movq -0x70(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x1a4620
movb %dl, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rb... | /JKorbelRA[P]CMake/Source/cmTargetLinkLibrariesCommand.cxx |
(anonymous namespace)::ConvertToAbsoluteContent(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... | std::vector<std::string> ConvertToAbsoluteContent(
const std::vector<std::string>& content, std::string const& baseDir)
{
std::vector<std::string> absoluteContent;
absoluteContent.reserve(content.size());
for (std::string const& src : content) {
std::string absoluteSrc;
// Use '<foo.h>' and '"foo.h"' in... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x118(%rbp)
movq %rdi, %rax
movq %rax, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x60530
movq -0x10(%rbp), %rdi
callq 0x60c70
movq -0x118(%rbp), %rdi
movq %rax, %rsi
call... | /JKorbelRA[P]CMake/Source/cmTargetPrecompileHeadersCommand.cxx |
cmTargetPropCommandBase::ProcessContentArgs(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&, unsigned int&, bool, bool) | bool cmTargetPropCommandBase::ProcessContentArgs(
std::vector<std::string> const& args, unsigned int& argIndex, bool prepend,
bool system)
{
std::string const& scope = args[argIndex];
if (scope != "PUBLIC" && scope != "PRIVATE" && scope != "INTERFACE") {
this->SetError("called with invalid arguments");
... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %cl
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax... | /JKorbelRA[P]CMake/Source/cmTargetPropCommandBase.cxx |
cmTargetPropCommandBase::PopulateTargetProperties(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::allocator<char... | bool cmTargetPropCommandBase::PopulateTargetProperties(
const std::string& scope, const std::vector<std::string>& content,
bool prepend, bool system)
{
if (content.empty()) {
return true;
}
if (scope == "PRIVATE" || scope == "PUBLIC") {
if (!this->HandleDirectContent(this->Target, content, prepend, sy... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %cl
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x61d70
testb $0x1, %al
jne 0x4ac1a9
jmp 0x... | /JKorbelRA[P]CMake/Source/cmTargetPropCommandBase.cxx |
(anonymous namespace)::TargetSourcesImpl::HandleDirectContent(cmTarget*, 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&, bool, bool) | bool HandleDirectContent(cmTarget* tgt,
const std::vector<std::string>& content,
bool /*prepend*/, bool /*system*/) override
{
tgt->AppendProperty("SOURCES",
this->Join(this->ConvertToAbsoluteContent(
tgt, cont... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x41(%rbp), %rdi
movq ... | /JKorbelRA[P]CMake/Source/cmTargetSourcesCommand.cxx |
(anonymous namespace)::TargetSourcesImpl::ConvertToAbsoluteContent(cmTarget*, 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&, (anonymous namespace)::TargetSourcesImpl::IsIn... | std::vector<std::string> TargetSourcesImpl::ConvertToAbsoluteContent(
cmTarget* tgt, const std::vector<std::string>& content,
IsInterface isInterfaceContent, CheckCMP0076 checkCmp0076)
{
// Skip conversion in case old behavior has been explicitly requested
if (checkCmp0076 == CheckCMP0076::Yes &&
this->Ma... | pushq %rbp
movq %rsp, %rbp
subq $0x3b0, %rsp # imm = 0x3B0
movq %rdi, -0x310(%rbp)
movq %rdi, %rax
movq %rax, -0x308(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x300(%rbp)
cm... | /JKorbelRA[P]CMake/Source/cmTargetSourcesCommand.cxx |
cmTimestamp::CurrentTime(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const | std::string cmTimestamp::CurrentTime(const std::string& formatString,
bool utcFlag) const
{
// get current time with microsecond resolution
uv_timeval64_t timeval;
uv_gettimeofday(&timeval);
auto currentTimeT = static_cast<time_t>(timeval.tv_sec);
auto microseconds = stati... | pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq %rdi, -0x258(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x250(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x248(%rbp)
leaq -0x30(%rbp), %r... | /JKorbelRA[P]CMake/Source/cmTimestamp.cxx |
cmGlobalNinjaGenerator::AddRule(cmNinjaRule const&) | void cmGlobalNinjaGenerator::AddRule(cmNinjaRule const& rule)
{
// Do not add the same rule twice.
if (!this->Rules.insert(rule.Name).second) {
return;
}
// Store command length
this->RuleCmdLength[rule.Name] = static_cast<int>(rule.Command.size());
// Write rule
cmGlobalNinjaGenerator::WriteRule(*thi... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x788, %rdi # imm = 0x788
movq -0x10(%rbp), %rsi
callq 0x1a4620
movb %dl, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movb -0x28(%rb... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::AddMacOSXContentRule() | void cmGlobalNinjaGenerator::AddMacOSXContentRule()
{
cmNinjaRule rule("COPY_OSX_CONTENT");
rule.Command = cmStrCat(this->CMakeCmd(), " -E copy $in $out");
rule.Description = "Copying OS X Content $out";
rule.Comment = "Rule for copying OS X bundle content file.";
this->AddRule(rule);
} | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x218(%rbp)
leaq -0x151(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x3c460
movq -0x210(%rbp), %rdx
leaq 0x6beb52(%rip), %rsi # 0xb7c84d
leaq -0x150(%rbp), %rdi
callq 0x606e0
jmp 0x4bdd09
leaq ... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::WriteRule(std::ostream&, cmNinjaRule const&) | void cmGlobalNinjaGenerator::WriteRule(std::ostream& os,
cmNinjaRule const& rule)
{
// -- Parameter checks
// Make sure the rule has a name.
if (rule.Name.empty()) {
cmSystemTools::Error(cmStrCat(
"No name given for WriteRule! called with comment: ", rule.Comment))... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b870
testb $0x1, %al
jne 0x4be0d5
jmp 0x4be161
leaq 0x6be7d9(%rip), %rsi # 0xb7c8b5
leaq -0x60(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x62090
movq -0x10(%rbp), %rsi
ad... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::WriteDefault(std::ostream&, 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<... | void cmGlobalNinjaGenerator::WriteDefault(std::ostream& os,
const cmNinjaDeps& targets,
const std::string& comment)
{
cmGlobalNinjaGenerator::WriteComment(os, comment);
os << "default";
for (std::string const& target : targets) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4bb3f0
movq -0x8(%rbp), %rdi
leaq 0x6e3eeb(%rip), %rsi # 0xba24d7
callq 0x3d690
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
cal... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::Generate() | void cmGlobalNinjaGenerator::Generate()
{
// Check minimum Ninja version.
if (cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, this->NinjaVersion,
RequiredNinjaVersion())) {
std::ostringstream msg;
msg << "The detected version of Ninja (" << this->NinjaVersion;
m... | pushq %rbp
movq %rsp, %rbp
subq $0x360, %rsp # imm = 0x360
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x308(%rbp)
addq $0x9b0, %rax # imm = 0x9B0
movq %rax, -0x300(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x2f8(%rbp)
callq 0x4d75a0
movq -0x300(%rbp), %rsi
movq -0x2f8(%rbp), %rdx
movl ... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::OpenRulesFileStream() | bool cmGlobalNinjaGenerator::OpenRulesFileStream()
{
if (!this->OpenFileStream(this->RulesFileStream,
cmGlobalNinjaGenerator::NINJA_RULES_FILE)) {
return false;
}
// Write comment about this file.
/* clang-format off */
*this->RulesFileStream
<< "# This file contains all t... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x778, %rax # imm = 0x778
movq %rax, -0x60(%rbp)
movq 0xa3cd63(%rip), %rax # 0xefc018
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3c460
movq -0x58(%rbp), ... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream&) | void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os)
{
if (!this->ComputingUnknownDependencies) {
return;
}
// We need to collect the set of known build outputs.
// Start with those generated by WriteBuild calls.
// No other method needs this so we can take ownership
// of th... | pushq %rbp
movq %rsp, %rbp
subq $0x750, %rsp # imm = 0x750
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x5e8(%rbp)
testb $0x1, 0x830(%rax)
jne 0x4c10bc
jmp 0x4c1e23
leaq -0x40(%rbp), %rdi
movq %rdi, -0x5f0(%rbp)
callq 0xdefc0
movq -0x5e8(%rbp), %rsi
movq -0x5f0(%rbp), %rdi
... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::WriteBuiltinTargets(std::ostream&) | void cmGlobalNinjaGenerator::WriteBuiltinTargets(std::ostream& os)
{
// Write headers.
cmGlobalNinjaGenerator::WriteDivider(os);
os << "# Built-in targets\n\n";
this->WriteTargetRebuildManifest(os);
this->WriteTargetClean(os);
this->WriteTargetHelp(os);
for (auto const& config : this->Makefiles[0]->GetG... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4bb3c0
movq -0x10(%rbp), %rdi
leaq 0x6bb2e0(%rip), %rsi # 0xb7d16c
callq 0x3d690
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4c6fc0
movq -0x60... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::CheckNinjaFeatures() | void cmGlobalNinjaGenerator::CheckNinjaFeatures()
{
this->NinjaSupportsConsolePool =
!cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, this->NinjaVersion,
RequiredNinjaVersionForConsolePool());
this->NinjaSupportsImplicitOuts = !cmSystemTools::VersionCompare(
cmSystem... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x178(%rbp)
addq $0x9b0, %rax # imm = 0x9B0
movq %rax, -0x170(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x168(%rbp)
callq 0x4d7880
movq -0x170(%rbp), %rsi
movq -0x168(%rbp), %rdx
movl ... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::CheckNinjaCodePage() | void cmGlobalNinjaGenerator::CheckNinjaCodePage()
{
std::vector<std::string> command{ this->NinjaCommand, "-t", "wincodepage" };
std::string output;
std::string error;
int result;
if (!cmSystemTools::RunSingleCommand(command, &output, &error, &result,
nullptr, cmSystemTo... | pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp # imm = 0x4D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x408(%rbp)
movb $0x1, -0xa7(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x990, %rsi # imm = 0x990
callq 0x3b400
jmp 0x4c31ad
leaq -0x70(%rbp), %rax
movq %rax, -0x418(%r... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::CheckISPC(cmMakefile*) const | bool cmGlobalNinjaGenerator::CheckISPC(cmMakefile* mf) const
{
if (this->NinjaSupportsMultipleOutputs) {
return true;
}
std::ostringstream e;
/* clang-format off */
e <<
"The Ninja generator does not support ISPC using Ninja version\n"
" " << this->NinjaVersion << "\n"
"due to lack of requir... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
testb $0x1, 0x9d7(%rax)
je 0x4c3e20
movb $0x1, -0x1(%rbp)
jmp 0x4c3f98
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x3c530
movq -0x1f8(%rbp), %rdi
... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::GenerateBuildCommand(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<st... | std::vector<cmGlobalGenerator::GeneratedMakeCommand>
cmGlobalNinjaGenerator::GenerateBuildCommand(
const std::string& makeProgram, const std::string& /*projectName*/,
const std::string& /*projectDir*/,
std::vector<std::string> const& targetNames, const std::string& config,
int jobs, bool verbose, const cmBuildO... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movb 0x20(%rbp), %al
movl 0x18(%rbp), %r10d
movq 0x10(%rbp), %r10
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rc... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::ComputeTargetObjectDirectory(cmGeneratorTarget*) const | void cmGlobalNinjaGenerator::ComputeTargetObjectDirectory(
cmGeneratorTarget* gt) const
{
// Compute full path to object file directory for this target.
std::string dir = cmStrCat(gt->LocalGenerator->GetCurrentBinaryDirectory(),
'/', gt->LocalGenerator->GetTargetDirectory(gt),
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1ee380
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x61ca0
leaq -0x90(%rbp), %rdi
movl $0x2f, %esi
callq 0x61ce0
movq -0x10(%rbp), %... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::OpenFileStream(std::unique_ptr<cmGeneratedFileStream, std::default_delete<cmGeneratedFileStream>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool cmGlobalNinjaGenerator::OpenFileStream(
std::unique_ptr<cmGeneratedFileStream>& stream, const std::string& name)
{
// Get a stream where to generate things.
if (!stream) {
// Compute Ninja's build file path.
std::string path =
cmStrCat(this->GetCMakeInstance()->GetHomeOutputDirectory(), '/', na... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4d80d0
testb $0x1, %al
jne 0x4c4cde
movq -0xc8(%rbp), %rdi
callq 0x1a0d20
movq %rax, %rdi
callq 0x31dcc0... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::ListSubsetWithAll(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<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>>>> co... | cm::optional<std::set<std::string>> cmGlobalNinjaGenerator::ListSubsetWithAll(
const std::set<std::string>& all, const std::set<std::string>& defaults,
const std::vector<std::string>& items)
{
std::set<std::string> result;
for (auto const& item : items) {
if (item == "all") {
if (items.size() == 1) {... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xdefc0
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x62f40
mov... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::AddCXXCompileCommand(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&) | void cmGlobalNinjaGenerator::AddCXXCompileCommand(
const std::string& commandLine, const std::string& sourceFile,
const std::string& objPath)
{
// Compute Ninja's build file path.
std::string buildFileDir =
this->GetCMakeInstance()->GetHomeOutputDirectory();
if (!this->CompileCommandsStream) {
std::st... | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x1a0d20
movq %rax, %rdi
callq 0x31dcc0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x3b400
movq -0x1f8(%r... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::AddTargetAlias(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorTarget*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmGlobalNinjaGenerator::AddTargetAlias(const std::string& alias,
cmGeneratorTarget* target,
const std::string& config)
{
std::string outputPath = this->NinjaOutputPath(alias);
std::string buildAlias = this->BuildAlias(outpu... | pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp # imm = 0x2D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x250(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x4bf4b0
movq -0x250(%rbp), %rsi
movq... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream&) | void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
{
if (this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION")) {
return;
}
const auto& lg = this->LocalGenerators[0];
{
cmNinjaRule rule("RERUN_CMAKE");
rule.Command =
cmStrCat(this->CMakeCmd(), " --regenerate-during-bui... | pushq %rbp
movq %rsp, %rbp
subq $0xf70, %rsp # imm = 0xF70
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xdc0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xdb8(%rbp)
callq 0x3c460
movq -0xdb8(%rbp), %rdx
leaq 0x6b5f90(%rip), %rsi # 0xb7cf8c
leaq -0x30(%rbp), %rdi
callq 0x606... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::WriteTargetHelp(std::ostream&) | void cmGlobalNinjaGenerator::WriteTargetHelp(std::ostream& os)
{
{
cmNinjaRule rule("HELP");
rule.Command = cmStrCat(this->NinjaCmd(), " -t targets");
rule.Description = "All primary targets available:";
rule.Comment = "Rule for printing all primary targets available.";
WriteRule(*this->RulesFileS... | pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp # imm = 0x3E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x3b0(%rbp)
leaq -0x159(%rbp), %rdi
movq %rdi, -0x3a8(%rbp)
callq 0x3c460
movq -0x3a8(%rbp), %rdx
leaq 0x693aab(%rip), %rsi # 0xb5de1a
leaq -0x158(%rbp), %rdi
callq 0x6... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaGenerator::NinjaCmd[abi:cxx11]() const | std::string cmGlobalNinjaGenerator::NinjaCmd() const
{
const auto& lgen = this->LocalGenerators[0];
if (lgen != nullptr) {
return lgen->ConvertToOutputFormat(this->NinjaCommand,
cmOutputConverter::SHELL);
}
return "ninja";
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4d6f80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %e... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
EnsureTrailingSlash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | static void EnsureTrailingSlash(std::string& path)
{
if (path.empty()) {
return;
}
std::string::value_type last = path.back();
#ifdef _WIN32
if (last != '\\') {
path += '\\';
}
#else
if (last != '/') {
path += '/';
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b870
testb $0x1, %al
jne 0x4cb89b
jmp 0x4cb89d
jmp 0x4cb8c2
movq -0x8(%rbp), %rdi
callq 0x3c6d0
movb (%rax), %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x2f, %eax
je 0x4cb8c2
movq -0x8(%rbp), %rdi
movl $0x2f, %e... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
(anonymous namespace)::cmcmd_cmake_ninja_depends_fortran(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&) | cm::optional<cmSourceInfo> cmcmd_cmake_ninja_depends_fortran(
std::string const& arg_tdi, std::string const& arg_pp)
{
cm::optional<cmSourceInfo> info;
cmFortranCompiler fc;
std::vector<std::string> includes;
std::string dir_top_bld;
std::string module_dir;
{
Json::Value tdio;
Json::Value const& t... | pushq %rbp
movq %rsp, %rbp
subq $0xd50, %rsp # imm = 0xD50
movq %rdi, -0xc90(%rbp)
movq %rdi, %rax
movq %rax, -0xc88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x4cc7c0
leaq -0x80(%rbp), %rdi
callq 0x4debd0
leaq -0x98(%rbp), %rdi
callq 0x60530
leaq ... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaMultiGenerator::cmGlobalNinjaMultiGenerator(cmake*) | cmGlobalNinjaMultiGenerator::cmGlobalNinjaMultiGenerator(cmake* cm)
: cmGlobalNinjaGenerator(cm)
{
cm->GetState()->SetIsGeneratorMultiConfig(true);
cm->GetState()->SetNinjaMulti(true);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4be670
movq -0x38(%rbp), %rdi
leaq 0xa1901c(%rip), %rax # 0xeece38
movq %rax, (%rdi)
addq $0xa98, %rdi # imm = 0xA98
movq %rdi, -0x50(%rbp)
c... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmGlobalNinjaMultiGenerator::AddRebuildManifestOutputs(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 | void cmGlobalNinjaMultiGenerator::AddRebuildManifestOutputs(
cmNinjaDeps& outputs) const
{
for (auto const& config : this->Makefiles.front()->GetGeneratorConfigs(
cmMakefile::IncludeEmptyConfig)) {
outputs.push_back(this->NinjaOutputPath(GetNinjaImplFilename(config)));
outputs.push_back(this->Ninja... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x128(%rbp)
addq $0x80, %rdi
callq 0x1a2870
movq %rax, %rdi
callq 0x1a0fc0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
xorl %edx, %edx
callq 0x229270
leaq -0x30(%rbp), %rax
mov... | /JKorbelRA[P]CMake/Source/cmGlobalNinjaGenerator.cxx |
cmLocalNinjaGenerator::CreateRulePlaceholderExpander() const | cmRulePlaceholderExpander*
cmLocalNinjaGenerator::CreateRulePlaceholderExpander() const
{
cmRulePlaceholderExpander* ret =
this->cmLocalGenerator::CreateRulePlaceholderExpander();
ret->SetTargetImpLib("$TARGET_IMPLIB");
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dd190
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3c460
movq -0x50(%rbp), %rdx
leaq 0x68f679(%rip), %rsi # 0xb7e5f2
leaq -0x30(%rbp), %rdi
ca... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmLocalNinjaGenerator::WriteBuildFileTop() | void cmLocalNinjaGenerator::WriteBuildFileTop()
{
this->WriteProjectHeader(this->GetCommonFileStream());
if (this->GetGlobalGenerator()->IsMultiConfig()) {
for (auto const& config : this->GetConfigNames()) {
auto& stream = this->GetImplFileStream(config);
this->WriteProjectHeader(stream);
thi... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x4f01a0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x4f0e60
movq -0x38(%rbp), %rdi
callq 0x1a4960
movq %rax, %rdi
movq (%rdi), %rax
callq *0x130(%rax)
testb $0x1, %al
jne 0x4f0213
jmp 0x4f02b0
movq -0... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmLocalNinjaGenerator::WritePools(std::ostream&) | void cmLocalNinjaGenerator::WritePools(std::ostream& os)
{
cmGlobalNinjaGenerator::WriteDivider(os);
cmValue jobpools =
this->GetCMakeInstance()->GetState()->GetGlobalProperty("JOB_POOLS");
if (!jobpools) {
jobpools = this->GetMakefile()->GetDefinition("CMAKE_JOB_POOLS");
}
if (jobpools) {
cmGlob... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4bb3c0
movq -0x158(%rbp), %rdi
callq 0x4f0e30
movq %rax, %rdi
callq 0x1a08d0
movq %rax, -0x150(%rbp)
leaq -0x39(%rbp), %rdi
movq... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmLocalNinjaGenerator::GetTargetDirectory[abi:cxx11](cmGeneratorTarget const*) const | std::string cmLocalNinjaGenerator::GetTargetDirectory(
cmGeneratorTarget const* target) const
{
std::string dir = cmStrCat("CMakeFiles/", target->GetName());
#if defined(__VMS)
dir += "_dir";
#else
dir += ".dir";
#endif
return dir;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq 0x697abc(%rip), %rsi # 0xb8876f
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x62090
movq -0x18(%rbp), %rdi
... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmLocalNinjaGenerator::WriteNinjaRequiredVersion(std::ostream&) | void cmLocalNinjaGenerator::WriteNinjaRequiredVersion(std::ostream& os)
{
// Default required version
std::string requiredVersion = cmGlobalNinjaGenerator::RequiredNinjaVersion();
// Ninja generator uses the 'console' pool if available (>= 1.5)
if (this->GetGlobalNinjaGenerator()->SupportsDirectConsole()) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4d75a0
movq -0xe0(%rbp), %rdi
callq 0x4f0820
movq %rax, -0xd8(%rbp)
jmp 0x4f101c
movq -0xd8(%rbp), %rdi
movq (%rdi), %rax
movq 0x... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmLocalNinjaGenerator::WriteNinjaFilesInclusionConfig(std::ostream&) | void cmLocalNinjaGenerator::WriteNinjaFilesInclusionConfig(std::ostream& os)
{
cmGlobalNinjaGenerator::WriteDivider(os);
os << "# Include auxiliary files.\n\n";
cmGlobalNinjaGenerator* ng = this->GetGlobalNinjaGenerator();
std::string const ninjaCommonFile =
ng->NinjaOutputPath(cmGlobalNinjaMultiGenerator::... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4bb3c0
movq -0x10(%rbp), %rdi
leaq 0x68d2b6(%rip), %rsi # 0xb7e748
callq 0x3d690
movq -0xd8(%rbp), %rdi
callq 0x4f0820
movq %rax, -0x18(%rbp)
movq -0x18... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmLocalNinjaGenerator::WriteNinjaFilesInclusionCommon(std::ostream&) | void cmLocalNinjaGenerator::WriteNinjaFilesInclusionCommon(std::ostream& os)
{
cmGlobalNinjaGenerator::WriteDivider(os);
os << "# Include auxiliary files.\n\n";
cmGlobalNinjaGenerator* ng = this->GetGlobalNinjaGenerator();
std::string const ninjaRulesFile =
ng->NinjaOutputPath(cmGlobalNinjaGenerator::NINJA_... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4bb3c0
movq -0x10(%rbp), %rdi
leaq 0x68d0a6(%rip), %rsi # 0xb7e748
callq 0x3d690
movq -0xd8(%rbp), %rdi
callq 0x4f0820
movq %rax, -0x18(%rbp)
movq -0x18... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmLocalNinjaGenerator::WriteCommandScript(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>> con... | std::string cmLocalNinjaGenerator::WriteCommandScript(
std::vector<std::string> const& cmdLines, std::string const& outputConfig,
std::string const& commandConfig, std::string const& customStep,
cmGeneratorTarget const* target) const
{
std::string scriptPath;
if (target) {
scriptPath = target->GetSupportD... | pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp # imm = 0x410
movq %rdi, -0x3e8(%rbp)
movq %rdi, %rax
movq %rax, -0x3e0(%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 -0x10(%rbp), %rax
movq %... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmLocalNinjaGenerator::AppendCustomCommandLines(cmCustomCommandGenerator const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | void cmLocalNinjaGenerator::AppendCustomCommandLines(
cmCustomCommandGenerator const& ccg, std::vector<std::string>& cmdLines)
{
auto* gg = this->GetGlobalNinjaGenerator();
if (ccg.GetNumberOfCommands() > 0) {
std::string wd = ccg.GetWorkingDirectory();
if (wd.empty()) {
wd = this->GetCurrentBinary... | pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp # imm = 0x340
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2f0(%rbp)
callq 0x4f0820
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x586f30
cmpl $0x0, %eax
jbe 0x4f272f
movq -0x10(%rbp), %rsi
leaq -0x... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmLocalNinjaGenerator::MakeCustomLauncher[abi:cxx11](cmCustomCommandGenerator const&) | std::string cmLocalNinjaGenerator::MakeCustomLauncher(
cmCustomCommandGenerator const& ccg)
{
cmValue property_value = this->Makefile->GetProperty("RULE_LAUNCH_CUSTOM");
if (!cmNonempty(property_value)) {
return std::string();
}
// Expand rule variables referenced in the given launcher command.
cmRule... | pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp # imm = 0x2B0
movq %rdi, -0x280(%rbp)
movq %rdi, %rax
movq %rax, -0x278(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x270(%rbp)
movq 0x70(%rax), %rax
movq %rax, -0x268(%rbp)
leaq -0x41(%rbp), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmLocalNinjaGenerator::WriteCustomCommandBuildStatement(cmCustomCommand const*, std::set<cmGeneratorTarget*, std::less<cmGeneratorTarget*>, std::allocator<cmGeneratorTarget*>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmLocalNinjaGenerator::WriteCustomCommandBuildStatement(
cmCustomCommand const* cc, const std::set<cmGeneratorTarget*>& targets,
const std::string& fileConfig)
{
cmGlobalNinjaGenerator* gg = this->GetGlobalNinjaGenerator();
if (gg->SeenCustomCommand(cc, fileConfig)) {
return;
}
auto ccgs = this->M... | pushq %rbp
movq %rsp, %rbp
subq $0x7c0, %rsp # imm = 0x7C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x610(%rbp)
callq 0x4f0820
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq ... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmLocalNinjaGenerator::HasUniqueByproducts(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&, cmListFileBacktrace const&) | bool cmLocalNinjaGenerator::HasUniqueByproducts(
std::vector<std::string> const& byproducts, cmListFileBacktrace const& bt)
{
std::vector<std::string> configs =
this->GetMakefile()->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);
cmGeneratorExpression ge(bt);
for (std::string const& p : byproducts) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x1a29c0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0x229270
movq -0x20(%rbp), %rsi
leaq -0x58(%rbp), %rdi
mov... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmLocalNinjaGenerator::CreateUtilityOutput(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::allocator<char>>>> co... | std::string cmLocalNinjaGenerator::CreateUtilityOutput(
std::string const& targetName, std::vector<std::string> const& byproducts,
cmListFileBacktrace const& bt)
{
// In Ninja Multi-Config, we can only produce cross-config utility
// commands if all byproducts are per-config.
if (!this->GetGlobalGenerator()->... | pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp # imm = 0x2B0
movq %rdi, -0x268(%rbp)
movq %rdi, %rax
movq %rax, -0x260(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x1a4960
movq %rax, ... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
(anonymous namespace)::HasUniqueOutputs(std::vector<cmCustomCommandGenerator, std::allocator<cmCustomCommandGenerator>> const&) | bool HasUniqueOutputs(std::vector<cmCustomCommandGenerator> const& ccgs)
{
std::set<std::string> allOutputs;
std::set<std::string> allByproducts;
for (cmCustomCommandGenerator const& ccg : ccgs) {
for (std::string const& output : ccg.GetOutputs()) {
if (!allOutputs.insert(output).second) {
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xdefc0
leaq -0x70(%rbp), %rdi
callq 0xdefc0
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x4f67f0
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x4f6820
movq %ra... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmLocalNinjaGenerator::AddCustomCommandTarget(cmCustomCommand const*, cmGeneratorTarget*) | void cmLocalNinjaGenerator::AddCustomCommandTarget(cmCustomCommand const* cc,
cmGeneratorTarget* target)
{
CustomCommandTargetMap::value_type v(cc, std::set<cmGeneratorTarget*>());
std::pair<CustomCommandTargetMap::iterator, bool> ins =
this->CustomCommandTarge... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x4f5620
movq ... | /JKorbelRA[P]CMake/Source/cmLocalNinjaGenerator.cxx |
cmNinjaTargetGenerator::New(cmGeneratorTarget*) | std::unique_ptr<cmNinjaTargetGenerator> cmNinjaTargetGenerator::New(
cmGeneratorTarget* target)
{
switch (target->GetType()) {
case cmStateEnums::EXECUTABLE:
case cmStateEnums::SHARED_LIBRARY:
case cmStateEnums::STATIC_LIBRARY:
case cmStateEnums::MODULE_LIBRARY:
case cmStateEnums::OBJECT_LIBRARY... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6263f0
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
subl $0x5, %eax
jb 0x4fa6ed
jmp 0x4fa6e0
movl -0x24(%rbp), %eax
addl $-0x5, %eax
subl $0x3, ... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::cmNinjaTargetGenerator(cmGeneratorTarget*) | cmNinjaTargetGenerator::cmNinjaTargetGenerator(cmGeneratorTarget* target)
: cmCommonTargetGenerator(target)
, OSXBundleGenerator(nullptr)
, LocalGenerator(
static_cast<cmLocalNinjaGenerator*>(target->GetLocalGenerator()))
{
for (auto const& fileConfig :
target->Makefile->GetGeneratorConfigs(cmMakef... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq -0x10(%rbp), %rsi
callq 0x556860
movq -0x80(%rbp), %rdi
leaq 0x9f2a41(%rip), %rax # 0xeed1c0
movq %rax, (%rdi)
addq $0x78, %rdi
movq %rdi, -0x90(%rbp)
xorl %eax, %eax
movl %eax, ... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::AddIncludeFlags(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, 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&) | void cmNinjaTargetGenerator::AddIncludeFlags(std::string& languageFlags,
std::string const& language,
const std::string& config)
{
std::vector<std::string> includes;
this->LocalGenerator->GetIncludeDirectories(includes, this->... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x60530
movq -0x90(%rbp), %rax
movq -0x88(%rbp), %rsi
movq 0x8(%rax), %rdx
movq 0xb0(%ra... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::ComputeDefines(cmSourceFile 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::string cmNinjaTargetGenerator::ComputeDefines(cmSourceFile const* source,
const std::string& language,
const std::string& config)
{
std::set<std::string> defines;
cmGeneratorExpressionInterpreter genexInterpre... | pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp # imm = 0x350
movq %rdi, -0x2e8(%rbp)
movq %rdi, %rax
movq %rax, -0x2e0(%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, -0x2d8(%rbp)
leaq -0x58(%rbp), %rdi
cal... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::ComputeLinkDeps(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const | cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps(
const std::string& linkLanguage, const std::string& config,
bool ignoreType) const
{
// Static libraries never depend on other targets for linking.
if (!ignoreType &&
(this->GeneratorTarget->GetType() == cmStateEnums::STATIC_LIBRARY ||
this->Gene... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x130(%rbp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, -0x128(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x120(%rbp... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::GetObjectFilePath(cmSourceFile const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmNinjaTargetGenerator::GetObjectFilePath(
cmSourceFile const* source, const std::string& config) const
{
std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
if (!path.empty()) {
path += '/';
}
std::string const& objectName = this->GeneratorTarget->GetObjectName(source);
pa... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x110(%rbp)
movq %rdi, %rax
movq %rax, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x118(%rbp)
movb $0x0, -0x21(%rbp)
movq 0xb0(%rax), %rsi
cal... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::GetDyndepFilePath(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&) const | std::string cmNinjaTargetGenerator::GetDyndepFilePath(
std::string const& lang, const std::string& config) const
{
std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
if (!path.empty()) {
path += '/';
}
path += cmStrCat(
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget)... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x110(%rbp)
movb $0x0, -0x21(%rbp)
movq 0xb0(%rax), %rsi
cal... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::GetTargetDependInfoPath(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&) const | std::string cmNinjaTargetGenerator::GetTargetDependInfoPath(
std::string const& lang, const std::string& config) const
{
std::string path =
cmStrCat(this->Makefile->GetCurrentBinaryDirectory(), '/',
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget),
this->GetGlobalGenerat... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movb $0x0, -0x21(%rbp)
movq 0x10(%rax), %rdi
callq ... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::SetMsvcTargetPdbVariable(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::alloca... | bool cmNinjaTargetGenerator::SetMsvcTargetPdbVariable(
cmNinjaVars& vars, const std::string& config) const
{
cmMakefile* mf = this->GetMakefile();
if (mf->GetDefinition("MSVC_C_ARCHITECTURE_ID") ||
mf->GetDefinition("MSVC_CXX_ARCHITECTURE_ID") ||
mf->GetDefinition("MSVC_CUDA_ARCHITECTURE_ID")) {
s... | pushq %rbp
movq %rsp, %rbp
subq $0x360, %rsp # imm = 0x360
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x290(%rbp)
callq 0x510ba0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x288(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x280(%rbp)
ca... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::ForceResponseFile() | bool cmNinjaTargetGenerator::ForceResponseFile()
{
static std::string const forceRspFile = "CMAKE_NINJA_FORCE_RESPONSE_FILE";
return (this->GetMakefile()->IsDefinitionSet(forceRspFile) ||
cmSystemTools::HasEnv(forceRspFile));
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpb $0x0, 0x9ff645(%rip) # 0xf02e90
jne 0x5038b3
leaq 0x9ff63c(%rip), %rdi # 0xf02e90
callq 0x3d080
cmpl $0x0, %eax
je 0x5038b3
leaq -0x9(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3c460
movq -0x30(%rbp... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
(anonymous namespace)::GetScanRule(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&, cmRulePlaceholderExpande... | cmNinjaRule GetScanRule(
std::string const& ruleName, std::string const& ppFileName,
std::string const& deptype,
cmRulePlaceholderExpander::RuleVariables const& vars,
const std::string& responseFlag, const std::string& flags,
cmRulePlaceholderExpander* const rulePlaceholderExpander,
cmLocalNinjaGenerator* g... | pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp # imm = 0x3E0
movq %rdi, -0x380(%rbp)
movq %rdi, %rax
movq %rax, -0x390(%rbp)
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq %rax, -0x388(%rbp)
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %r... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::WriteObjectBuildStatements(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | void cmNinjaTargetGenerator::WriteObjectBuildStatements(
const std::string& config, const std::string& fileConfig,
bool firstForConfig)
{
this->GeneratorTarget->CheckCxxModuleStatus(config);
// Write comments.
cmGlobalNinjaGenerator::WriteDivider(this->GetImplFileStream(fileConfig));
this->GetImplFileStrea... | pushq %rbp
movq %rsp, %rbp
subq $0xa50, %rsp # imm = 0xA50
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x888(%rbp)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x65cdf0
movq -0x888(%rbp), %rdi
mo... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::WriteTargetDependInfo(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&) | void cmNinjaTargetGenerator::WriteTargetDependInfo(std::string const& lang,
const std::string& config)
{
Json::Value tdi(Json::objectValue);
tdi["language"] = lang;
tdi["compiler-id"] = this->Makefile->GetSafeDefinition(
cmStrCat("CMAKE_", lang, "_COMPILER_ID... | pushq %rbp
movq %rsp, %rbp
subq $0x17c0, %rsp # imm = 0x17C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x12d8(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x7, %esi
callq 0x8d5360
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x8d5ac0
jmp 0x50926f
leaq 0... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::GenerateSwiftOutputFileMap(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>>&) | void cmNinjaTargetGenerator::GenerateSwiftOutputFileMap(
const std::string& config, std::string& flags)
{
if (this->Configs[config].SwiftOutputMap.empty()) {
return;
}
std::string const targetSwiftDepsPath = [this, config]() -> std::string {
cmGeneratorTarget const* target = this->GeneratorTarget;
... | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x400(%rbp)
addq $0xb8, %rdi
movq -0x10(%rbp), %rsi
callq 0x510910
movq %rax, %rdi
addq $0x48, %rdi
callq 0x8d8900
testb $0x1, %al
jne 0x50c2a4
jmp ... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::ExportObjectCompileCommand(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::__c... | void cmNinjaTargetGenerator::ExportObjectCompileCommand(
std::string const& language, std::string const& sourceFileName,
std::string const& objectDir, std::string const& objectFileName,
std::string const& objectFileDir, std::string const& flags,
std::string const& defines, std::string const& includes,
std::st... | pushq %rbp
movq %rsp, %rbp
subq $0x6f0, %rsp # imm = 0x6F0
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
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 -0x8(%rbp), %rax
movq ... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
(anonymous namespace)::GetScanBuildStatement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool, cmNinjaBuild&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::all... | cmNinjaBuild GetScanBuildStatement(const std::string& ruleName,
const std::string& ppFileName,
bool compilePP, bool compilePPWithDefines,
cmNinjaBuild& objBuild, cmNinjaVars& vars,
... | pushq %rbp
movq %rsp, %rbp
subq $0x6d0, %rsp # imm = 0x6D0
movq %rdi, -0x500(%rbp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, -0x508(%rbp)
movq 0x28(%rbp), %r8
movq 0x20(%rbp), %r8
movq 0x18(%rbp), %r8
movq 0x10(%rbp), %r8
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %cl
movb %... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::addPoolNinjaVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmGeneratorTarget*, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>,... | void cmNinjaTargetGenerator::addPoolNinjaVariable(
const std::string& pool_property, cmGeneratorTarget* target,
cmNinjaVars& vars)
{
cmValue pool = target->GetProperty(pool_property);
if (pool) {
vars["pool"] = *pool;
}
} | 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 -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6266f0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x62230
testb $0x1, %al
jne 0x50e5ee
jmp 0x50e68a
leaq -0x28(%rbp), %rdi... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::EmitSwiftDependencyInfo(cmSourceFile const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmNinjaTargetGenerator::EmitSwiftDependencyInfo(
cmSourceFile const* source, const std::string& config)
{
std::string const sourceFilePath = this->GetCompiledSourceNinjaPath(source);
std::string const objectFilePath =
this->ConvertToNinjaPath(this->GetObjectFilePath(source, config));
std::string const ... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x238(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x4fd5e0
movq -0x238(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq ... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::AdditionalCleanFiles(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmNinjaTargetGenerator::AdditionalCleanFiles(const std::string& config)
{
if (cmValue prop_value =
this->GeneratorTarget->GetProperty("ADDITIONAL_CLEAN_FILES")) {
cmLocalNinjaGenerator* lg = this->LocalGenerator;
std::vector<std::string> cleanFiles;
cmExpandList(cmGeneratorExpression::Evaluat... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x148(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x140(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x3c460
movq -0x138(%rbp), %rdx
leaq 0x64c60c(%rip), %rsi ... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()(cmSourceFile const&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()(
cmSourceFile const& source, const char* pkgloc, const std::string& config)
{
// Skip OS X content when not building a Framework or Bundle.
if (!this->Generator->GetGeneratorTarget()->IsBundleOnApple()) {
return;
}
std::string macdir =
... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x178(%rbp)
movq 0x8(%rax), %rdi
callq 0x510b00
movq %rax, %rdi
callq 0x635df0
testb $0x1, %al
jne 0x50f900
jmp 0x50fbcd
movq... | /JKorbelRA[P]CMake/Source/cmNinjaTargetGenerator.cxx |
cmNinjaNormalTargetGenerator::Generate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmNinjaNormalTargetGenerator::Generate(const std::string& config)
{
std::string lang = this->GeneratorTarget->GetLinkerLanguage(config);
if (this->TargetLinkLanguage(config).empty()) {
cmSystemTools::Error("CMake can not determine linker language for "
"target: " +
... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x178(%rbp)
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x633310
movq -0x178(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0... | /JKorbelRA[P]CMake/Source/cmNinjaNormalTargetGenerator.cxx |
cmNinjaNormalTargetGenerator::WriteObjectLibStatement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmNinjaNormalTargetGenerator::WriteObjectLibStatement(
const std::string& config)
{
// Write a phony output that depends on all object files.
{
cmNinjaBuild build("phony");
build.Comment = "Object library " + this->GetTargetName();
this->GetLocalGenerator()->AppendTargetOutputs(this->GetGenerator... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x151(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x3c460
movq -0x1e8(%rbp), %rdx
leaq 0x6658bd(%rip), %rsi # 0xb7cecc
leaq -0x150(%rbp), %rdi
callq 0x6... | /JKorbelRA[P]CMake/Source/cmNinjaNormalTargetGenerator.cxx |
cmNinjaNormalTargetGenerator::LanguageLinkerDeviceRule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmNinjaNormalTargetGenerator::LanguageLinkerDeviceRule(
const std::string& config) const
{
return cmStrCat(
this->TargetLinkLanguage(config), "_",
cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()),
"_DEVICE_LINKER__",
cmGlobalNinjaGenerator::EncodeRuleName(
this->Ge... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq... | /JKorbelRA[P]CMake/Source/cmNinjaNormalTargetGenerator.cxx |
cmNinjaNormalTargetGenerator::LanguageLinkerCudaDeviceRule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmNinjaNormalTargetGenerator::LanguageLinkerCudaDeviceRule(
const std::string& config) const
{
return cmStrCat(
this->TargetLinkLanguage(config), "_DEVICE_LINK__",
cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()),
'_', config);
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq... | /JKorbelRA[P]CMake/Source/cmNinjaNormalTargetGenerator.cxx |
cmNinjaNormalTargetGenerator::LanguageLinkerCudaDeviceCompileRule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmNinjaNormalTargetGenerator::LanguageLinkerCudaDeviceCompileRule(
const std::string& config) const
{
return cmStrCat(
this->TargetLinkLanguage(config), "_DEVICE_LINK_COMPILE__",
cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()),
'_', config);
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq... | /JKorbelRA[P]CMake/Source/cmNinjaNormalTargetGenerator.cxx |
cmNinjaNormalTargetGenerator::WriteNvidiaDeviceLinkRule(bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmNinjaNormalTargetGenerator::WriteNvidiaDeviceLinkRule(
bool useResponseFile, const std::string& config)
{
cmNinjaRule rule(this->LanguageLinkerDeviceRule(config));
if (!this->GetGlobalGenerator()->HasRule(rule.Name)) {
cmRulePlaceholderExpander::RuleVariables vars;
vars.CMTargetName = this->GetGene... | pushq %rbp
movq %rsp, %rbp
subq $0x770, %rsp # imm = 0x770
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x660(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x160(%rbp), %rdi
movq %rdi, -0x658(%rbp)
callq 0x51e9c0
movq -0x658(%rbp), %rs... | /JKorbelRA[P]CMake/Source/cmNinjaNormalTargetGenerator.cxx |
cmNinjaNormalTargetGenerator::ComputeDeviceLinkCmd[abi:cxx11]() | std::vector<std::string> cmNinjaNormalTargetGenerator::ComputeDeviceLinkCmd()
{
std::vector<std::string> linkCmds;
// this target requires separable cuda compilation
// now build the correct command depending on if the target is
// an executable or a dynamic library.
switch (this->GetGeneratorTarget()->GetTy... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %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)
callq 0x60530
movq -0x88(%rbp), %rdi
callq 0x510b00
movq %rax, -0x80(%rbp)
jmp 0x51fa0a
movq -0x80(%... | /JKorbelRA[P]CMake/Source/cmNinjaNormalTargetGenerator.cxx |
cmNinjaNormalTargetGenerator::WriteDeviceLinkRules(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmNinjaNormalTargetGenerator::WriteDeviceLinkRules(
const std::string& config)
{
const cmMakefile* mf = this->GetMakefile();
cmNinjaRule rule(this->LanguageLinkerCudaDeviceRule(config));
rule.Command = this->GetLocalGenerator()->BuildCommandLine(
{ cmStrCat(mf->GetRequiredDefinition("CMAKE_CUDA_DEVICE... | pushq %rbp
movq %rsp, %rbp
subq $0x8b0, %rsp # imm = 0x8B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x6a0(%rbp)
callq 0x510ba0
movq -0x6a0(%rbp), %rsi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x160(%rbp), %rdi
movq %rdi, -0x698(%rbp)
callq 0x51eb50
movq -0x698... | /JKorbelRA[P]CMake/Source/cmNinjaNormalTargetGenerator.cxx |
cmNinjaNormalTargetGenerator::ComputeLinkCmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::vector<std::string> cmNinjaNormalTargetGenerator::ComputeLinkCmd(
const std::string& config)
{
std::vector<std::string> linkCmds;
cmMakefile* mf = this->GetMakefile();
{
// If we have a rule variable prefer it. In the case of static libraries
// this occurs when things like IPO is enabled, and we n... | pushq %rbp
movq %rsp, %rbp
subq $0x6f0, %rsp # imm = 0x6F0
movq %rdi, -0x5d8(%rbp)
movq %rdi, %rax
movq %rax, -0x5d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x5c8(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x60530
movq -0x5c8(%rbp), %rdi
callq 0x51... | /JKorbelRA[P]CMake/Source/cmNinjaNormalTargetGenerator.cxx |
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.