name string | code string | asm string | file string |
|---|---|---|---|
VanEmdeBoasTree::remove(VanEmdeBoasTree::Node*&, int) | bool VanEmdeBoasTree::remove(Node *&root, int value) {
if (!root) {
return false;
}
if (value < 0 || value >= root->uni) {
return false;
}
if (root->min > value || root->max < value) {
return false;
}
if (root->min == value) {
int i;
if (!findMin(roo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r15
testq %r15, %r15
sete %al
testl %edx, %edx
sets %cl
orb %al, %cl
jne 0x7b84
movl %edx, %ebp
movl (%r15), %eax
cmpl %edx, %eax
jle 0x7b84
movl 0x10(%r15), %edx
cmpl %ebp, %edx
jg 0x7b84
movl 0x14(%r15), %ecx
cmpl %ebp, %ecx
jg... | /spyridon97[P]DataStructuresComparison/Source/VanEmdeBoasTree.cpp |
VanEmdeBoasTree::find(VanEmdeBoasTree::Node*, int) | bool VanEmdeBoasTree::find(Node *root, int value) {
if (!root) {
return false;
}
if (value < 0 || value >= root->uni) {
return false;
}
if (root->min > value || root->max < value) {
return false;
}
if (root->min == value) {
return true;
}
if (!root->s... | testq %rsi, %rsi
sete %al
testl %edx, %edx
sets %cl
orb %al, %cl
je 0x7dc0
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movl (%r14), %eax
cmpl %ebx, %eax
jle 0x7e89
movl 0x10(%r14), %edx
cmpl %ebx, %edx
jg 0x7e89
movl 0x14(%r14), %ecx
cmpl %ebx, %ecx
jl 0x7e89
c... | /spyridon97[P]DataStructuresComparison/Source/VanEmdeBoasTree.cpp |
VanEmdeBoasTree::predecessor(VanEmdeBoasTree::Node*, int, int&) | bool VanEmdeBoasTree::predecessor(Node *root, int value, int &result) {
if (!root) {
return false;
}
if (value < 0 || value > root->uni) {
return false;
}
if (root->max < value) {
result = root->max;
return true;
}
if (!root->summary) {
if (root->mi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
testq %rsi, %rsi
sete %al
testl %edx, %edx
sets %cl
orb %al, %cl
jne 0x83c9
movl %edx, %ebp
movq %rsi, %r14
movl (%rsi), %eax
cmpl %edx, %eax
jge 0x83da
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq ... | /spyridon97[P]DataStructuresComparison/Source/VanEmdeBoasTree.cpp |
getAscendingNumbers(int) | vector<int> getAscendingNumbers(int inputSize) {
vector<int> ascendingNumbers;
for (int i = 0; i < inputSize; i++) {
ascendingNumbers.push_back(i);
}
return ascendingNumbers;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, 0xc(%rsp)
testl %esi, %esi
jle 0x87b0
movl %esi, %ebp
xorl %eax, %eax
leaq 0xc(%rsp), %r14
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8797
movl %eax, (%rsi)
addq $0x4, %rsi
mov... | /spyridon97[P]DataStructuresComparison/main.cpp |
main | int main(int argc, const char *argv[])
{
FILE *fp;
struct wal_q2_header header_q2;
struct wal_dk_header header_dk;
char *path = cli_concat_args(argc, argv);
char buffer[WAL_DK_HEADER_SIZE]; /* Daikatana's header is bigger */
const unsigned char *buf_ptr = (const unsigned char *)&buffer;
if (argc < 2) {
printf... | pushq %rbp
movq %rsp, %rbp
subq $0xb30, %rsp # imm = 0xB30
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x26d0
movq %rax, -0x408(%rbp)
leaq -0x790(%rbp), %rax
movq %rax, -0x798(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x22da
leaq 0x3d3d(%rip), %... | /RaZeR-RBI[P]wal-tools/src/wal-info.c |
print_info_dk | static void print_info_dk(struct wal_dk_header header)
{
int i;
printf("Name: %.*s\n", NAME_LEN, header.name);
printf("Width: %d\n", header.width);
printf("Height: %d\n", header.height);
for (i = 0; i < MIP_LEVELS_DK; i++) {
printf("MIP %d offset: %#010x\n", i, header.offsets[i]);
}
printf("Next frame name: %.... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rdx
movq %rdx, -0x10(%rbp)
addq $0x4, %rdx
leaq 0x3b32(%rip), %rdi # 0x60cd
movl $0x20, %esi
movb $0x0, %al
callq 0x2090
movq -0x10(%rbp), %rax
movl 0x24(%rax), %esi
leaq 0x3b24(%rip), %rdi # 0x60d9
movb $0x0, %al
callq 0x2090
movq -0x10(%rbp), %ra... | /RaZeR-RBI[P]wal-tools/src/wal-info.c |
cli_concat_args | char *cli_concat_args(int argc, const char *argv[])
{
int i;
size_t length = 1;
for (i = 1; i < argc; i++) {
length += strlen(argv[i]) + 1;
}
char *result = (char *)xmalloc(length);
length = 0;
for (i = 1; i < argc; i++) {
length += sprintf(result + length, "%s ", argv[i]);
}
result[--length] = '\0';
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x1, -0x20(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x271e
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2080
addq $0x1, %rax
addq -0x20(%rbp), %rax
movq... | /RaZeR-RBI[P]wal-tools/common/cli.c |
cli_parse_args | struct ll_node *cli_parse_args(int argc, const char *argv[], const char *prefix)
{
int pos = 1;
int end = pos;
struct ll_node *root_node = NULL;
struct ll_node *prev_node = NULL;
struct ll_node *cur_node = NULL;
if (argc <= 0 || argv == NULL) {
return NULL;
}
while (pos < argc) {
prev_node = cur_node;
cu... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x27e5
cmpq $0x0, -0x18(%rbp)
jne 0x27ef
mov... | /RaZeR-RBI[P]wal-tools/common/cli.c |
parse_arg_range | static struct ll_node *parse_arg_range(int from, int count, int *end,
const char *argv[], const char *prefix)
{
int i = from;
struct cli_option option;
if (from >= count || from < 0 || argv == NULL || prefix == NULL) {
return NULL;
}
option.name = starts_with(prefix, argv[i]) ? (char *)argv[i] : NULL... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x28ac
cmpl $0x0, -0xc(%rbp)
jl 0x28ac
cmpq $0x0, -0x20(%rbp)
je 0x28... | /RaZeR-RBI[P]wal-tools/common/cli.c |
cli_get_option | const struct cli_option *cli_get_option(char *name, struct ll_node *parsed)
{
if (parsed == NULL) {
return NULL;
}
g_cli_get_option_name = name;
struct ll_node *result = ll_find(parsed, &cli_get_option_predicate);
if (result == NULL) {
return NULL;
}
return result->value_ptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2ac1
movq $0x0, -0x8(%rbp)
jmp 0x2afc
movq -0x10(%rbp), %rax
movq %rax, 0x560c(%rip) # 0x80d8
movq -0x18(%rbp), %rdi
leaq 0x39(%rip), %rsi # 0x2b10
callq 0x35e0
movq %rax, -0x20(%rbp)
cmpq ... | /RaZeR-RBI[P]wal-tools/common/cli.c |
cli_get_option_predicate | static int cli_get_option_predicate(void *data)
{
struct cli_option option = *(struct cli_option *)data;
if (option.name != NULL && g_cli_get_option_name != NULL) {
return strcmp(option.name, g_cli_get_option_name) == 0;
}
if (option.name != NULL || g_cli_get_option_name != NULL) {
return 0;
}
return 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2b60
cmpq $0x0, 0x559a(%rip) # 0x80d8
je 0x2b60
movq -0x20(%rbp), %rdi
movq 0x558d(%rip), %rsi # 0x80d8
cal... | /RaZeR-RBI[P]wal-tools/common/cli.c |
read_le16 | uint16_t read_le16(unsigned char **buffer)
{
uint8_t b1, b2;
b1 = *(uint8_t *)(*buffer);
b2 = *(uint8_t *)(*buffer + 1);
uint16_t result = (b1 << 0) | (b2 << 8);
(*buffer) += 2;
return result;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb 0x1(%rax), %al
movb %al, -0xa(%rbp)
movzbl -0x9(%rbp), %eax
shll $0x0, %eax
movzbl -0xa(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, -0xc(%r... | /RaZeR-RBI[P]wal-tools/common/endian-util.c |
read_le32 | uint32_t read_le32(unsigned char **buffer)
{
uint8_t b1, b2, b3, b4;
b1 = *(uint8_t *)(*buffer);
b2 = *(uint8_t *)(*buffer + 1);
b3 = *(uint8_t *)(*buffer + 2);
b4 = *(uint8_t *)(*buffer + 3);
uint32_t result = (b1 << 0) | (b2 << 8) | (b3 << 16) | (b4 << 24);
(*buffer) += 4;
return result;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb 0x1(%rax), %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb 0x2(%rax), %al
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq (%ra... | /RaZeR-RBI[P]wal-tools/common/endian-util.c |
flip_bgr | void flip_bgr(sptr_t colors)
{
int i;
int size = colors.size - (colors.size % 3);
unsigned char *p = colors.ptr;
for (i = 0; i < size; i += 3) {
unsigned char tmp = *p;
*p = *(p + 2);
*(p + 2) = tmp;
p += 3;
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq -0x30(%rbp), %rax
subq %rdx, %rax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x... | /RaZeR-RBI[P]wal-tools/common/image.c |
file_read | sptr_t file_read(const char *path, const char *mode)
{
sptr_t result = SPTR_NULL;
if (path == NULL || mode == NULL) {
return result;
}
FILE *f = fopen(path, mode);
if (!f) {
perror("Unable to open file for reading\n");
fprintf(stderr, "File: \"%s\", mode \"%s\"\n", path, mode);
return result;
}
fseek(f, ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x20b0
cmpq $0x0, -0x18(%rbp)
je 0x2f0e
cmpq $0x0, -0x20(%rbp)
jne 0x2f13
jmp 0x30b0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2140
movq %rax, -0x28(%rbp)
c... | /RaZeR-RBI[P]wal-tools/common/io.c |
trim_extension | const char *trim_extension(const char *s)
{
char buffer[PATH_MAX];
sprintf(&buffer[0], "%s%c", s, '\0');
char *delim_pos = strrchr(buffer, '.');
if (delim_pos == &buffer[0] || *(delim_pos - 1) == PATH_SEPARATOR) {
return xstrdup(&buffer[0]);
}
*delim_pos = '\0';
return xstrdup(&buffer[0]);
} | pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp # imm = 0x1020
movq %rdi, -0x10(%rbp)
leaq -0x1010(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3069(%rip), %rsi # 0x625a
xorl %ecx, %ecx
movb $0x0, %al
callq 0x2160
leaq -0x1010(%rbp), %rdi
movl $0x2e, %esi
callq 0x20a0
movq %rax, -0x1018(%rbp)
movq -0x1018(%rb... | /RaZeR-RBI[P]wal-tools/common/io.c |
ll_create_node | struct ll_node *ll_create_node(const void *ptr, size_t isize)
{
if (ptr == NULL || isize <= 0) {
return NULL;
}
struct ll_node *node = xmalloc(sizeof(struct ll_node));
node->next = NULL;
node->value_ptr = xmalloc(isize);
node->value_size = isize;
memcpy(node->value_ptr, ptr, isize);
return node;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x328e
cmpq $0x0, -0x18(%rbp)
ja 0x3298
movq $0x0, -0x8(%rbp)
jmp 0x32ed
movl $0x18, %edi
callq 0x36a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x36... | /RaZeR-RBI[P]wal-tools/common/list.c |
ll_size | size_t ll_size(const struct ll_node *node)
{
size_t length = 0;
struct ll_node *cur_node = (struct ll_node *)node;
while (cur_node != NULL) {
cur_node = cur_node->next;
length++;
}
return length;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3449
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3428
movq -0x10(%rbp), %rax
popq %... | /RaZeR-RBI[P]wal-tools/common/list.c |
ll_append | struct ll_node *ll_append(struct ll_node *root, const void *ptr, size_t isize)
{
struct ll_node *new_node = ll_create_node(ptr, isize);
struct ll_node *result = ll_append_node(root, new_node);
if (new_node != NULL && result != NULL) {
return result;
}
ll_free_node(new_node);
return NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3270
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3590
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x356e
cmpq $0x0,... | /RaZeR-RBI[P]wal-tools/common/list.c |
ll_find | struct ll_node *ll_find(struct ll_node *root, ll_predicate fn)
{
struct ll_node *cur_node = root;
if (fn == NULL) {
return NULL;
}
while (cur_node != NULL) {
if (fn(cur_node->value_ptr)) {
return cur_node;
}
cur_node = cur_node->next;
}
return NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3609
movq $0x0, -0x8(%rbp)
jmp 0x3644
jmp 0x360b
cmpq $0x0, -0x20(%rbp)
je 0x363c
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
callq *%r... | /RaZeR-RBI[P]wal-tools/common/list.c |
xmalloc | void *xmalloc(size_t size)
{
if (size == 0) {
size = 1;
}
void *result = malloc(size);
if (result == NULL) {
fprintf(stderr, "Out of memory - unable to allocate %lu bytes", size);
abort();
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x36bb
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2120
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x36f0
movq 0x4922(%rip), %rax # 0x7ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x2b7b(%rip), %rsi ... | /RaZeR-RBI[P]wal-tools/common/mem.c |
Arbiter_Time_Test::TestBody() | TEST(Arbiter, Time)
{
Time a;
Time b(a.str());
EXPECT_EQ(a.str(), b.str());
EXPECT_EQ(a - b, 0);
Time x("2016-03-18T03:14:42Z");
Time y("2016-03-18T04:24:54Z");
const int64_t delta(1 * 60 * 60 + 10 * 60 + 12);
EXPECT_EQ(y - x, delta);
EXPECT_EQ(x - y, -delta);
Time epoch("197... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
leaq 0x80(%rsp), %rdi
callq 0x287f0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x304d9(%rip), %rsi # 0x5a70c
leaq 0x304e4(%rip), %rdx # 0x5a71e
leaq 0x8(%rsp), %rdi
callq 0x3a788
leaq 0x28(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x8(%... | /connormanning[P]arbiter/test/unit.cpp |
arbiter::Arbiter::~Arbiter() | class ARBITER_DLL Arbiter
{
public:
/** Construct a basic Arbiter with only drivers the don't require
* external configuration parameters.
*/
Arbiter();
/** @brief Construct an Arbiter with driver configurations. */
Arbiter(std::string stringifiedJson);
/** @brief Add a custom driver for... | pushq %rbx
movq %rdi, %rbx
addq $0x78, %rdi
callq 0x2ecd2
leaq 0x48(%rbx), %rdi
callq 0x2ed00
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x2e374
popq %rbx
jmp 0x28530
popq %rbx
retq
| /connormanning[P]arbiter/arbiter/arbiter.hpp |
DriverTest_PutGet_Test::~DriverTest_PutGet_Test() | TEST_P(DriverTest, PutGet)
{
Arbiter a;
const std::string root(GetParam());
const std::string path(root + "test.txt");
const std::string data("Testing path " + path);
if (a.isLocal(root)) mkdirp(root);
EXPECT_NO_THROW(a.put(path, data));
EXPECT_EQ(a.get(path), data);
} | pushq %rbx
movq %rdi, %rbx
callq 0x41e5c
movq %rbx, %rdi
popq %rbx
jmp 0x28530
| /connormanning[P]arbiter/test/unit.cpp |
non-virtual thunk to DriverTest_PutGet_Test::~DriverTest_PutGet_Test() | TEST_P(DriverTest, PutGet)
{
Arbiter a;
const std::string root(GetParam());
const std::string path(root + "test.txt");
const std::string data("Testing path " + path);
if (a.isLocal(root)) mkdirp(root);
EXPECT_NO_THROW(a.put(path, data));
EXPECT_EQ(a.get(path), data);
} | pushq %rbx
movq %rdi, %rbx
addq $-0x10, %rbx
movq %rbx, %rdi
callq 0x41e5c
movq %rbx, %rdi
popq %rbx
jmp 0x28530
nop
| /connormanning[P]arbiter/test/unit.cpp |
non-virtual thunk to DriverTest_HttpRange_Test::~DriverTest_HttpRange_Test() | TEST_P(DriverTest, HttpRange)
{
Arbiter a;
const std::string root(GetParam());
const std::string path(root + "range.txt");
const std::string data("0123456789");
const std::size_t x(2);
const std::size_t y(8);
const http::Headers headers{
// The range header is inclusive of the end,... | addq $-0x10, %rdi
jmp 0x41e5c
nop
| /connormanning[P]arbiter/test/unit.cpp |
DriverTest_Glob_Test::~DriverTest_Glob_Test() | TEST_P(DriverTest, Glob)
{
using Paths = std::set<std::string>;
Arbiter a;
const std::string rawRoot(GetParam());
// Local directories explicitly prefixed with file:// will be returned
// without that prefix, so strip that off.
const std::string root(
a.isLocal(rawRoot) ? stripProt... | pushq %rbx
movq %rdi, %rbx
callq 0x41e5c
movq %rbx, %rdi
popq %rbx
jmp 0x28530
| /connormanning[P]arbiter/test/unit.cpp |
testing::internal::ParameterizedTestCaseInfo<DriverTest>::AddTestPattern(char const*, char const*, testing::internal::TestMetaFactoryBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*) | void AddTestPattern(const char* test_case_name,
const char* test_base_name,
TestMetaFactoryBase<ParamType>* meta_factory) {
tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name,
test_base_name,
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl $0x48, %edi
callq 0x28170
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2ef18
addq $0x28, %rbx
leaq 0x8(%rsp), %rax
movq %r14, -0x8(%rax)... | /connormanning[P]arbiter/third/gtest-1.7.0/include/gtest/internal/gtest-param-util.h |
testing::internal::TestMetaFactory<DriverTest_Glob_Test>::CreateTestFactory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | virtual TestFactoryBase* CreateTestFactory(ParamType parameter) {
return new ParameterizedTestFactory<TestCase>(parameter);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movl $0x28, %edi
callq 0x28170
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x3a6f2
leaq 0x43583(%rip), %rax # 0x73050
addq $0x10, %rax
movq %rax, (%rbx)
lea... | /connormanning[P]arbiter/third/gtest-1.7.0/include/gtest/internal/gtest-param-util.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [7]>(char const (&) [7]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3f04e
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x283f0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x28960
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3041c
cmpq $0x0... | /connormanning[P]arbiter/third/gtest-1.7.0/include/gtest/gtest.h |
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>::json_value::json_value(nlohmann::detail::value_t) | json_value(value_t t)
{
switch (t)
{
case value_t::object:
{
object = create<object_t>();
break;
}
case value_t::array:
{
array = create<array_t>()... | pushq %rbx
movq %rdi, %rbx
cmpl $0x7, %esi
ja 0x30d43
movl %esi, %eax
leaq 0x29326(%rip), %rcx # 0x5a060
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, (%rbx)
jmp 0x30da2
movl $0x30, %edi
callq 0x28170
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %edx, %edx
movq %rdx, 0x10(%ra... | /connormanning[P]arbiter/arbiter/third/json/json.hpp |
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>>::skip_bom() | bool skip_bom()
{
if (get() == 0xEF)
{
// check if we completely parse the BOM
return get() == 0xBB and get() == 0xBF;
}
// the first character is not the beginning of the BOM; unget it to
// process is later
unget();
return true;
... | pushq %rbx
movq %rdi, %rbx
callq 0x28bf0
cmpl $0xef, %eax
je 0x31abc
movq %rbx, %rdi
callq 0x32314
movb $0x1, %al
popq %rbx
retq
movq %rbx, %rdi
callq 0x28bf0
cmpl $0xbb, %eax
je 0x31acf
xorl %eax, %eax
jmp 0x31aba
movq %rbx, %rdi
callq 0x28bf0
cmpl $0xbf, %eax
sete %al
jmp 0x31aba
nop
| /connormanning[P]arbiter/arbiter/third/json/json.hpp |
nlohmann::detail::json_sax_dom_callback_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>>::~json_sax_dom_callback_parser() | ~json_sax_dom_callback_parser() = default; | pushq %rbx
movq %rdi, %rbx
addq $0xa8, %rdi
callq 0x30c86
leaq 0xb0(%rbx), %rdi
movzbl 0xa8(%rbx), %esi
callq 0x3a648
movq 0x90(%rbx), %rax
testq %rax, %rax
je 0x33d6e
leaq 0x80(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x48(%rbx), %rdi
callq 0x34cdc
leaq 0x20(%rbx), %rdi
callq 0x34cdc
movq 0x8(%rbx)... | /connormanning[P]arbiter/arbiter/third/json/json.hpp |
std::pair<bool, 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>*> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<std::map, std::vector, std::__cxx... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
assert(not keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (not keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x37a02
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x80000000000... | /connormanning[P]arbiter/arbiter/third/json/json.hpp |
nlohmann::detail::parse_error::position_string[abi:cxx11](nlohmann::detail::position_t const&) | static std::string position_string(const position_t& pos)
{
return " at line " + std::to_string(pos.lines_read + 1) +
", column " + std::to_string(pos.chars_read_current_line);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
incq %r15
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x38ac4
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x38abd
cmpq $0x... | /connormanning[P]arbiter/arbiter/third/json/json.hpp |
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> const>::operator*() const | reference operator*() const
{
assert(m_object != nullptr);
switch (m_object->m_type)
{
case value_t::object:
{
assert(m_it.object_iterator != m_object->m_value.object->end());
return m_it.object_iterator->second;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x3c003
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x3bfdf
cmpl $0x2, %ecx
je 0x3bfb2
testl %ecx, %ecx
je 0x3c022
cmpq $0x0, 0x18(%rdi)
je 0x3bff8
movl $0x20, %edi
callq 0x283c0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15... | /connormanning[P]arbiter/arbiter/third/json/json.hpp |
testing::internal::StringFromGTestEnv(char const*, char const*) | const char* StringFromGTestEnv(const char* flag, const char* default_value) {
const std::string env_var = FlagToEnvVar(flag);
const char* const value = posix::GetEnv(env_var.c_str());
return value == NULL ? default_value : value;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x50742
movq (%r14), %r15
movq %r15, %rdi
callq 0x28700
movq %rax, %r14
leaq 0x10(%rsp), %rax
cmpq %rax, %r15
je 0x3cec5
movq %r15, %rdi
callq 0x28530
testq %r14, %r14
cmovneq %r14, %rbx
movq %rbx, %r... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-port.cc |
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<wchar_t const*>(bool, char const*, char const*, wchar_t const* const&, wchar_t const* const&) | AssertionResult IsSubstringImpl(
bool expected_to_be_substring,
const char* needle_expr, const char* haystack_expr,
const StringType& needle, const StringType& haystack) {
if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
return AssertionSuccess();
const bool is_wide_string = sizeo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r9, %r15
movq %r8, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq (%r8), %rsi
movq (%r9), %rdi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %cl, %al
jne 0x4084b
cmpq %rdi, %rsi
sete %al
jmp... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::CmpHelperSTREQ(char const*, char const*, wchar_t const*, wchar_t const*) | AssertionResult CmpHelperSTREQ(const char* expected_expression,
const char* actual_expression,
const wchar_t* expected,
const wchar_t* actual) {
if (String::WideCStringEquals(expected, actual)) {
return AssertionSuccess()... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x411ba
orq %r8, %rcx
jne 0x411c9
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x41226
movq %rcx, %rdi
movq %r8, %rsi
ca... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::String::CaseInsensitiveWideCStringEquals(wchar_t const*, wchar_t const*) | bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
const wchar_t* rhs) {
if (lhs == NULL) return rhs == NULL;
if (rhs == NULL) return false;
#if GTEST_OS_WINDOWS
return _wcsicmp(lhs, rhs) == 0;
#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
return ... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movq %rdi, %rax
orq %rsi, %rax
sete %al
testb %cl, %cl
jne 0x41426
pushq %rax
callq 0x28250
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
nop
| /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::String::FormatByte[abi:cxx11](unsigned char) | std::string String::FormatByte(unsigned char value) {
std::stringstream ss;
ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
<< static_cast<unsigned int>(value);
return ss.str();
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x282b0
movq 0x10(%r14), %rax
movq -0x18(%rax), %rcx
leaq (%rsp,%rcx), %r14
addq $0x18, %r14
cmpb $0x0, 0xe1(%r14)
jne 0x41599
movq %r14, %rdi
movl $0x20, %esi
callq 0x2... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::TestResult::Clear() | void TestResult::Clear() {
test_part_results_.clear();
test_properties_.clear();
death_test_count_ = 0;
elapsed_time_ = 0;
} | pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x38(%rbx), %rsi
callq 0x57c98
leaq 0x50(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x5854c
movl $0x0, 0x68(%rbx)
movq $0x0, 0x70(%rbx)
popq %rbx
retq
nop
| /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::Test::HasSameFixtureClass() | Message& Message::operator <<(const ::wstring& wstr) {
internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x3d306
movq 0x32760(%rip), %rax # 0x74808
movq 0x108(%rax), %rcx
movq 0x110(%rax), %r12
movq 0x30(%rcx), %rax
movq (%rax), %rax
movq 0x50(%rax), %r13
movq 0x50(%r12), %rbp
cmpq %r13, %rbp
je 0x424dd
movq 0x20(%rax), %rbx
movq ... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::PrintTestPartResultToString[abi:cxx11](testing::TestPartResult const&) | static std::string PrintTestPartResultToString(
const TestPartResult& test_part_result) {
return (Message()
<< internal::FormatFileLocation(test_part_result.file_name(),
test_part_result.line_number())
<< " " << TestPartResultTypeToString(test_part_res... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x3f04e
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x425b7
movq 0x8(%r14), %rsi
movl 0x28(%r14), %edx
leaq 0x8(%rsp), %rdi
callq 0x42d9a
movq (%rsp), %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rs... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::UnitTestImpl::os_stack_trace_getter() | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
if (os_stack_trace_getter_ == NULL) {
os_stack_trace_getter_ = new OsStackTraceGetter;
}
return os_stack_trace_getter_;
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x1a8(%rdi), %rbx
testq %rbx, %rbx
jne 0x427cc
movq %rdi, %r14
movl $0x48, %edi
callq 0x28170
movq %rax, %rbx
leaq 0x30eeb(%rip), %rax # 0x73698
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
callq 0x52d4a
movq $0x0, 0x40(%rbx)
movq %rbx, 0x1a8(%r14)
movq %rbx, %rax
ad... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::TestCase::GetMutableTestInfo(int) | inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
return (i < 0 || i >= static_cast<int>(v.size())) ? default_value : v[i];
} | testl %esi, %esi
js 0x433b5
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %esi, %ecx
jle 0x433b5
movl %esi, %ecx
movslq (%rax,%rcx,4), %rax
testq %rax, %rax
js 0x433b5
movq 0x30(%rdi), %rcx
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
| /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-internal-inl.h |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestCase const&) | void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(COLOR_GREEN, "[----------] ");
printf("%s from %s", counts.c_str(), test_case.name());
if (test_case.type_param() == ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x4413a
movq (%rax), %rdx
movzbl 0x58(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x44126
leaq 0x1c56d(%rip), %rdx # 0x606ae
leaq 0x1bce1(%rip), %rcx # 0x5fe29
leaq 0x8(%rsp)... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void PrettyUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
// If the test part succeeded, we don't need to do anything.
if (result.type() == TestPartResult::kSuccess)
return;
// Print failure message from the assertion (e.g. expected this and got that).
PrintTestPartResult(resu... | cmpl $0x0, (%rsi)
je 0x443a7
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x42591
movq (%rbx), %rdi
callq 0x289e0
movq 0x2fc02(%rip), %r14 # 0x73f80
movq (%r14), %rdi
callq 0x284c0
movq (%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x44398
callq 0x28530
movq (%r14), %rdi... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseEnd(testing::TestCase const&) | void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
if (!GTEST_FLAG(print_time)) return;
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(COLOR_GREEN, "[----------] ");
printf("%s from %s (%s ms total)\n\n",
co... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq 0x30290(%rip), %rax # 0x74718
cmpb $0x1, (%rax)
jne 0x4454a
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x444b2
movq (%rax), %rdx
movzbl 0x58(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x4449e
leaq 0x1c1f5... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* xmlout = NULL;
FilePath output_file(output_file_);
FilePath output_dir(output_file.RemoveFileName());
if (output_dir.CreateDirectoriesRecursively()) {
xm... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1f0, %rsp # imm = 0x1F0
movq %rsi, %rbx
movq %rdi, %r15
addq $0x8, %r15
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x52046
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x450ca
leaq 0x8(%rsp), %rdi
callq 0x451a2
testb %al, %al
je 0x45064
movq (%r15), %rd... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::FilePath::RemoveFileName() const | FilePath FilePath::RemoveFileName() const {
const char* const last_sep = FindLastPathSeparator();
std::string dir;
if (last_sep) {
dir = std::string(c_str(), last_sep + 1 - c_str());
} else {
dir = kCurrentDirectoryString;
}
return FilePath(dir);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
movq %r14, %rdi
movl $0x2f, %esi
callq 0x28900
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
testq %rax, %rax
je 0x45140
incq %rax
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28(... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-filepath.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*) | void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
const char* data) {
const char* segment = data;
*stream << "<![CDATA[";
for (;;) {
const char* const next_segment = strstr(segment, "]]>");
if (next_segment != NULL) {
st... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x19aa1(%rip), %rsi # 0x5ff83
movl $0x9, %edx
callq 0x28960
leaq 0x19a83(%rip), %rsi # 0x5ff76
movq %r14, %rdi
callq 0x28470
testq %rax, %rax
je 0x4654e
movq %rax, %r13
leaq 0x19a70(%rip), %r15 # 0x5ff7a
leaq 0x19a65... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(std::ostream*, char const*, testing::TestInfo const&) | void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
const char* test_case_name,
const TestInfo& test_info) {
const TestResult& result = *test_info.result();
const std::string kTestcase = "testcase"... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, 0x30(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xb0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x19891(%rip), %rsi # 0x60024
leaq 0x19892(%rip), %rdx # 0x6002c
leaq 0xa0(%rsp), %rdi
callq 0x3a788
leaq 0x19871(%rip), %rsi... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream*, testing::TestCase const&) | void XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream* stream,
const TestCase& test_case) {
const std::string kTestsuite = "testsuite";
*stream << " <" << kTestsuite;
OutputXmlAttribute(stream, kTestsuite, "name", test_case.name());
OutputXmlAttribute(stre... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x18d0c(%rip), %rsi # 0x600a7
leaq 0x18d0e(%rip), %rdx # 0x600b0
leaq 0x50(%rsp), %rdi
callq 0x3a788
leaq 0x18cfe(%rip), %rsi # 0x600b1
movl $0x3, %edx
mo... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::StreamingListener::UrlEncode[abi:cxx11](char const*) | string StreamingListener::UrlEncode(const char* str) {
string result;
result.reserve(strlen(str) + 1);
for (char ch = *str; ch != '\0'; ch = *++str) {
switch (ch) {
case '%':
case '=':
case '&':
case '\n':
result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x283f0
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x287d0
leaq 0x18(%rsp), %r13
m... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::StreamingListener::SocketWriter::MakeConnection() | void StreamingListener::SocketWriter::MakeConnection() {
GTEST_CHECK_(sockfd_ == -1)
<< "MakeConnection() can't be called when there is already a connection.";
addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses.
hints.ai_socktype =... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
je 0x47a04
leaq 0x17c8b(%rip), %rdx # 0x5f641
leaq 0x10(%rsp), %rdi
movl $0x3, %esi
movl $0xd6f, %ecx # imm = 0xD6F
callq 0x50368
movq 0x2c5ff(%rip), %rdi # 0x73fd0
leaq 0x1873a(%rip), %rsi # 0x6011... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::UnitTest::total_test_count() const | const internal::UnitTestImpl* impl() const { return impl_; } | movq 0x40(%rdi), %rax
movq 0xb8(%rax), %rcx
movq 0xc0(%rax), %rdx
subq %rcx, %rdx
je 0x47f25
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rcx,%rsi,8), %rdi
movq 0x38(%rdi), %r8
subq 0x30(%rdi), %r8
shrq $0x3, %r8
addl %r8d, %eax
incq %rsi
cmpq %rsi, %rdx
jne 0x47f09
retq
xorl %... | /connormanning[P]arbiter/third/gtest-1.7.0/include/gtest/gtest.h |
testing::internal::UnitTestImpl::~UnitTestImpl() | UnitTestImpl::~UnitTestImpl() {
// Deletes every TestCase.
ForEach(test_cases_, internal::Delete<TestCase>);
// Deletes every Environment.
ForEach(environments_, internal::Delete<Environment>);
delete os_stack_trace_getter_;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2ac95(%rip), %rax # 0x73610
addq $0x10, %rax
movq %rax, (%rdi)
movq 0xb8(%rdi), %r14
movq 0xc0(%rdi), %r15
cmpq %r15, %r14
je 0x489a9
movq (%r14), %rdi
testq %rdi, %rdi
je 0x489a3
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x48990
movq 0xa0(%rbx), ... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::UnitTestImpl::GetTestCase(char const*, char const*, void (*)(), void (*)()) | TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
const char* type_param,
Test::SetUpTestCaseFunc set_up_tc,
Test::TearDownTestCaseFunc tear_down_tc) {
// Can we find a TestCase with the given nam... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb8(%rdi), %rbp
movq 0xc0(%rdi), %r15
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x28980
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::ParseFlagValue(char const*, char const*, bool) | const char* ParseFlagValue(const char* str,
const char* flag,
bool def_optional) {
// str and flag must not be NULL.
if (str == NULL || flag == NULL) return NULL;
// The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
const std::string flag_str = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x49921
xorl %r12d, %r12d
jmp 0x49a5d
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x16aac(%rip), %rsi # 0x603e5... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::InDeathTestChild() | bool InDeathTestChild() {
# if GTEST_OS_WINDOWS
// On Windows, death tests are thread-safe regardless of the value of the
// death_test_style flag.
return !GTEST_FLAG(internal_run_death_test).empty();
# else
if (GTEST_FLAG(death_test_style) == "threadsafe")
return !GTEST_FLAG(internal_run_death_test).emp... | pushq %rax
leaq 0x2ac44(%rip), %rdi # 0x74838
leaq 0x167ed(%rip), %rsi # 0x603e8
callq 0x288a0
leaq 0x2ac11(%rip), %rcx # 0x74818
xorl %edx, %edx
cmpq $0x0, 0x8(%rcx)
setne %dl
testl %eax, %eax
movzbl 0x2ac3f(%rip), %eax # 0x74859
cmovel %edx, %eax
andb $0x1, %al
popq %rcx
retq
nop
| /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-death-test.cc |
testing::internal::DeathTest::DeathTest() | DeathTest::DeathTest() {
TestInfo* const info = GetUnitTestImpl()->current_test_info();
if (info == NULL) {
DeathTestAbort("Cannot run a death test outside of a TEST or "
"TEST_F construct");
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x29d62(%rip), %rax # 0x73aa8
addq $0x10, %rax
movq %rax, (%rdi)
callq 0x3d306
movq 0x2aaaf(%rip), %rax # 0x74808
cmpq $0x0, 0x110(%rax)
je 0x49d6b
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x16678(%rip), %rsi # 0x... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-death-test.cc |
testing::internal::ExecDeathTest::AssumeRole() | DeathTest::TestRole ExecDeathTest::AssumeRole() {
const UnitTestImpl* const impl = GetUnitTestImpl();
const InternalRunDeathTestFlag* const flag =
impl->internal_run_death_test_flag();
const TestInfo* const info = impl->current_test_info();
const int death_test_index = info->result()->death_test_count();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, %rbx
callq 0x3d306
movq 0x2838a(%rip), %rax # 0x74808
movq 0x110(%rax), %r14
movq 0x1d0(%rax), %rax
movl 0xd0(%r14), %ecx
movl %ecx, 0x114(%rsp)
testq %rax, %rax
je 0x4c4af
movl 0x28(%rax), %eax
m... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-death-test.cc |
testing::internal::FilePath::GetCurrentDir() | FilePath FilePath::GetCurrentDir() {
#if GTEST_OS_WINDOWS_MOBILE
// Windows CE doesn't have a current directory, so we just return
// something reasonable.
return FilePath(kCurrentDirectoryString);
#elif GTEST_OS_WINDOWS
char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
return FilePath(_getcwd(cwd, sizeof(cwd)) == NU... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1028, %rsp # imm = 0x1028
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movl $0x1001, %edx # imm = 0x1001
movq %r14, %rdi
xorl %esi, %esi
callq 0x282c0
movl $0x1001, %esi # imm = 0x1001
movq %r14, %rdi
callq 0x28370
testq %rax, %rax
leaq 0xe02f(%... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-filepath.cc |
testing::internal::FilePath::MakeFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, int, char const*) | FilePath FilePath::MakeFileName(const FilePath& directory,
const FilePath& base_name,
int number,
const char* extension) {
std::string file;
if (number == 0) {
file = base_name.string() + "." + extension;
} else {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, 0x4(%rsp)
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
testl %ecx, %ecx
je 0x4fbc5
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdx)... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-filepath.cc |
testing::internal::FilePath::IsRootDirectory() const | bool FilePath::IsRootDirectory() const {
#if GTEST_OS_WINDOWS
// TODO(wan@google.com): on Windows a network share like
// \\server\share can be a root directory, although it cannot be the
// current directory. Handle this properly.
return pathname_.length() == 3 && IsAbsolutePath();
#else
return pathname_.le... | cmpq $0x1, 0x8(%rdi)
jne 0x4fff1
movq (%rdi), %rax
cmpb $0x2f, (%rax)
sete %al
retq
xorl %eax, %eax
retq
| /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-filepath.cc |
testing::internal::RE::~RE() | RE::~RE() {
if (is_valid_) {
// regfree'ing an invalid regex might crash because the content
// of the regex is undefined. Since the regex's are essentially
// the same, one cannot be valid (or invalid) without the other
// being so too.
regfree(&partial_regex_);
regfree(&full_regex_);
}
f... | pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x50112
leaq 0x50(%rbx), %rdi
callq 0x28420
leaq 0x10(%rbx), %rdi
callq 0x28420
movq (%rbx), %rdi
popq %rbx
jmp 0x281c0
movq %rax, %rdi
callq 0x2ec32
nop
| /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-port.cc |
testing::internal::GTestLog::~GTestLog() | GTestLog::~GTestLog() {
GetStream() << ::std::endl;
if (severity_ == GTEST_FATAL) {
fflush(stderr);
posix::Abort();
}
} | pushq %rbx
movq %rdi, %rbx
movq 0x23b2b(%rip), %rdi # 0x73fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x28a40
movsbl %al, %esi
movq 0x23b10(%rip), %rdi # 0x73fd0
callq 0x28540
movq %rax, %rdi
callq 0x284a0
cmpl $0x3, (%rbx)
je 0x504d4
popq %rbx
retq
movq 0x23aad(%rip), %rax # 0x73f88
... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-port.cc |
testing::internal2::PrintBytesInObjectTo(unsigned char const*, unsigned long, std::ostream*) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
ostream* os) {
PrintBytesInObjectToImpl(obj_bytes, count, os);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x284e0
leaq 0x107fa(%rip), %rsi # 0x610b7
movl $0xe, %edx
movq %rax, %rdi
callq 0x28960
cmpq $0x83, %r14
ja 0x508da
movq %r15, %rdi
xorl %esi, %esi
jmp 0x5090e
movl $0x40, %edx
movq %r15, %rdi
xorl %esi, %esi
mov... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-printers.cc |
testing::internal::HasGoogleTestFlagPrefix(char const*) | static bool HasGoogleTestFlagPrefix(const char* str) {
return (SkipPrefix("--", &str) ||
SkipPrefix("-", &str) ||
SkipPrefix("/", &str)) &&
!SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
(SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
SkipPrefix(GTEST_FLAG_PREFIX_DASH_, ... | pushq %rax
movq %rsp, %rsi
movq %rdi, (%rsi)
leaq 0xe6e8(%rip), %rdi # 0x603e5
callq 0x498b9
testb %al, %al
jne 0x51d2c
leaq 0xe6d9(%rip), %rdi # 0x603e6
movq %rsp, %rsi
callq 0x498b9
testb %al, %al
jne 0x51d2c
leaq 0xe3a8(%rip), %rdi # 0x600c8
movq %rsp, %rsi
callq 0x498b9
testb %al, %al
je 0x51d3f
leaq... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<char [2]>(char const (&) [2]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3f04e
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x283f0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x28960
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3041c
movq 0x8(... | /connormanning[P]arbiter/third/gtest-1.7.0/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<testing::TestPartResult>(testing::TestPartResult const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3f04e
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x50c4e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3041c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x52284
movq (%rdi), %rax
call... | /connormanning[P]arbiter/third/gtest-1.7.0/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [24]>(char const (&) [24]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3f04e
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x283f0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x28960
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3041c
movq 0x8(... | /connormanning[P]arbiter/third/gtest-1.7.0/include/gtest/gtest.h |
testing::AssertionResult testing::internal::FloatingPointLE<float>(char const*, char const*, float, float) | AssertionResult FloatingPointLE(const char* expr1,
const char* expr2,
RawType val1,
RawType val2) {
// Returns success if val1 is less than val2,
if (val1 < val2) {
return AssertionSuccess();
}
// or if val1 is ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x380, %rsp # imm = 0x380
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
ucomiss %xmm0, %xmm1
ja 0x526d8
leaq 0x1c(%rsp), %rdi
movss %xmm0, 0x4(%rsp)
movss %xmm0, (%rdi)
leaq 0x18(%rsp), %rsi
movss %xmm1, (%rsp)
movss %xmm1, (%rsi)
call... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
: premature_exit_filepath_(premature_exit_filepath) {
// If a path to the premature-exit file is specified...
if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') {
// create the file with a single "0" characte... | movq %rsi, (%rdi)
testq %rsi, %rsi
je 0x53bdb
cmpb $0x0, (%rsi)
je 0x53bdb
pushq %rbx
leaq 0xc381(%rip), %rax # 0x5ff38
movq %rsi, %rdi
movq %rax, %rsi
callq 0x28b70
movq %rax, %rbx
movl $0x30, %edi
movq %rax, %rsi
callq 0x28830
movq %rbx, %rdi
popq %rbx
jmp 0x28410
retq
| /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<wchar_t>(int*, wchar_t**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseBoolFlag;
using internal::ParseInt32Flag;
using internal::ParseStringFlag;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x2, (%rdi)
jl 0x549f4
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsi), %r15
movl $0x1, %r12d
movslq %r12d, %r13
leaq (%rbx,%r13,8), %rsi
leaq 0x8(%rsp), %rdi
callq 0x590f8
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
leaq 0x9ff9(%rip), %rs... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest.cc |
void testing::internal::PrintCharAndCodeTo<wchar_t, wchar_t>(wchar_t, std::ostream*) | void PrintCharAndCodeTo(Char c, ostream* os) {
// First, print c as a literal in the most readable form we can find.
*os << ((sizeof(c) > 1) ? "L'" : "'");
const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
*os << "'";
// To aid user debugging, we also print c's code in decimal, unless
//... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xbebc(%rip), %rsi # 0x612d3
movl $0x2, %edx
movq %rbx, %rdi
callq 0x28960
movl %ebp, %edi
movq %rbx, %rsi
callq 0x51e65
movl %eax, %r14d
leaq 0x7a6f(%rip), %rsi # 0x5cea7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x28960
testl... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-printers.cc |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testi... | Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
GTEST_CHECK_(typeid(*base) == typeid(Derived));
return dynamic_cast<Derived*>(base); // NOLINT
#else
return static_cast<Derived*>(base); // Poor man's downcast.
#endif
} | pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x55b5d
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
cmpq 0x1e4ed(%rip), %rdi # 0x73fd8
je 0x55b3f
cmpb $0x2a, (%rdi)
je 0x55b02
leaq 0xb9b7(%rip), %rsi # 0x614b0
callq 0x287e0
testl %eax, %eax
je 0x55b3f
leaq 0x5194(%rip), %rdx ... | /connormanning[P]arbiter/third/gtest-1.7.0/include/gtest/internal/gtest-port.h |
testing::internal::StreamingListener::OnTestIterationStart(testing::UnitTest const&, int) | void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) {
SendLn("event=TestIterationStart&iteration=" +
StreamableToString(iteration));
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
movl %edx, (%rsi)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x539a1
leaq 0xad95(%rip), %rcx # 0x60d16
movl $0x23, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x28190
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax)... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&) | void OnTestEnd(const TestInfo& test_info) {
SendLn("event=TestEnd&passed=" +
FormatBool((test_info.result())->Passed()) +
"&elapsed_time=" +
StreamableToString((test_info.result())->elapsed_time()) + "ms");
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rsi), %rdi
callq 0x41d6a
leaq 0xa974(%rip), %rcx # 0x61028
leaq 0xa088(%rip), %rsi # 0x60743
testb %al, %al
cmovneq %rcx, %rsi
leaq 0xc0(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xa954(%rip), %rax... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestProgramEnd(testing::UnitTest const&) | void OnTestProgramEnd(const UnitTest& unit_test) {
// Note that Google Test current only report elapsed time for each
// test iteration, not for the entire test program.
SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));
// Notify the streaming server to stop.
socket_writer_->... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x53a12
leaq 0x96a9(%rip), %rcx # 0x60743
leaq 0x9f87(%rip), %rsi # 0x61028
testb %al, %al
cmovneq %rcx, %rsi
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x968d(%rip), %rax # 0x60744
leaq 0x9f6b(%rip), %rd... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-internal-inl.h |
testing::internal::StreamingListener::AbstractSocketWriter::SendLn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SendLn(const string& message) {
Send(message + "\n");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3a6f2
leaq 0x8ab8(%rip), %rsi # 0x5fe98
movq %r14, %rdi
callq 0x28620
movq (%rbx), %rax
movq ... | /connormanning[P]arbiter/third/gtest-1.7.0/src/gtest-internal-inl.h |
testing::internal::FloatingPoint<double>::AlmostEquals(testing::internal::FloatingPoint<double> const&) const | bool AlmostEquals(const FloatingPoint& rhs) const {
// The IEEE standard says that any comparison operation involving
// a NAN must return false.
if (is_nan() || rhs.is_nan()) return false;
return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
<= kMaxUlps;
} | movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
movq (%rdi), %rax
movq %rax, %rcx
notq %rcx
testq %rdx, %rcx
sete %cl
movq %rax, %rdi
shlq $0xc, %rdi
setne %dil
testb %dil, %cl
jne 0x57a36
movabsq $0xfffffffffffff, %rdi # imm = 0xFFFFFFFFFFFFF
movq (%rsi), %rcx
movq %rcx, %rsi
notq %rsi
testq %rsi, %rdx
s... | /connormanning[P]arbiter/third/gtest-1.7.0/include/gtest/internal/gtest-internal.h |
testing::AssertionResult& testing::AssertionResult::operator<<<wchar_t const*>(wchar_t const* const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3f04e
movq (%r14), %rsi
movq %r15, %rdi
callq 0x3f09a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3041c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x57bc0
movq (%rdi), %rax
callq *0x8(%rax)
movq... | /connormanning[P]arbiter/third/gtest-1.7.0/include/gtest/gtest.h |
stbtt__close_shape(stbtt_vertex*, int, int, int, int, int, int, int, int, int) | static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off,
stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy)
{
if (start_off) {
if (was_off)
stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1... | pushq %rbp
pushq %rbx
movl %esi, %eax
movl 0x30(%rsp), %esi
movl 0x28(%rsp), %r11d
testl %ecx, %ecx
je 0x56c96
movl 0x20(%rsp), %ecx
movl 0x18(%rsp), %ebx
testl %edx, %edx
je 0x56c78
movslq %eax, %rdx
incl %eax
imulq $0xe, %rdx, %rdx
leal (%r11,%rbx), %r10d
shrl %r10d
leal (%rsi,%rcx), %ebp
shrl %ebp
movb $0x3, 0xc(%rd... | /ggerganov[P]kbd-audio/imgui/imstb_truetype.h |
ImParseFormatTrimDecorations(char const*, char*, unsigned long) | const char* ImParseFormatTrimDecorations(const char* fmt, char* buf, size_t buf_size)
{
const char* fmt_start = ImParseFormatFindStart(fmt);
if (fmt_start[0] != '%')
return fmt;
const char* fmt_end = ImParseFormatFindEnd(fmt_start);
if (fmt_end[0] == 0) // If we only have leading decoration, we ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
callq 0x5f5a5
cmpb $0x25, (%rax)
jne 0x5f66d
movq %rax, %r15
movq %rax, %rdi
callq 0x5f5ca
cmpb $0x0, (%rax)
je 0x5f66a
subq %r15, %rax
incq %rax
cmpq %r14, %rax
cmovaeq %r14, %rax
movq %rbx, %rdi
movq %r15, %rsi
movq... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
ImGuiInputTextCallbackData::DeleteChars(int, int) | void ImGuiInputTextCallbackData::DeleteChars(int pos, int bytes_count)
{
IM_ASSERT(pos + bytes_count <= BufTextLen);
char* dst = Buf + pos;
const char* src = Buf + pos + bytes_count;
while (char c = *src++)
*dst++ = c;
*dst = '\0';
if (CursorPos + bytes_count >= pos)
CursorPos -... | pushq %rax
leal (%rdx,%rsi), %eax
cmpl 0x20(%rdi), %eax
jg 0x63557
movslq %esi, %rax
addq 0x18(%rdi), %rax
movslq %edx, %rcx
movb (%rax,%rcx), %r8b
testb %r8b, %r8b
je 0x6352c
movb %r8b, (%rax)
incq %rax
jmp 0x6351b
movb $0x0, (%rax)
movl 0x2c(%rdi), %eax
leal (%rax,%rdx), %ecx
cmpl %esi, %ecx
jge 0x6353f
cmpl %esi, %e... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
ImGuiTabBar::ImGuiTabBar() | ImVec2(float _x, float _y) { x = _x; y = _y; } | xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x78(%rdi)
movups %xmm0, 0x68(%rdi)
orq $-0x1, 0x20(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x53(%rdi)
orw $-0x1, 0x64(%rdi)
retq
| /ggerganov[P]kbd-audio/imgui/imgui.h |
ImGui::TabBarLayout(ImGuiTabBar*) | static void ImGui::TabBarLayout(ImGuiTabBar* tab_bar)
{
ImGuiContext& g = *GImGui;
tab_bar->WantLayout = false;
// Garbage collect
int tab_dst_n = 0;
for (int tab_src_n = 0; tab_src_n < tab_bar->Tabs.Size; tab_src_n++)
{
ImGuiTabItem* tab = &tab_bar->Tabs[tab_src_n];
if (tab->La... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x3a312(%rip), %rax # 0xa4630
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x61(%rdi)
xorl %r14d, %r14d
xorl %ebp, %ebp
movl (%rbx), %eax
cmpl %eax, %r14d
jge 0x6a38a
movq %rbx, %rdi
movl %r14d, %esi
callq 0... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
ImGui::TabBarQueueChangeTabOrder(ImGuiTabBar*, ImGuiTabItem const*, int) | void ImGui::TabBarQueueChangeTabOrder(ImGuiTabBar* tab_bar, const ImGuiTabItem* tab, int dir)
{
IM_ASSERT(dir == -1 || dir == +1);
IM_ASSERT(tab_bar->ReorderRequestTabId == 0);
tab_bar->ReorderRequestTabId = tab->ID;
tab_bar->ReorderRequestDir = (ImS8)dir;
} | pushq %rax
cmpl $-0x1, %edx
je 0x6ad8d
cmpl $0x1, %edx
jne 0x6adbc
cmpl $0x0, 0x5c(%rdi)
jne 0x6ad9d
movl (%rsi), %eax
movl %eax, 0x5c(%rdi)
movb %dl, 0x60(%rdi)
popq %rax
retq
leaq 0x1ca62(%rip), %rdi # 0x87806
leaq 0x1b24d(%rip), %rsi # 0x85ff8
leaq 0x1ca04(%rip), %rcx # 0x877b6
movl $0x1b12, %edx ... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
ImGui::TabItemEx(ImGuiTabBar*, char const*, bool*, int) | bool ImGui::TabItemEx(ImGuiTabBar* tab_bar, const char* label, bool* p_open, ImGuiTabItemFlags flags)
{
// Layout whole tab bar if not already done
if (tab_bar->WantLayout)
TabBarLayout(tab_bar);
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (window->SkipItems)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %ecx, %r12d
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x61(%rdi)
jne 0x6ae92
movq %r14, %rdi
callq 0x6a303
leaq 0x39797(%rip), %rax # 0xa4630
movq (%rax), %rbp
movq 0x1a80(%rbp), %rax
movq %rax, 0x20(%rsp)
cmpb ... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
ImGui::TabItemLabelAndCloseButton(ImDrawList*, ImRect const&, int, ImVec2, char const*, unsigned int, unsigned int, bool) | bool ImGui::TabItemLabelAndCloseButton(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImVec2 frame_padding, const char* label, ImGuiID tab_id, ImGuiID close_button_id, bool is_contents_visible)
{
ImGuiContext& g = *GImGui;
ImVec2 label_size = CalcTextSize(label, NULL, true);
if (bb.GetWid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r9d, %r15d
movl %r8d, 0xc(%rsp)
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movaps %xmm0, 0x10(%rsp)
movlps %xmm0, 0x48(%rsp)
leaq 0x38d24(%rip), %rax # 0xa4630
movq (%rax), %rbp
xorl %r13d, %r13d
pushq $0x1
popq %rdx
movss... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
ImGui::FindOrCreateColumns(ImGuiWindow*, unsigned int) | ImGuiColumns* ImGui::FindOrCreateColumns(ImGuiWindow* window, ImGuiID id)
{
// We have few columns per window so for now we don't need bother much with turning this into a faster lookup.
for (int n = 0; n < window->ColumnsStorage.Size; n++)
if (window->ColumnsStorage[n].ID == id)
return &win... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebx
movq %rdi, %r14
addq $0x298, %r14 # imm = 0x298
xorl %ebp, %ebp
cmpl (%r14), %ebp
jge 0x6c035
movq %r14, %rdi
movl %ebp, %esi
callq 0x48642
cmpl %ebx, (%rax)
je 0x6c068
incl %ebp
jmp 0x6c01e
movq %rsp, %r15
movq %r15, %rdi
callq 0x7... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
ImGui::BeginColumns(char const*, int, int) | void ImGui::BeginColumns(const char* str_id, int columns_count, ImGuiColumnsFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
IM_ASSERT(columns_count >= 1);
IM_ASSERT(window->DC.CurrentColumns == NULL); // Nested columns are currently not supported
// Acquire st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x38532(%rip), %rax # 0xa4630
movq (%rax), %r12
movq 0x1a80(%r12), %rbx
movb $0x1, 0x80(%rbx)
testl %esi, %esi
jle 0x6c459
cmpq $0x0, 0x1a0(%rbx)
jne 0x6c478
movl %edx, %ebp
movl %esi, %r15d
callq 0x6c08f
movl %eax, %r14d
movq %... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
ImGui::EndColumns() | void ImGui::EndColumns()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
ImGuiColumns* columns = window->DC.CurrentColumns;
IM_ASSERT(columns != NULL);
PopItemWidth();
if (columns->Count > 1)
{
PopClipRect();
columns->Splitter.Merge(window->DrawList);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0x37f58(%rip), %rax # 0xa4630
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x1a80(%rax), %r13
movb $0x1, 0x80(%r13)
movq 0x1a0(%r13), %r15
testq %r15, %r15
je 0x6cab5
callq 0x42fed
cmpl $0x2, 0x10(%r15)
jl 0x6c720
callq 0x3f2a4
... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
ImStb::STB_TEXTEDIT_DELETECHARS(ImGuiInputTextState*, int, int) | static void STB_TEXTEDIT_DELETECHARS(STB_TEXTEDIT_STRING* obj, int pos, int n)
{
ImWchar* dst = obj->TextW.Data + pos;
// We maintain our buffer length in both UTF-8 and wchar formats
obj->CurLenA -= ImTextCountUtf8BytesFromStr(dst, dst + n);
obj->CurLenW -= n;
// Offset remaining text (FIXME-OPT:... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movslq %esi, %r15
leaq (%r14,%r15,2), %rdi
movslq %edx, %r12
leaq (%rdi,%r12,2), %rsi
callq 0x35d5d
subl %eax, 0x8(%rbx)
subl %r12d, 0x4(%rbx)
addq %r12, %r12
addq 0x18(%rbx), %r12
addq %r15, %r15
movzwl (%r12,%r15), %eax
testw... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
ImStb::STB_TEXTEDIT_INSERTCHARS(ImGuiInputTextState*, int, unsigned short const*, int) | static bool STB_TEXTEDIT_INSERTCHARS(STB_TEXTEDIT_STRING* obj, int pos, const ImWchar* new_text, int new_text_len)
{
const bool is_resizable = (obj->UserFlags & ImGuiInputTextFlags_CallbackResize) != 0;
const int text_len = obj->CurLenW;
IM_ASSERT(pos <= text_len);
const int new_text_len_utf8 = ImTextC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x4(%rdi), %ebp
movl %esi, 0x4(%rsp)
cmpl %esi, %ebp
jl 0x6cd77
movl %ecx, %ebx
movq %rdx, %r13
movq %rdi, %r14
movl 0xe78(%rdi), %r15d
movslq %ecx, %r12
leaq (%rdx,%r12,2), %rsi
movq %rdx, %rdi
callq 0x35d5d
btl $0x12, %r15d
jb 0x6... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
ImStb::STB_TEXTEDIT_LAYOUTROW(ImStb::StbTexteditRow*, ImGuiInputTextState*, int) | static void STB_TEXTEDIT_LAYOUTROW(StbTexteditRow* r, STB_TEXTEDIT_STRING* obj, int line_start_idx)
{
const ImWchar* text = obj->TextW.Data;
const ImWchar* text_remaining = NULL;
const ImVec2 size = InputTextCalcTextSizeW(text + line_start_idx, text + obj->CurLenW, &text_remaining, NULL, true);
r->x0... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rsi), %rax
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movslq %edx, %rcx
leaq (%rax,%rcx,2), %r15
movslq 0x4(%rsi), %rcx
leaq (%rax,%rcx,2), %rsi
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0x638a9
andl $0x0, (%rbx)
movlps %xmm0, 0x4... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
ImStb::stb_textedit_delete(ImGuiInputTextState*, ImStb::STB_TexteditState*, int, int) | static void stb_textedit_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int len)
{
stb_text_makeundo_delete(str, state, where, len);
STB_TEXTEDIT_DELETECHARS(str, where, len);
state->has_preferred_x = 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdi, %r15
movq %rsi, 0x10(%rsp)
leaq 0x18(%rsi), %rdi
xorl %r13d, %r13d
movl %edx, 0xc(%rsp)
movl %edx, %esi
movl %ecx, %edx
xorl %ecx, %ecx
callq 0x6d191
testq %rax, %rax
je 0x6d15c
movq %rax, %r12
testl %ebp, %ebp... | /ggerganov[P]kbd-audio/imgui/imstb_textedit.h |
ImStb::stb_textedit_discard_undo(ImStb::StbUndoState*) | static void stb_textedit_discard_undo(StbUndoState *state)
{
if (state->undo_point > 0) {
// if the 0th undo state has characters, clean those up
if (state->undo_rec[0].char_storage >= 0) {
int n = state->undo_rec[0].insert_length, i;
// delete n characters from all other records
... | movzwl 0xdfe(%rdi), %eax
testw %ax, %ax
jle 0x6d2f2
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
js 0x6d2ce
movslq 0x4(%rbx), %r14
movslq 0xe04(%rbx), %rdx
subq %r14, %rdx
movl %edx, 0xe04(%rbx)
leaq 0x630(%rbx), %rdi
leaq (%rbx,%r14,2), %rsi
addq $0x630, %rsi # imm = 0x630
addq %rdx... | /ggerganov[P]kbd-audio/imgui/imstb_textedit.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.