name string | code string | asm string | file string |
|---|---|---|---|
stackjit::Amd64Backend::multIntToReg(std::vector<unsigned char, std::allocator<unsigned char>>&, stackjit::Registers, int, bool) | void Amd64Backend::multIntToReg(CodeGen& codeGen, Registers destReg, int srcValue, bool is32bits) {
if (!is32bits) {
codeGen.push_back(0x48);
}
codeGen.push_back(0x69);
codeGen.push_back(0xc0 | (Byte)destReg | ((Byte)destReg << 3));
IntToBytes converter;
converter.intValue = srcValue;
for (std::size... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xe59c3
movq -0x8(%rbp), %rdi
movb $0x48, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
mov... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::multIntToReg(std::vector<unsigned char, std::allocator<unsigned char>>&, stackjit::ExtendedRegisters, int) | void Amd64Backend::multIntToReg(CodeGen& codeGen, ExtendedRegisters destReg, int srcValue) {
codeGen.push_back(0x4d);
codeGen.push_back(0x69);
codeGen.push_back(0xc0 | (Byte)destReg | ((Byte)destReg << 3));
IntToBytes converter;
converter.intValue = srcValue;
for (std::size_t i = 0; i < sizeof(int); i++) ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0x4d, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
movb $0x69, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
movzbl ... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::divRegFromReg(std::vector<unsigned char, std::allocator<unsigned char>>&, stackjit::Registers, stackjit::Registers, bool) | void Amd64Backend::divRegFromReg(CodeGen& codeGen, Registers dest, Registers src, bool is32bits) {
assert(dest == Registers::AX && "Only the AX register is supported as dest.");
if (!is32bits) {
codeGen.push_back(0x48);
}
codeGen.push_back(0xf7);
codeGen.push_back(0xf8 | (Byte)src | ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
movb %dl, -0x9(%rbp)
movb %cl, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
xorl %eax, %eax
cmpb $0x0, -0x9(%rbp)
movb %al, -0xf(%rbp)
jne 0xe5be0
movb $0x1, %al
movb %al, -0xf(%rbp)
jmp 0xe5be0
movb -0xf(%rbp... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::divRegFromRegUnsigned(std::vector<unsigned char, std::allocator<unsigned char>>&, stackjit::Registers, stackjit::Registers, bool) | void Amd64Backend::divRegFromRegUnsigned(CodeGen& codeGen, Registers dest, Registers src, bool is32bits) {
assert(dest == Registers::AX && "Only the AX register is supported as dest.");
if (!is32bits) {
codeGen.push_back(0x48);
}
codeGen.push_back(0xf7);
codeGen.push_back(0xf0 | (Byte)src);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
movb %dl, -0x9(%rbp)
movb %cl, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
xorl %eax, %eax
cmpb $0x0, -0x9(%rbp)
movb %al, -0xf(%rbp)
jne 0xe5db0
movb $0x1, %al
movb %al, -0xf(%rbp)
jmp 0xe5db0
movb -0xf(%rbp... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::andIntToReg(std::vector<unsigned char, std::allocator<unsigned char>>&, stackjit::Registers, int, bool) | void Amd64Backend::andIntToReg(CodeGen& codeGen, Registers dest, int value, bool is32bits) {
if (!is32bits) {
codeGen.push_back(0x48);
}
if (dest == Registers::AX) {
codeGen.push_back(0x25);
} else {
codeGen.push_back(0x81);
codeGen.push_back(0xe0 | (Byte)dest);
}
IntToBytes converter;
conve... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xe60c3
movq -0x8(%rbp), %rdi
movb $0x48, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0xe6ff0
cmpb $0x0, -0x9(%rbp)
jne... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::andIntToReg(std::vector<unsigned char, std::allocator<unsigned char>>&, stackjit::ExtendedRegisters, int) | void Amd64Backend::andIntToReg(CodeGen& codeGen, ExtendedRegisters dest, int value) {
codeGen.push_back(0x49);
codeGen.push_back(0x81);
codeGen.push_back(0xe0 | (Byte)dest);
IntToBytes converter;
converter.intValue = value;
for (std::size_t i = 0; i < sizeof(int); i++) {
codeGen.push_back(converter.byt... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0x49, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
movb $-0x7f, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
movzbl... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::jumpEqual(std::vector<unsigned char, std::allocator<unsigned char>>&, int) | void Amd64Backend::jumpEqual(CodeGen& codeGen, int target) {
IntToBytes converter;
converter.intValue = target;
codeGen.push_back(0x0F);
codeGen.push_back(0x84);
for (std::size_t i = 0; i < sizeof(int); i++) {
codeGen.push_back(converter.byteValues[i]);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0xf, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
movb $-0x7c, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0xe6ff0
movq $0x0, -0x20(%rbp... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::jumpNotEqual(std::vector<unsigned char, std::allocator<unsigned char>>&, int) | void Amd64Backend::jumpNotEqual(CodeGen& codeGen, int target) {
IntToBytes converter;
converter.intValue = target;
codeGen.push_back(0x0F);
codeGen.push_back(0x85);
for (std::size_t i = 0; i < sizeof(int); i++) {
codeGen.push_back(converter.byteValues[i]);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0xf, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
movb $-0x7b, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0xe6ff0
movq $0x0, -0x20(%rbp... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::jumpGreaterThan(std::vector<unsigned char, std::allocator<unsigned char>>&, int) | void Amd64Backend::jumpGreaterThan(CodeGen& codeGen, int target) {
IntToBytes converter;
converter.intValue = target;
codeGen.push_back(0x0F);
codeGen.push_back(0x8F);
for (std::size_t i = 0; i < sizeof(int); i++) {
codeGen.push_back(converter.byteValues[i]);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0xf, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
movb $-0x71, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0xe6ff0
movq $0x0, -0x20(%rbp... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::jumpGreaterThanUnsigned(std::vector<unsigned char, std::allocator<unsigned char>>&, int) | void Amd64Backend::jumpGreaterThanUnsigned(CodeGen& codeGen, int target) {
IntToBytes converter;
converter.intValue = target;
codeGen.push_back(0x0F);
codeGen.push_back(0x87);
for (std::size_t i = 0; i < sizeof(int); i++) {
codeGen.push_back(converter.byteValues[i]);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0xf, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
movb $-0x79, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0xe6ff0
movq $0x0, -0x20(%rbp... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::jumpGreaterThanOrEqual(std::vector<unsigned char, std::allocator<unsigned char>>&, int) | void Amd64Backend::jumpGreaterThanOrEqual(CodeGen& codeGen, int target) {
IntToBytes converter;
converter.intValue = target;
codeGen.push_back(0x0F);
codeGen.push_back(0x8D);
for (std::size_t i = 0; i < sizeof(int); i++) {
codeGen.push_back(converter.byteValues[i]);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0xf, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
movb $-0x73, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0xe6ff0
movq $0x0, -0x20(%rbp... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::jumpGreaterThanOrEqualUnsigned(std::vector<unsigned char, std::allocator<unsigned char>>&, int) | void Amd64Backend::jumpGreaterThanOrEqualUnsigned(CodeGen& codeGen, int target) {
IntToBytes converter;
converter.intValue = target;
codeGen.push_back(0x0F);
codeGen.push_back(0x83);
for (std::size_t i = 0; i < sizeof(int); i++) {
codeGen.push_back(converter.byteValues[i]);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0xf, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
movb $-0x7d, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0xe6ff0
movq $0x0, -0x20(%rbp... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::jumpLessThan(std::vector<unsigned char, std::allocator<unsigned char>>&, int) | void Amd64Backend::jumpLessThan(CodeGen& codeGen, int target) {
IntToBytes converter;
converter.intValue = target;
codeGen.push_back(0x0F);
codeGen.push_back(0x8C);
for (std::size_t i = 0; i < sizeof(int); i++) {
codeGen.push_back(converter.byteValues[i]);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0xf, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
movb $-0x74, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0xe6ff0
movq $0x0, -0x20(%rbp... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::jumpLessThanUnsigned(std::vector<unsigned char, std::allocator<unsigned char>>&, int) | void Amd64Backend::jumpLessThanUnsigned(CodeGen& codeGen, int target) {
IntToBytes converter;
converter.intValue = target;
codeGen.push_back(0x0F);
codeGen.push_back(0x82);
for (std::size_t i = 0; i < sizeof(int); i++) {
codeGen.push_back(converter.byteValues[i]);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0xf, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
movb $-0x7e, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0xe6ff0
movq $0x0, -0x20(%rbp... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::Amd64Backend::jumpLessThanOrEqual(std::vector<unsigned char, std::allocator<unsigned char>>&, int) | void Amd64Backend::jumpLessThanOrEqual(CodeGen& codeGen, int target) {
IntToBytes converter;
converter.intValue = target;
codeGen.push_back(0x0F);
codeGen.push_back(0x8E);
for (std::size_t i = 0; i < sizeof(int); i++) {
codeGen.push_back(converter.byteValues[i]);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0xf, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0xe6ff0
movq -0x8(%rbp), %rdi
movb $-0x72, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0xe6ff0
movq $0x0, -0x20(%rbp... | /svenslaggare[P]StackJIT/src/compiler/x64/amd64.cpp |
stackjit::CodeGenerator::generateZeroLocals(stackjit::ManagedFunction&, stackjit::Amd64Assembler&) | void CodeGenerator::generateZeroLocals(ManagedFunction& function, Amd64Assembler& assembler) {
//Zero the locals
if (function.numLocals() > 0) {
assembler.bitwiseXor(Registers::AX, Registers::AX); //Zero rax
for (int i = 0; i < function.numLocals(); i++) {
int localOffset = (int)((i + function.def().numP... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10eb60
cmpq $0x0, %rax
jbe 0x1034be
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x1b(%rbp), %rdi
xorl %esi, %esi
movl %esi, -0x54(%rbp)
callq 0xe7a20
movl -0x54(%rbp), %... | /svenslaggare[P]StackJIT/src/compiler/x64/codegenerator.cpp |
stackjit::ExecutionEngine::loadAssembly(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, stackjit::AssemblyType) | bool ExecutionEngine::loadAssembly(std::string filePath, AssemblyType assemblyType) {
std::ios::openmode openMode = std::ios::in;
if (filePath.find(".simg") != std::string::npos) {
openMode = std::ios::binary;
}
std::ifstream fileStream(filePath, openMode);
if (!fileStream.is_open()) {
std::cout << "... | pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp # imm = 0x310
movq %rsi, -0x2c8(%rbp)
movq %rdi, %rax
movq -0x2c8(%rbp), %rdi
movq %rdi, -0x2c0(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2b8(%rbp)
movl $0x8, -0x20(%rbp)
leaq 0x4a838(%rip), %rs... | /svenslaggare[P]StackJIT/src/executionengine.cpp |
stackjit::ExecutionEngine::loadRuntimeLibrary() | void ExecutionEngine::loadRuntimeLibrary() {
if (mVMState.config.loadRuntimeLibrary) {
bool loaded = loadAssembly(mBaseDir + "rtlib/rtlib.simg");
if (!loaded) {
throw std::runtime_error("Could not load the runtime library.");
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rax), %rax
testb $0x1, 0xa(%rax)
je 0x113657
movq -0x48(%rbp), %rsi
addq $0x128, %rsi # imm = 0x128
leaq 0x4a581(%rip), %rdx # 0x15db34
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq... | /svenslaggare[P]StackJIT/src/executionengine.cpp |
stackjit::Runtime::getExecutableDir[abi:cxx11]() | std::string getExecutableDir() {
const int bufferSize = 512;
char buffer[bufferSize];
char temp[32];
sprintf(temp, "/proc/%d/exe", getpid());
int bytes = std::min((int)readlink(temp, buffer, bufferSize), bufferSize - 1);
if (bytes >= 0) {
buffer[bytes] = '\0';
}
//Remove the name
buffer... | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %rdi, -0x268(%rbp)
movq %rdi, %rax
movq %rax, -0x260(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x200, -0xc(%rbp) # imm = 0x200
leaq -0x230(%rbp), %rax
movq %rax, -0x258(%rbp)
callq 0xc25e0
movq -0x258(%rbp), %rdi
movl %eax, %edx
leaq 0x446c1(%rip),... | /svenslaggare[P]StackJIT/src/linux/runtime.cpp |
stackjit::ClassLoader::loadClasses(stackjit::ImageContainer&) | void ClassLoader::loadClasses(ImageContainer& imageContainer) {
std::vector<Loader::Class> classes;
forEachClass(imageContainer, [&](const stackjit::Loader::Class& classDef) {
imageContainer.loadClassBody(classDef.name());
classes.push_back(classDef);
});
loadClasses(classes);
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x11abc0
movq -0x80(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
leaq -0x48... | /svenslaggare[P]StackJIT/src/loader/classloader.cpp |
stackjit::AssemblyImage::loadClassBody(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | bool AssemblyImage::loadClassBody(std::string className) {
if (mClassBodyOffsets.count(className) > 0) {
auto bodyOffset = mClassBodyOffsets[className];
Loader::Class& classDef = mClasses[className];
classDef.parentClassName() = loadString(mImageData, bodyOffset);
classDef.attributes() = AssemblyImageLoa... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rsi, -0x1e0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
addq $0x50, %rdi
callq 0x127270
cmpq $0x0, %rax
jbe 0x1261e7
movq -0x1d8(%rbp), %rdi
movq -0x1e0(%rbp), %rsi
addq $0x50, %rdi
callq 0... | /svenslaggare[P]StackJIT/src/loader/imageloader.cpp |
stackjit::StackWalker::visitReferences(stackjit::StackFrame const&, std::function<void (stackjit::StackFrameEntry)>, std::function<void (stackjit::StackFrame const&)>) | void StackWalker::visitReferences(const StackFrame& stackFrame, VisitReferenceFn fn, VisitFrameFn frameFn) {
if (frameFn) {
frameFn(stackFrame);
}
//Visit the calling stack frame
visitReferencesInFrame(stackFrame, fn);
//Then all other stack frames
auto topEntryPtr = mVMState.engine().callStack().top()... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rcx, -0xe0(%rbp)
movq %rdi, %rax
movq -0xe0(%rbp), %rdi
movq %rdx, -0xd8(%rbp)
movq %rdi, -0xd0(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
callq ... | /svenslaggare[P]StackJIT/src/runtime/stackframe.cpp |
stackjit::TestLibrary::add(stackjit::VMState&) | void TestLibrary::add(VMState& vmState) {
auto& binder = vmState.binder();
auto intType = vmState.typeProvider().makeType(TypeSystem::toString(PrimitiveTypes::Integer));
auto voidType = vmState.typeProvider().makeType(TypeSystem::toString(PrimitiveTypes::Void));
binder.define(FunctionDefinition("rt.test.fib", ... | pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp # imm = 0x320
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x158880
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x158840
movq %rax, -0x2a8(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x2a0(%rbp)
movl $0x1, %esi
callq 0x155200
movq -0x2a8(%rbp), %rdi
movq ... | /svenslaggare[P]StackJIT/src/test/test.cpp |
stackjit::FieldRef<int> stackjit::ClassRef::getField<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, stackjit::Type const*) | FieldRef<T> ClassRef::getField(std::string name, const Type* type) {
if (mMetadata.fields().count(name) > 0) {
auto& fieldRef = mMetadata.fields().at(name);
if (*fieldRef.type() != *type) {
throw std::runtime_error(
"Expected field to be of type '" + type->name() + "' but got type '" + fieldRef.type()... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rsi, -0x148(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
movq 0x18(%rax), %rdi
callq 0x14b940
movq -0x148(%rbp), %rsi
movq %rax, %rdi
callq 0x14b4d0
cmpq $0x0, %rax
jb... | /svenslaggare[P]StackJIT/src/test/../runtime/../type/objectref.hpp |
stackjit::toString[abi:cxx11](stackjit::AccessModifier const&) | std::string toString(const AccessModifier& accessModifier) {
switch (accessModifier) {
case AccessModifier::Private:
return "private";
case AccessModifier::Public:
return "public";
default:
return "";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x27(%rbp)
testb %al, %al
je 0x14b6d6
jmp 0x14b6ca
movb -0x27(%rbp), %al
subb $0x1, %al
je 0x14b721
jmp 0x14b766
leaq ... | /svenslaggare[P]StackJIT/src/type/classmetadata.cpp |
stackjit::ClassMetadata::insertField(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, stackjit::Field const&) | void ClassMetadata::insertField(const std::string& name, const Field& field) {
if (mFields.count(name) > 0) {
throw std::runtime_error("The field '" + name + "' is already defined in the class '" + mName + "'.");
}
mFields.insert({ name, field });
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
addq $0x48, %rdi
movq -0x10(%rbp), %rsi
callq 0x14b4d0
cmpq $0x0, %rax
jbe 0x14bb9c
movb $0x1, -0xa5(%rbp)
movl $0x10, %edi
callq 0xc2210... | /svenslaggare[P]StackJIT/src/type/classmetadata.cpp |
stackjit::ClassMetadata::setParentClass(stackjit::ClassType const*) | void ClassMetadata::setParentClass(const ClassType* parentClass) {
if (mParentClass != nullptr) {
throw std::runtime_error("The parent class has already been set.");
}
this->mParentClass = parentClass;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x28(%rax)
je 0x14bebf
movl $0x10, %edi
callq 0xc2210
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x1311d(%rip), %rsi # 0x15efa7
callq 0xc21a0
jmp 0x14be91... | /svenslaggare[P]StackJIT/src/type/classmetadata.cpp |
stackjit::ClassMetadata::getVirtualFunctionIndex(stackjit::FunctionDefinition const&) const | int ClassMetadata::getVirtualFunctionIndex(const FunctionDefinition& funcDef) const {
auto rootDef = getVirtualFunctionRootDefinition(&funcDef);
auto signature = FunctionSignature::from(*rootDef).str();
if (mVirtualFunctionToIndex.count(signature) == 0) {
throw std::runtime_error("There exists no virtual funct... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x108(%rbp)
movq -0x10(%rbp), %rsi
callq 0x14c1c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x111fd0
movq -0x100(%... | /svenslaggare[P]StackJIT/src/type/classmetadata.cpp |
stackjit::ClassMetadata::getVirtualFunctionRootDefinition(stackjit::FunctionDefinition const*) const | const FunctionDefinition* ClassMetadata::getVirtualFunctionRootDefinition(const FunctionDefinition* funcDef) const {
if (mParentClass != nullptr) {
for (auto parentDef : mParentClass->metadata()->mVirtualFunctions) {
if (funcDef->memberName() == parentDef->memberName()
&& TypeSystem::areEqual(funcDef->cal... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, 0x28(%rax)
je 0x14c2bb
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1557d0
addq $0x80, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14d410
movq %rax, -... | /svenslaggare[P]StackJIT/src/type/classmetadata.cpp |
stackjit::ClassMetadata::bindVirtualFunction(stackjit::FunctionDefinition const&, unsigned char*) | void ClassMetadata::bindVirtualFunction(const FunctionDefinition& funcDef, BytePtr funcPtr) {
if (mVirtualFunctionTable == nullptr) {
throw std::runtime_error("Virtual function table not created.");
}
auto index = getVirtualFunctionIndex(funcDef);
mVirtualFunctionTable[index] = funcPtr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x118(%rax)
jne 0x14c376
movl $0x10, %edi
callq 0xc2210
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x12cb0(%rip), %rsi # 0x15eff1
c... | /svenslaggare[P]StackJIT/src/type/classmetadata.cpp |
stackjit::ClassMetadata::makeVirtualFunctionTable() | bool ClassMetadata::makeVirtualFunctionTable() {
if (mVirtualFunctionTable == nullptr && (mVirtualFunctions.size() > 0 || mParentClass != nullptr)) {
int virtualFuncIndex = 0;
bool hasParentVirtual = false;
std::unordered_map<std::string, std::string> virtualFuncMapping;
//Create for parent class
if (... | pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp # imm = 0x340
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x260(%rbp)
cmpq $0x0, 0x118(%rax)
jne 0x14cc07
movq -0x260(%rbp), %rdi
addq $0x80, %rdi
callq 0x14d4f0
cmpq $0x0, %rax
ja 0x14c423
movq -0x260(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x14cc07
mo... | /svenslaggare[P]StackJIT/src/type/classmetadata.cpp |
stackjit::ClassMetadataProvider::createVirtualFunctionTables(stackjit::VMState const&) | void ClassMetadataProvider::createVirtualFunctionTables(const VMState& vmState) {
for (auto& current : mClassesMetadata) {
auto& currentClass = current.second;
auto createdVTable = currentClass.makeVirtualFunctionTable();
if (createdVTable && vmState.config.enableDebug && vmState.config.printVirtualFunction... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x14d990
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x14d9c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14d9f0
tes... | /svenslaggare[P]StackJIT/src/type/classmetadata.cpp |
stackjit::ObjectRef::ObjectRef(unsigned char*) | ObjectRef::ObjectRef(RawObjectRef objRef)
: mPtr(objRef - stackjit::OBJECT_HEADER_SIZE), mType(*((const Type**)mPtr)) {
if (type()->isArray()) {
auto arrayType = static_cast<const ArrayType*>(type());
auto elementType = arrayType->elementType();
auto elementSize = TypeSystem::sizeOfType(elementType);
au... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $-0x9, %rax
movq %rax, (%rdi)
movq (%rdi), %rax
movq (%rax), %rax
movq %rax, 0x8(%rdi)
callq 0x1429b0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
test... | /svenslaggare[P]StackJIT/src/type/objectref.cpp |
stackjit::TypeSystem::toString[abi:cxx11](stackjit::PrimitiveTypes) | std::string TypeSystem::toString(PrimitiveTypes primitiveType) {
switch (primitiveType) {
case PrimitiveTypes::Void:
return "Void";
case PrimitiveTypes::Integer:
return "Int";
case PrimitiveTypes::Float:
return "Float";
case PrimitiveTypes::Bool:
return "Bool";
case PrimitiveTypes::Char... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x4, %rax
ja 0x1553b4
movq -0x30(%rbp), %rax
leaq 0x9e02(%rip), %rcx # 0x15f03c
movslq (%rcx,%rax,... | /svenslaggare[P]StackJIT/src/type/type.cpp |
stackjit::TypeSystem::fromString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, stackjit::PrimitiveTypes&) | bool TypeSystem::fromString(std::string typeName, PrimitiveTypes& primitiveType) {
if (typeName == "Int") {
primitiveType = PrimitiveTypes::Integer;
return true;
} else if (typeName == "Float") {
primitiveType = PrimitiveTypes::Float;
return true;
} else if (typeName == "Bool") {
primitiveType = Pr... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x98cb(%rip), %rsi # 0x15f0f6
callq 0xcb3e0
testb $0x1, %al
jne 0x155836
jmp 0x155846
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1558de
movq -0x20(%rbp), %rdi
leaq 0x98a9(... | /svenslaggare[P]StackJIT/src/type/type.cpp |
stackjit::TypeSystem::areEqual(std::vector<stackjit::Type const*, std::allocator<stackjit::Type const*>> const&, std::vector<stackjit::Type const*, std::allocator<stackjit::Type const*>> const&) | bool TypeSystem::areEqual(const std::vector<const Type*>& list1, const std::vector<const Type*>& list2) {
if (list1.size() != list2.size()) {
return false;
}
for (std::size_t i = 0; i < list1.size(); i++) {
if (*list1[i] != *list2[i]) {
return false;
}
}
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xda950
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xda950
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x155a58
movb $0x0, -0x1(%rbp)
jmp 0x155aca
movq $0x0, -0x20(%rbp)
movq -0x... | /svenslaggare[P]StackJIT/src/type/type.cpp |
stackjit::TypeSystem::sizeOfType(stackjit::PrimitiveTypes) | std::size_t TypeSystem::sizeOfType(PrimitiveTypes primitiveType) {
switch (primitiveType) {
case PrimitiveTypes::Void:
return 0;
case PrimitiveTypes::Integer:
return 4;
case PrimitiveTypes::Float:
return 4;
case PrimitiveTypes::Bool:
return 1;
case PrimitiveTypes::Char:
return 1;
}
retur... | pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x155bfe
movq -0x18(%rbp), %rax
leaq 0x948d(%rip), %rcx # 0x15f050
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x155c06
movq $0x4, -0x8(%rbp)
jmp 0x15... | /svenslaggare[P]StackJIT/src/type/type.cpp |
stackjit::TypeSystem::sizeOfType(stackjit::Type const*) | std::size_t TypeSystem::sizeOfType(const Type* type) {
auto typeName = type->name();
PrimitiveTypes primitiveType;
if (fromString(typeName, primitiveType)) {
return sizeOfType(primitiveType);
} else if (type->isReference()) {
return sizeof(BytePtr);
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x155020
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xc21d0
movq -0x70(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xc21d0
jmp 0x155c47
leaq -0x58(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x155810
movb ... | /svenslaggare[P]StackJIT/src/type/type.cpp |
stackjit::TypeSystem::getClassAndFieldName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool TypeSystem::getClassAndFieldName(std::string str, std::string& className, std::string& fieldName) {
auto fieldSepPos = str.find("::");
if (fieldSepPos != std::string::npos) {
className = str.substr(0, fieldSepPos);
fieldName = str.substr(fieldSepPos + 2);
return true;
} ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x543a(%rip), %rsi # 0x15b169
xorl %eax, %eax
movl %eax, %edx
callq 0xc2790
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x155da6
movq -0x70(%rbp), %rsi
movq -0x28(%rbp)... | /svenslaggare[P]StackJIT/src/type/type.cpp |
stackjit::TypeProvider::~TypeProvider() | TypeProvider::~TypeProvider() {
for (auto type : mTypes) {
delete type.second;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x156a00
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x156a30
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x156a60
tes... | /svenslaggare[P]StackJIT/src/type/typeprovider.cpp |
stackjit::TypeProvider::makeType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | const Type* TypeProvider::makeType(std::string name) {
if (mTypes.count(name) > 0) {
return mTypes[name];
}
//Split the type name
auto typeParts = splitTypeName(name);
Type* type = nullptr;
PrimitiveTypes primitiveType;
if (TypeSystem::fromString(typeParts.at(0), primitiveType)) {
type = new Primi... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %rsi, -0x198(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x190(%rbp)
callq 0x156b70
cmpq $0x0, %rax
jbe 0x15601f
movq -0x198(%rbp), %rsi
movq -0x190(%rbp), %rdi
callq 0x156ba0
movq (%rax), %rax
movq %ra... | /svenslaggare[P]StackJIT/src/type/typeprovider.cpp |
(anonymous namespace)::extractElementType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool extractElementType(std::string typePart, std::string& elementPart) {
std::string buffer;
bool foundArrayElement = false;
bool foundStart = false;
int bracketCount = 0;
for (char c : typePart) {
if (c == '[') {
bracketCount++;
}
if (c == ']') {
bracketCount--;
}
if (c == ']' && b... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc2580
movq -0x78(%rbp), %rdi
movb $0x0, -0x39(%rbp)
movb $0x0, -0x3a(%rbp)
movl $0x0, -0x40(%rbp)
movq %rdi, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xc2380
movq %rax, -0x50(%... | /svenslaggare[P]StackJIT/src/type/typeprovider.cpp |
stackjit::VMState::VMState(stackjit::VMStateConfig) | VMState::VMState(VMStateConfig config)
: config(config),
mTypeProvider(mClassProvider),
mGC(*this),
mEngine(*this) {
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
movups %xmm1, 0xc(%rdi)
movups %xmm0, (%rdi)
addq $0x20, %rdi
movq %rdi, -0x28(%rbp)
callq 0x158980
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %... | /svenslaggare[P]StackJIT/src/vmstate.cpp |
_cxx_global_array_dtor | Contract *HumanPlayer::proposeContract(Contract *current_max) {
int color = -1, trick_amount;
cout << AdvancedConsole::Cursor(6, 0) << AdvancedConsole::Erase(AdvancedConsole::AC_AFTER);
displayHand(7);
if (current_max) {
cout << "Current contract: " << *current_max << endl;
}
int i = 0;
... | pushq %r14
pushq %rbx
pushq %rax
movl $0x80, %ebx
leaq 0x18ab0(%rip), %r14 # 0x1dc70
leaq (%r14,%rbx), %rdi
callq 0x4170
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x51c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /zek[P]Bridge-Game/HumanPlayer.cpp |
GLOBAL__sub_I_Memento.cpp | void Memento::setRound(int value) {
round = value;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x1af83(%rip), %rbx # 0x21170
leaq 0xbe10(%rip), %rsi # 0x12004
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x4140
leaq 0x1af88(%rip), %r14 # 0x21190
leaq 0xbdfa(%rip), %rsi # 0x12009
leaq 0x6(%rsp), %rdx
movq %r14, %rdi
callq 0x4140
leaq 0x1af8d(%... | /zek[P]Bridge-Game/Memento.cpp |
Game::Game() | Game::Game() {
cout << AdvancedConsole::Cursor(0, 0) << AdvancedConsole::Erase();
cout << "Welcome to the Bridge Game." << endl << endl;
Memento *mem = Memento::loadFile();
if (mem) {
cout << "Do you want to load last game?" << endl;
string q;
cout << "Yes(y) or No(n) : ";
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x28(%rsp)
leaq 0x50(%rsp), %rbx
pushq $0x1
popq %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10fc4
movq 0x16931(%rip), %r14 # 0x1cfd0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10ac8... | /zek[P]Bridge-Game/Game.cpp |
Game::setTeams() | void Game::setTeams() {
Team *team1 = new Team("Team 1", _players[0], _players[2]);
Team *team2 = new Team("Team 2", _players[1], _players[3]);
_teams = {team1, team2};
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
pushq $0x58
popq %rdi
callq 0x4330
movq %rax, %rbx
leaq 0xb53c(%rip), %rsi # 0x121a4
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4140
movq (%r14), %rdx
movq 0x10(%r14), %rcx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x98e8
leaq 0x30(%rsp), ... | /zek[P]Bridge-Game/Game.cpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator[](unsigned long) | reference operator[](size_type idx)
{
// implicitly convert null value to an empty array
if (is_null())
{
m_type = value_t::array;
m_value.array = create<array_t>();
assert_invariant();
}
// operator[] only works for arrays
if (JSO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
jne 0x6f26
movb $0x2, (%r14)
callq 0x73be
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x7282
movb (%r14), %al
cmpb $0x2, %al
jne 0x6f97
movq 0x8(%r14), %r15
movq (%r15), %rax... | /zek[P]Bridge-Game/json.hh |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::basic_json(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::a... | basic_json(const basic_json& other)
: m_type(other.m_type)
{
// check of passed value is valid
other.assert_invariant();
switch (m_type)
{
case value_t::object:
{
m_value = *other.m_value.object;
break;
}
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb (%rsi), %al
movb %al, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
callq 0x7282
movzbl (%rbx), %eax
decl %eax
cmpl $0x6, %eax
ja 0x71cf
leaq 0xaeb2(%rip), %rcx # 0x12048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
j... | /zek[P]Bridge-Game/json.hh |
nlohmann::detail::exception::name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | static std::string name(const std::string& ename, int id_)
{
return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %edx, %ebp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0xadb8(%rip), %rsi # 0x1238a
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x6e50
leaq 0xba60(%rip), %rdx # 0x13046
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x7698
movq %rsp, %rdi
movl %ebp, %esi
callq 0x77... | /zek[P]Bridge-Game/json.hh |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::type_name() const | const char* type_name() const noexcept
{
{
switch (m_type)
{
case value_t::null:
return "null";
case value_t::object:
return "object";
case value_t::array:
return "array";
... | movzbl (%rdi), %eax
cmpq $0x8, %rax
ja 0x7a80
leaq 0xaca4(%rip), %rcx # 0x1271c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0xab67(%rip), %rax # 0x125ee
retq
| /zek[P]Bridge-Game/json.hh |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator=(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | reference& operator=(basic_json other) noexcept (
std::is_nothrow_move_constructible<value_t>::value and
std::is_nothrow_move_assignable<value_t>::value and
std::is_nothrow_move_constructible<json_value>::value and
std::is_nothrow_move_assignable<json_value>::value
)
{
//... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7282
movb (%r14), %al
movb (%rbx), %cl
movb %cl, (%r14)
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x7282
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
pop... | /zek[P]Bridge-Game/json.hh |
Player::displayHand(int) | void Player::displayHand(int row) {
cout << AdvancedConsole::Cursor(row, 0) << AdvancedConsole::Erase(AdvancedConsole::AC_ALL, AdvancedConsole::AC_LINE)
<< "Your Hand: ";
for (Card *c: _hand) {
cout << *c << " ";
}
cout << endl << endl;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x14(%rsp), %r15
pushq $0x1
popq %rbp
movq %r15, %rdi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x10fc4
movq 0x146b4(%rip), %rbx # 0x1cfd0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10ac8
movq %rax, %r15
leaq 0xc(%rsp), %r12
pushq... | /zek[P]Bridge-Game/Player.cpp |
Player::getAvailableCards(Color::Type) | std::vector<Card *> Player::getAvailableCards(Color::Type color) {
std::vector<Card *> available_cards;
copy_if(_hand.begin(), _hand.end(), std::back_inserter(available_cards),
[color](const Card *card) {
return card->getColor() == color;
});
if (available_cards.empty... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0x8(%rsi), %r14
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %r13
cmpq %r13, %r12
je 0x8a39
movq (%r12), %rdi
callq 0xa3ee
cmpl %... | /zek[P]Bridge-Game/Player.cpp |
Player::serializeHand[abi:cxx11]() | json Player::serializeHand() {
json hand;
for (auto c: _hand) {
hand += c->serialize();
}
return hand;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x7242
movq 0x8(%r14), %r15
movq 0x10(%r14), %r12
leaq 0x8(%rsp), %r14
cmpq %r12, %r15
je 0x8d66
movq (%r15), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x96... | /zek[P]Bridge-Game/Player.cpp |
nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::operator++() | iter_impl& operator++()
{
assert(m_object != nullptr);
switch (m_object->m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std:... | pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x9075
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x9065
cmpl $0x1, %eax
jne 0x906c
leaq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x95b4
jmp 0x9070
addq $0x10, 0x10(%rbx)
jmp 0x9070
incq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x9714(%rip), %rdi ... | /zek[P]Bridge-Game/json.hh |
nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::operator==(nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::_... | bool operator==(const iter_impl& other) const
{
// if objects are not the same, the comparison is undefined
if (JSON_UNLIKELY(m_object != other.m_object))
{
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
}
assert(m_... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x9442
testq %rax, %rax
je 0x9490
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x9424
cmpl $0x1, %eax
jne 0x942e
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0x9436
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x9436
movq 0x18(%rdi)... | /zek[P]Bridge-Game/json.hh |
Team::Team(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Player*, Player*) | Team::Team(string name, Player *player1, Player *player2) {
_name.assign(name);
_players = {player1, player2};
player1->setTeam(this);
player2->setTeam(this);
_gameScore = 0;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rdi, %r14
leaq 0x1318f(%rip), %rax # 0x1ca90
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rbx
movb $0x0, 0x18(%rdi)
leaq 0x38(%rdi), %r12
movq %r12, 0x40(%rdi)
movq %r1... | /zek[P]Bridge-Game/Team.cpp |
Team::serialize[abi:cxx11]() | json Team::serialize() {
json data;
data["name"] = _name;
data["game_score"] = _gameScore;
json tricks_won;
for (auto t : _tricksWon) {
tricks_won += t->serialize();
}
data["tricks_won"] = tricks_won;
return data;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x7242
leaq 0x8(%r14), %rsi
leaq 0x30(%rsp), %rdi
callq 0x9d28
leaq 0x8cb4(%rip), %rsi # 0x1274f
movq %rbx, %rdi
callq 0x7048
leaq 0x30(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x7... | /zek[P]Bridge-Game/Team.cpp |
HumanPlayer::makeDecision(std::vector<Card*, std::allocator<Card*>>) | Card *HumanPlayer::makeDecision(std::vector<Card *> available_cards) {
cout << AdvancedConsole::Cursor(8, 0) << AdvancedConsole::Erase(AdvancedConsole::AC_ALL, AdvancedConsole::AC_LINE)
<< "It's Player " << *this << "'s turn." << endl;
displayHand(9);
cout << AdvancedConsole::Erase(AdvancedConsol... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x4(%rsp), %r13
pushq $0x8
popq %rsi
xorl %r15d, %r15d
pushq $0x1
popq %r14
movq %r13, %rdi
xorl %edx, %edx
movl %r14d, %ecx
callq 0x10fc4
movq 0x12eb5(%rip), %rdi # 0x1cfd0
movq %r13, %rsi
callq ... | /zek[P]Bridge-Game/HumanPlayer.cpp |
Card::isBigger(Card*, Contract*) | bool Card::isBigger(Card *rhs, Contract *c) {
if (rhs->getColor() == getColor()) {
return getValue() > rhs->getValue();
}
return getColor() == c->getColor() && rhs->getColor() != c->getColor();
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl 0xc(%rdi), %ebp
cmpl %ebp, 0xc(%rsi)
jne 0xa40d
movl 0x8(%rdi), %eax
cmpl 0x8(%r14), %eax
setg %al
jmp 0xa431
movq %rdx, %rbx
movq %rdx, %rdi
callq 0xbda4
cmpl %eax, %ebp
jne 0xa42f
movl 0xc(%r14), %ebp
movq %rbx, %rdi
callq 0xbda4
cmpl %eax, %ebp
setne %al
jmp 0xa4... | /zek[P]Bridge-Game/Card.cpp |
Trick::getWinner(Contract*) | int Trick::getWinner(Contract *c) {
std::list<pair<Card *, int>>::iterator it = _cards.begin();
pair<Card *, int> biggest = *it;
for (++it; it != _cards.end(); ++it) {
if (it->first->isBigger(biggest.first, c)) {
biggest = *it;
}
}
return biggest.second;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
addq $0x8, %r14
movq 0x10(%r12), %r15
movl 0x18(%r12), %ebp
movq (%r12), %r12
cmpq %r14, %r12
je 0xa615
movq 0x10(%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xa3f2
testb %al, %al
je 0xa5f6
jmp 0xa5ec
movl ... | /zek[P]Bridge-Game/Trick.cpp |
Trick::unserialize(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>) | Trick *Trick::unserialize(json data) {
Trick *t = new Trick;
for (const auto &c: data) {
t->addCard(Card::get(c[1]), c[0]);
}
return t;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x4330
movq %rax, %rbx
leaq 0x123bd(%rip), %rax # 0x1cb40
movq %rax, (%rbx)
leaq 0x8(%rbx), %rax
movq %rax, 0x10(%rbx)
movq %rax, 0x8(%rbx)
andq $0x0, 0x18(%rbx)
leaq 0x28(%rsp), %r14
movq ... | /zek[P]Bridge-Game/Trick.cpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::push_back(std::initializer_list<nlohmann::detail::json_ref<nlohmann::basic_json<std::map, std::vector, std::__cxx11::b... | void push_back(initializer_list_t init)
{
if (is_object() and init.size() == 2 and (*init.begin())->is_string())
{
basic_json&& key = init.begin()->moved_or_copied();
push_back(typename object_t::value_type(
std::move(key.get_ref<string_t&>()), (init... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rdi)
sete %al
cmpq $0x2, %rdx
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xaa77
movq 0x10(%r14), %rax
cmpb $0x3, (%rax)
jne 0xaa77
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xaae6
movq %r15, %rdi
callq 0xadd6... | /zek[P]Bridge-Game/json.hh |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::basic_json(std::initializer_list<nlohmann::detail::json_ref<nlohmann::basic_json<std::map, std::vector, std::__cxx11::... | basic_json(initializer_list_t init,
bool type_deduction = true,
value_t manual_type = value_t::array)
{
// check if each element is an array with two elements whose first
// element is a string
bool is_an_object = std::all_of(init.begin(), init.end(),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdi, %rbx
movb $0x0, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r14
movq %rsi, %r15
shlq $0x5, %r14
addq %rsi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0xae99
testl %r12d, %r12d
jne 0xac68
cmpb $0x2, %bpl
setne... | /zek[P]Bridge-Game/json.hh |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::basic_json(std::initializer_list<nlohmann::detail::json_ref<nlohmann::basic_json<std::map, std::vector, std::__cxx11::... | value_type const* operator->() const
{
return static_cast<value_type const*>(value_ref);
} | pushq %rbx
movq 0x10(%rsi), %rdi
cmpb $0x2, (%rdi)
jne 0xb0a5
movq %rsi, %rbx
callq 0xb0aa
cmpq $0x2, %rax
jne 0xb0a5
movq 0x10(%rbx), %rdi
xorl %esi, %esi
callq 0xa864
cmpb $0x3, (%rax)
sete %al
jmp 0xb0a7
xorl %eax, %eax
popq %rbx
retq
nop
| /zek[P]Bridge-Game/json.hh |
ComputerPlayer::theGreatestAvailable() | Card *ComputerPlayer::theGreatestAvailable() {
vector<Card *>::iterator it = available_cards.begin();
Card *greatest = *it;
//greatest Card in available cards
Card *tmp = *it;
for (++it; it != available_cards.end(); ++it) {
tmp = *it;
if (tmp->isBigger(greatest, _game->getCurrentDea... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %r12
movq (%r12), %r14
addq $0x8, %r12
cmpq 0x60(%rbx), %r12
je 0xb56a
movq (%r12), %r15
movq 0x50(%rbx), %rdi
callq 0x65e8
movq %rax, %rdi
callq 0xbe84
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa3f2
testb %al, %al
jne... | /zek[P]Bridge-Game/ComputerPlayer.cpp |
ComputerPlayer::greatestOnTable() | Card *ComputerPlayer::greatestOnTable() {
vector<Card *>::iterator iter = cardsOnTable.begin();
Card *greatest = *iter;
//greatest Card on the table
Card *tmp = *iter;
for (++iter; iter != cardsOnTable.end(); ++iter) {
tmp = *iter;
if (tmp->isBigger(greatest, _game->getCurrentDeal()... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x70(%rdi), %r12
movq (%r12), %r14
addq $0x8, %r12
cmpq 0x78(%rbx), %r12
je 0xb718
movq (%r12), %r15
movq 0x50(%rbx), %rdi
callq 0x65e8
movq %rax, %rdi
callq 0xbe84
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa3f2
testb %al, %al
jne... | /zek[P]Bridge-Game/ComputerPlayer.cpp |
_gnu_cxx::__normal_iterator<Card**, std::vector<Card*, std::allocator<Card*>>> select_randomly<__gnu_cxx::__normal_iterator<Card**, std::vector<Card*, std::allocator<Card*>>>, std::mersenne_twister_engine<unsigned long, 32ul, 624ul, 397ul, 31ul, 2567483615ul, 11ul, 4294967295ul, 7ul, 2636928640ul, 15ul, 4022730752ul, 1... | Iter select_randomly(Iter start, Iter end, RandomGenerator &g) {
std::uniform_int_distribution<> dis(0, std::distance(start, end) - 1);
std::advance(start, dis(g));
return start;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
subq %rdi, %rsi
shrq $0x3, %rsi
decl %esi
leaq 0x8(%rsp), %rdi
andl $0x0, (%rdi)
movl %esi, 0x4(%rdi)
movq %rdx, %rsi
callq 0xbb56
cltq
leaq (%rbx,%rax,8), %rax
addq $0x10, %rsp
popq %rbx
retq
| /zek[P]Bridge-Game/misc.h |
Deal::bidding() | void Deal::bidding() {
int speaker = ((_contractor == -1 ? _dealer : _contractor) + 1) % 4;
int nbrOfPass = 0;
Contract *tmp_c;
cout << AdvancedConsole::Erase();
cout << AdvancedConsole::Cursor(0, 0) << "Proposes:";
while ((nbrOfPass < 3) || (nbrOfPass == 3 && _contract == nullptr)) {
co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x34(%rdi), %ebp
cmpl $-0x1, %ebp
jne 0xbfa6
movl 0x30(%rbx), %ebp
leaq 0x14(%rsp), %r14
pushq $0x2
popq %rsi
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
callq 0x10fda
movq 0x1100e(%rip), %r13 # 0x1cfd0
mov... | /zek[P]Bridge-Game/Deal.cpp |
Deal::scoreIfWon(int) | int Deal::scoreIfWon(int nbrOfOddTricks) {
int slamBonus;
int contractPoints = 0;
switch (_contract->getTricksAmount()) {
case 6:
slamBonus = 500;
break;
case 7:
slamBonus = 1000;
break;
default :
slamBonus = 0;
... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rdi
callq 0xbda0
movl %eax, %ebx
movq (%r14), %rdi
callq 0xbda4
cmpl $0x2, %eax
jb 0xc511
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0xc516
imull $0x1e, %ebp, %ecx
jmp 0xc523
imull $0x14, %ebp, %ecx
jmp 0xc523
xorl %ecx, %ecx
cmpl $0x4, %eax
... | /zek[P]Bridge-Game/Deal.cpp |
Color::Type nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::get<Color::Type, Color::Type, 0>() const | ValueType get() const noexcept(noexcept(
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
{
// we cannot static_assert on ValueTypeCV being non-const, because
// there is support for get<const basic_json_t>... | pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0xc7b0
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
| /zek[P]Bridge-Game/json.hh |
Memento::saveFile() | void Memento::saveFile() {
json j;
j["round"] = round;
j["first_player"] = first_player;
j["players"] = players;
j["contractor"] = contractor;
j["contract"] = contract;
j["state"] = state;
j["teams"] = teams;
std::ofstream o("history.data");
o << j << std::endl;
} | pushq %r14
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x7242
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
callq 0x9d42
leaq 0x6b86(%rip), %rsi # 0x13598
movq %r14, %rdi
callq 0x7048
leaq 0x78(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
... | /zek[P]Bridge-Game/Memento.cpp |
nlohmann::operator<<(std::ostream&, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const&) | friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
{
// read width member and use it as indentation parameter if nonzero
const bool pretty_print = (o.width() > 0);
const auto indentation = (pretty_print ? o.width() : 0);
// reset width to 0 for subsequent calls to... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq 0x10(%rdi,%rax), %r13
xorl %r14d, %r14d
testq %r13, %r13
cmovgq %r13, %r14
movq %rsi, %r15
andq $0x0, 0x10(%rdi,%rax)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
cal... | /zek[P]Bridge-Game/json.hh |
nlohmann::detail::serializer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::serializer(std::shared_ptr<nlohmann::detail::output_adapter_protocol<char>>, char) | serializer(output_adapter_t<char> s, const char ichar)
: o(std::move(s)), loc(std::localeconv()),
thousands_sep(loc->thousands_sep == nullptr ? '\0' : * (loc->thousands_sep)),
decimal_point(loc->decimal_point == nullptr ? '\0' : * (loc->decimal_point)),
indent_char(ichar), indent_s... | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
andq $0x0, 0x8(%rdi)
movups (%rsi), %xmm0
andq $0x0, 0x8(%rsi)
movups %xmm0, (%rdi)
andq $0x0, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
callq 0x45d0
movq %rax, 0x50(%r14)... | /zek[P]Bridge-Game/json.hh |
nlohmann::detail::serializer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::dump_escaped(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<cha... | void dump_escaped(const string_t& s, const bool ensure_ascii) const
{
throw_if_invalid_utf8(s);
const auto space = extra_space(s, ensure_ascii);
if (space == 0)
{
o->write_characters(s.c_str(), s.size());
return;
}
// create a result string o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe0a2
movq %r14, %rdi
movl %ebp, %esi
callq 0xe36a
testq %rax, %rax
je 0xdcee
movq %rbx, 0x30(%rsp)
addq 0x8(%r14), %rax
leaq 0x20(%rsp), %rcx
movq %rcx, -0x10(%rcx)
... | /zek[P]Bridge-Game/json.hh |
nlohmann::detail::parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::parse(bool, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std... | void parse(const bool strict, BasicJsonType& result)
{
// read first token
get_token();
parse_internal(true, result);
result.assert_invariant();
// in strict mode, input must be completely read
if (strict)
{
get_token();
expect(token_... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0xead6
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xeae8
movq %rbx, %rdi
callq 0x7282
testl %ebp, %ebp
je 0xe9ce
movq %r14, %rdi
callq 0xead6
pushq $0xf
popq %rsi
movq %r14, %rdi
callq 0xf17e
cmpb $0x... | /zek[P]Bridge-Game/json.hh |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::scan() | token_type scan()
{
// read next character and ignore whitespace
do
{
get();
}
while (current == ' ' or current == '\t' or current == '\n' or current == '\r');
switch (current)
{
// structural characters
case '[':
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3f3a(%rip), %r14 # 0x130f0
movq %rbx, %rdi
callq 0xf296
movl 0x10(%rbx), %eax
leal -0x9(%rax), %ecx
cmpl $0x2, %ecx
jb 0xf1b6
leal -0x20(%rax), %ecx
cmpl $0x1a, %ecx
ja 0xf1da
movslq (%r14,%rcx,4), %rax
addq %r14, %rax
jmpq *%rax
cmpl $0xd, %eax
je 0xf1b6
lea... | /zek[P]Bridge-Game/json.hh |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::scan_string() | token_type scan_string()
{
// reset yytext (ignore opening quote)
reset();
// we entered the function by reading an open quote
assert(current == '\"');
while (true)
{
// get next character
switch (get())
{
// end o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0xfab6
cmpl $0x22, 0x10(%r14)
jne 0xf602
leaq 0x38(%r14), %r15
leaq 0x3e32(%rip), %rbp # 0x131a0
movabsq $0xbf00000080, %r13 # imm = 0xBF00000080
movq %rsp, %r12
movq %r14, %rdi
callq 0xf296
incl %eax
cmpl ... | /zek[P]Bridge-Game/json.hh |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::unget() | void unget()
{
--chars_read;
if (JSON_LIKELY(current != std::char_traits<char>::eof()))
{
ia->unget_character();
assert(token_string.size() != 0);
token_string.pop_back();
}
} | pushq %rbx
decq 0x18(%rdi)
cmpl $-0x1, 0x10(%rdi)
je 0xfc84
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rax
cmpq 0x20(%rbx), %rax
je 0xfc86
decq %rax
movq %rax, 0x28(%rbx)
popq %rbx
retq
leaq 0x45b6(%rip), %rdi # 0x14243
leaq 0x2529(%rip), %rsi # 0x121bd
leaq 0x45c1(... | /zek[P]Bridge-Game/json.hh |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::get_token_string() const | std::string get_token_string() const
{
// escape control characters
std::string result;
for (const auto c : token_string)
{
if ('\x00' <= c and c <= '\x1F')
{
// escape control characters
std::stringstream ss;
ss... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x20(%rsi), %rbp
movq 0x28(%rsi), %r14
leaq 0x20(%rsp), %r12
movq %rsp, %r15
cmpq %r14, %rbp
je 0xfe78
movs... | /zek[P]Bridge-Game/json.hh |
nlohmann::detail::input_adapter::input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, 0>(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iter... | input_adapter(IteratorType first, IteratorType last)
{
// assertion to check that the iterator range is indeed contiguous,
// see http://stackoverflow.com/a/35008842/266378 for more discussion
assert(std::accumulate(
first, last, std::pair<bool, int>(true, 0),
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rcx
movq %rsi, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
pushq $0x1
popq %rdx
movq %rsi, %rdi
movq %r14, %rsi
callq 0x104f5
testb $0x1, %al
je 0x104bb
movq 0x20(%rsp), %rax
subq %rax, %r14
movq %r14, 0x10(%rsp)
leaq 0x18(%rsp)... | /zek[P]Bridge-Game/json.hh |
State nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::get<State, State, 0>() const | ValueType get() const noexcept(noexcept(
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
{
// we cannot static_assert on ValueTypeCV being non-const, because
// there is support for get<const basic_json_t>... | pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x108d8
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
| /zek[P]Bridge-Game/json.hh |
getLastLine[abi:cxx11](std::basic_ifstream<char, std::char_traits<char>>&) | std::string getLastLine(std::ifstream& in)
{
std::ifstream::pos_type pos = in.tellg();
std::ifstream::pos_type lastPos;
while (in >> std::ws && ignoreline(in, lastPos))
pos = lastPos;
in.clear();
in.seekg(pos);
std::string line;
std::getline(in, line);
return line;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4560
movq %rax, %r15
movq %rdx, %r12
xorps %xmm0, %xmm0
movq %rsp, %r13
movaps %xmm0, (%r13)
movq %r14, %rdi
callq 0x42c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
j... | /zek[P]Bridge-Game/misc.cpp |
getUnbufKey() | char getUnbufKey()
{
termios oTermOld, oTermNew;
tcgetattr(STDIN_FILENO, &oTermOld);
oTermNew = oTermOld;
oTermNew.c_lflag &= ~(ICANON | ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &oTermNew);
char cKey = getchar();
tcsetattr(STDIN_FILENO, TCSANOW, &oTermOld);
return cKey;
} | pushq %rbp
pushq %rbx
subq $0x78, %rsp
leaq 0x3c(%rsp), %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x4380
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x2c(%rbx), %xmm3
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm1, 0x10(%rdx)
movaps %xmm2, 0x20(%rdx)
movups %xmm3, 0x2c(%rdx)
andb $... | /zek[P]Bridge-Game/advconsole/advconsole.unix.cpp |
AdvancedConsole::Cursor::getSize(int&, int&) | void AdvancedConsole::Cursor::getSize(int& rows, int& cols)
{
int iOldRow, iOldCol;
getPosition(iOldRow, iOldCol);
int iTempLastRow = iOldRow, iTempLastCol = iOldCol;
while (true)
{
cout << Cursor(100, 100, AC_RELATIVE);
int iTempRow, iTempCol;
getPosition(iTempRow, iTempCol);
if (iTempRow != iTempLas... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x34(%rsp), %rbx
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10cc0
movl (%rbx), %eax
movl (%r14), %ecx
leaq 0x24(%rsp), %r12
pushq $0x64
popq %r13
movq 0xc242(%rip), %rbx... | /zek[P]Bridge-Game/advconsole/advconsole.unix.cpp |
doctest::(anonymous namespace)::Endianness::which() | static Arch which() {
int x = 1;
// casting any data pointer to char* is allowed
auto ptr = reinterpret_cast<char*>(&x);
if(*ptr)
return Little;
return Big;
} | movl $0x1, -0x8(%rsp)
leaq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x7436
movl $0x1, -0x4(%rsp)
jmp 0x743e
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
| /igormironchik[P]read-excel/test/sst/../../test/doctest/doctest.h |
doctest::detail::$_0::~$_0() | DOCTEST_THREAD_LOCAL class
{
std::vector<std::streampos> stack;
std::stringstream ss;
public:
std::ostream* push() {
stack.push_back(ss.tellp());
return &ss;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
callq 0x6390
movq 0x8(%rsp), %rdi
callq 0x23650
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| /igormironchik[P]read-excel/test/sst/../../test/doctest/doctest.h |
doctest::String::operator+=(doctest::String const&) | String& String::operator+=(const String& other) {
const unsigned my_old_size = size();
const unsigned other_size = other.size();
const unsigned total_size = my_old_size + other_size;
if(isOnStack()) {
if(total_size < len) {
// append to the current stack space
memcpy(bu... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x7cc0
movl %eax, 0x54(%rsp)
movq 0x58(%rsp), %rdi
callq 0x7cc0
movq 0x30(%rsp), %rdi
movl %eax, 0x50(%rsp)
movl 0x54(%rsp), %eax
addl 0x50(%rsp), %eax
movl %eax, 0x4c(%rsp)
callq 0x20ba0
testb $0x1, %al
jne 0... | /igormironchik[P]read-excel/test/sst/../../test/doctest/doctest.h |
doctest::failureString(doctest::assertType::Enum) | const char* failureString(assertType::Enum at) {
if(at & assertType::is_warn) //!OCLINT bitwise operator in conditional
return "WARNING";
if(at & assertType::is_check) //!OCLINT bitwise operator in conditional
return "ERROR";
if(at & assertType::is_require) //!OCLINT bitwise operator in cond... | movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x89be
leaq 0x2fb1b(%rip), %rax # 0x384d2
movq %rax, -0x8(%rsp)
jmp 0x89fe
movl -0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x89d8
leaq 0x2fb0f(%rip), %rax # 0x384e0
movq %rax, -0x8(%rsp)
jmp 0x89fe
movl -0xc(%rsp), %eax
andl... | /igormironchik[P]read-excel/test/sst/../../test/doctest/doctest.h |
doctest::skipPathFromFilename(char const*) | const char* skipPathFromFilename(const char* file) {
#ifndef DOCTEST_CONFIG_DISABLE
if(getContextOptions()->no_path_in_filenames) {
auto back = std::strrchr(file, '\\');
auto forward = std::strrchr(file, '/');
if(back || forward) {
if(back > forward)
forward = ... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
callq 0x8aa0
testb $0x1, 0x7c(%rax)
je 0x8a84
movq 0x18(%rsp), %rdi
movl $0x5c, %esi
callq 0x6560
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2f, %esi
callq 0x6560
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x8a5c
cmpq $0x0, 0x8(%rsp)
je 0x8a82
movq 0x10(%rsp), %rax
cm... | /igormironchik[P]read-excel/test/sst/../../test/doctest/doctest.h |
doctest::toString(signed char) | DOCTEST_TO_STRING_OVERLOAD(char, "%d")
DOCTEST_TO_STRING_OVERLOAD(char signed, "%d")
DOCTEST_TO_STRING_OVERLOAD(char unsigned, "%u")
DOCTEST_TO_STRING_OVERLOAD(int short, "%d")
DOCTEST_TO_STRING_OVERLOAD(int short unsigned, "%u")
DOCTEST_TO_STRING_OVERLOAD(int, "%d")
DOCTEST_TO_STRING_OVERLOAD(unsigned, "%u")
DOCTEST_T... | subq $0x68, %rsp
movq %rdi, (%rsp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movb %al, 0x5f(%rsp)
leaq 0x10(%rsp), %rdi
movsbl 0x5f(%rsp), %edx
leaq 0x2f164(%rip), %rsi # 0x384f1
movb $0x0, %al
callq 0x60b0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7900
movq 0x8(%rsp), %rax
add... | /igormironchik[P]read-excel/test/sst/../../test/doctest/doctest.h |
doctest::detail::checkIfShouldThrow(doctest::assertType::Enum) | bool checkIfShouldThrow(assertType::Enum at) {
if(at & assertType::is_require) //!OCLINT bitwise operator in conditional
return true;
if((at & assertType::is_check) //!OCLINT bitwise operator in conditional
&& getContextOptions()->abort_after > 0 &&
(g_cs->numAssertsFa... | subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl 0x10(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x9ceb
movb $0x1, 0x17(%rsp)
jmp 0x9d4f
movl 0x10(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x9d4a
callq 0x8aa0
cmpl $0x0, 0x64(%rax)
jle 0x9d4a
movq 0x438f7(%rip), %rax # 0x4d600
movl 0x9c(%rax), %eax
movl %eax, 0x... | /igormironchik[P]read-excel/test/sst/../../test/doctest/doctest.h |
doctest::detail::Subcase::Subcase(doctest::String const&, char const*, int) | Subcase::Subcase(const String& name, const char* file, int line)
: m_signature({name, file, line}) {
auto* s = g_cs;
// check subcase filters
if(s->subcasesStack.size() < size_t(s->subcase_filter_levels)) {
if(!matchesAny(m_signature.m_name.c_str(), s->filters[6], true, ... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x78(%rsp), %rsi
callq 0x79e0
movq 0x28(%rsp), %rax
movq 0x70(%rsp), %rcx
movq %rcx, 0x18(%rax)
movl 0x6c(%rsp), %ecx
movl %ecx, 0x20(%rax)
movb $0x0, 0x28(%rax)
movq... | /igormironchik[P]read-excel/test/sst/../../test/doctest/doctest.h |
doctest::(anonymous namespace)::matchesAny(char const*, std::vector<doctest::String, std::allocator<doctest::String>> const&, bool, bool) | bool matchesAny(const char* name, const std::vector<String>& filters, bool matchEmpty,
bool caseSensitive) {
if(filters.empty() && matchEmpty)
return true;
for(auto& curr : filters)
if(wildcmp(name, curr.c_str(), caseSensitive))
return true;
... | subq $0x48, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
andb $0x1, %cl
movb %cl, 0x2f(%rsp)
andb $0x1, %al
movb %al, 0x2e(%rsp)
movq 0x30(%rsp), %rdi
callq 0x21850
testb $0x1, %al
jne 0xa05f
jmp 0xa070
testb $0x1, 0x2f(%rsp)
je 0xa070
movb $0x1, 0x47(%rsp)
jmp 0xa103
movq 0x30(%rsp), %r... | /igormironchik[P]read-excel/test/sst/../../test/doctest/doctest.h |
doctest::detail::Subcase::~Subcase() | Subcase::~Subcase() {
if(m_entered) {
// only mark the subcase stack as passed if no subcases have been skipped
if(g_cs->should_reenter == false)
g_cs->subcasesPassed.insert(g_cs->subcasesStack);
g_cs->subcasesStack.pop_back();
#if defined(__cpp_lib_uncaught_... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x28(%rax)
je 0xa2f8
movq 0x434c3(%rip), %rax # 0x4d600
movb 0x115c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xa18d
movq 0x434ac(%rip), %rsi # 0x4d600
movq %rsi, %rdi
addq $0x1128, %rdi ... | /igormironchik[P]read-excel/test/sst/../../test/doctest/doctest.h |
doctest::detail::TestCase::operator=(doctest::detail::TestCase const&) | TestCase& TestCase::operator=(const TestCase& other) {
static_cast<TestCaseData&>(*this) = static_cast<const TestCaseData&>(other);
m_test = other.m_test;
m_type = other.m_type;
m_template_id = other.m_template_id;
m_full_name = other.m_full_name;
if(m_t... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x20ff0
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x50(%rdi)
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x58(%rdi)
movq 0x8(%rsp), %rax
movl 0x60(%rax),... | /igormironchik[P]read-excel/test/sst/../../test/doctest/doctest.h |
doctest::detail::isDebuggerActive() | bool isDebuggerActive() {
ErrnoGuard guard;
std::ifstream in("/proc/self/status");
for(std::string line; std::getline(in, line);) {
static const int PREFIX_LEN = 11;
if(line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0) {
return line.length() > PREFIX_LEN &... | subq $0x268, %rsp # imm = 0x268
leaq 0x260(%rsp), %rdi
callq 0x210c0
leaq 0x2dce1(%rip), %rsi # 0x385ac
leaq 0x58(%rsp), %rdi
movl $0x8, %edx
callq 0x69a0
jmp 0xa8dc
leaq 0x28(%rsp), %rdi
callq 0x66f0
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x60c0
movq %rax, 0x18(%rsp)
jmp 0xa8fc
movq 0x18(%rsp... | /igormironchik[P]read-excel/test/sst/../../test/doctest/doctest.h |
doctest::(anonymous namespace)::wildcmp(char const*, char const*, bool) | int wildcmp(const char* str, const char* wild, bool caseSensitive) {
const char* cp = str;
const char* mp = wild;
while((*str) && (*wild != '*')) {
if((caseSensitive ? (*wild != *str) : (tolower(*wild) != tolower(*str))) &&
(*wild != '?')) {
return 0;
... | subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, 0x17(%rsp)
je 0x117fc
movq 0x30(%rsp), %rax
movsbl (%ra... | /igormironchik[P]read-excel/test/sst/../../test/doctest/doctest.h |
Liby::TimerMixin::runAt(Liby::Timestamp const&, std::function<void ()> const&) | TimerId TimerMixin::runAt(const Timestamp ×tamp,
const BasicHandler &handler) {
static TimerMixinHelper helper(&loop_);
return runHelper(loop_->runAt(timestamp, handler));
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpb $0x0, 0x7c24d(%rip) # 0x95660
jne 0x19448
leaq 0x7c244(%rip), %rdi # 0x95660
callq 0x67f0
cmpl $0x0, %eax
je 0x19448
movq -0x40(%rbp), %rsi
addq $0x8,... | /ccsexyz[P]liby-cpp/src/TimerMixin.cpp |
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.