name string | code string | asm string | file string |
|---|---|---|---|
generate_domain | static isl_stat generate_domain(__isl_take isl_map *executed, void *user)
{
struct isl_generate_domain_data *data = user;
isl_set *domain;
isl_map *map = NULL;
int empty, sv;
domain = isl_ast_build_get_domain(data->build);
domain = isl_set_from_basic_set(isl_set_simple_hull(domain));
executed = isl_map_intersec... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x1ad6eea
movq %rax, %rdi
callq 0x1af31e2
movq %rax, %rdi
callq 0x1b138e3
movq %r14, %rdi
movq %rax, %rsi
callq 0x1b1761a
movq %rax, %r14
movq %rax, %rdi
callq 0x1b1bf23
testl %eax, %eax
js 0x1ae1e40
je 0x1ae1e22
movq %r14, %rdi
ca... | /External/isl/isl_ast_codegen.c |
isl_ast_graft_insert_mark | __isl_give isl_ast_graft *isl_ast_graft_insert_mark(
__isl_take isl_ast_graft *graft, __isl_take isl_id *mark)
{
if (!graft)
goto error;
graft->node = isl_ast_node_alloc_mark(mark, graft->node);
if (!graft->node)
return isl_ast_graft_free(graft);
return graft;
error:
isl_id_free(mark);
isl_ast_graft_free(g... | pushq %rbx
movq %rsi, %rax
testq %rdi, %rdi
je 0x1ae881f
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %rax, %rdi
callq 0x1add726
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x1ae8829
movq %rbx, %rdi
callq 0x1ae69c2
jmp 0x1ae8827
movq %rax, %rdi
callq 0x1afe3ec
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
| /External/isl/isl_ast_graft.c |
update_basic_maps | static __isl_give isl_map *update_basic_maps(__isl_take isl_map *map,
int n, struct isl_coalesce_info *info)
{
int i;
if (!map)
return NULL;
for (i = n - 1; i >= 0; --i) {
if (info[i].removed) {
isl_basic_map_free(map->p[i]);
if (i != map->n - 1)
map->p[i] = map->p[map->n - 1];
map->n--;
conti... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x1ae9662
movl %esi, %r14d
leaq (%r14,%r14,2), %rax
shlq $0x4, %rax
leaq (%rax,%rdx), %r15
addq $-0x30, %r15
cmpl $0x0, 0x18(%r15)
je 0x1ae95eb
movq 0x30(%rbx,%r14,8), %rdi
callq 0x1b0fb02
movl 0x28(%rbx), %eax
cmpq %rax, %r14
je 0x1ae95e4
movslq %ea... | /External/isl/isl_coalesce.c |
wraps_init | static isl_stat wraps_init(struct isl_wraps *wraps, __isl_take isl_mat *mat,
struct isl_coalesce_info *info, int i, int j)
{
isl_ctx *ctx;
wraps->failed = 0;
wraps->bound = 0;
wraps->mat = mat;
if (!mat)
return isl_stat_error;
wraps->mat->n_row = 0;
ctx = isl_mat_get_ctx(mat);
wraps->bound = isl_options_get... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq $0x0, (%rdi)
movq %rsi, 0x8(%rdi)
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x1aeb67e
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %rbx
movq %rdi, %r14
movl $0x0, 0x14(%rsi)
movq %rsi, %rdi
callq 0x1b32714
movq %rax, %rdi
callq 0x1b38... | /External/isl/isl_coalesce.c |
isl_constraint_list_alloc | __isl_give LIST(EL) *FN(LIST(EL),alloc)(isl_ctx *ctx, int n)
{
LIST(EL) *list;
if (n < 0)
isl_die(ctx, isl_error_invalid,
"cannot create list of negative length",
return NULL);
list = isl_alloc(ctx, LIST(EL),
sizeof(LIST(EL)) + (n - 1) * sizeof(struct EL *));
if (!list)
return NULL;
list->ctx = ctx... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
testl %esi, %esi
js 0x1aef076
movl %esi, %ebp
movslq %esi, %rax
leaq 0x20(,%rax,8), %rsi
movq %r14, %rdi
callq 0x1af8237
testq %rax, %rax
je 0x1aef097
movq %rax, %rbx
movq %r14, 0x8(%rax)
movq %r14, %rdi
callq 0x1af85c4
movl $0x1, (%rbx)
movl %ebp, %eax
movq %rax, 0x18(%... | /External/isl/isl_list_templ.c |
isl_constraint_list_insert | __isl_give LIST(EL) *FN(LIST(EL),insert)(__isl_take LIST(EL) *list,
unsigned pos, __isl_take struct EL *el)
{
int i;
isl_ctx *ctx;
LIST(EL) *res;
if (!list || !el)
goto error;
ctx = FN(LIST(EL),get_ctx)(list);
if (pos > list->n)
isl_die(ctx, isl_error_invalid,
"index out of bounds", goto error);
if (li... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x1aef405
movl %esi, %ebp
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
cmpl %ebp, %esi
jae 0x1aef423
leaq 0x35a78a1(%rip), %rdx # 0x5096c8f
leaq 0x341bdd1(%rip), %r... | /External/isl/isl_list_templ.c |
isl_constraint_check_range | isl_stat FN(TYPE,check_range)(__isl_keep TYPE *obj,
enum isl_dim_type type, unsigned first, unsigned n)
{
isl_size dim;
dim = FN(TYPE,dim)(obj, type);
if (dim < 0)
return isl_stat_error;
if (first + n > dim || first + n < first)
isl_die(FN(TYPE,get_ctx)(obj), isl_error_invalid,
"position or range out of bo... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x1af043b
movq 0x8(%rbx), %rdi
callq 0x1b0bf7d
testl %eax, %eax
js 0x1af048b
addl %r15d, %r14d
setb... | /External/isl/check_type_range_templ.c |
isl_basic_map_has_defining_equality | isl_bool isl_basic_map_has_defining_equality(
__isl_keep isl_basic_map *bmap, enum isl_dim_type type, int pos,
__isl_give isl_constraint **c)
{
int i;
unsigned offset;
isl_size total;
if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
return isl_bool_error;
offset = isl_basic_map_offset(bmap, type);
tota... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
movl $0x1, %ecx
callq 0x1b114ef
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x1af0d26
movq %r14, %rdi
movl %ebp, %esi
callq 0x1b0f370
movl %eax, %r1... | /External/isl/isl_constraint.c |
uset_convex_hull | static __isl_give isl_basic_set *uset_convex_hull(__isl_take isl_set *set)
{
isl_bool bounded;
isl_size dim;
struct isl_basic_set *convex_hull = NULL;
struct isl_basic_set *lin;
dim = isl_set_dim(set, isl_dim_all);
if (dim < 0)
goto error;
if (dim == 0)
return convex_hull_0d(set);
set = isl_set_coalesce(s... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x5, %esi
callq 0x1b0f2bb
testl %eax, %eax
js 0x1af2e75
je 0x1af2dda
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1ae96c0
movq %rax, %rdi
callq 0x1b11ccb
testq %rax, %rax
je 0x1af2e07
movq %rax, %rbx
cmpl $0x1, 0x28(%rax)
jne 0x1af2e0f
movq 0x38(%rbx), %rdi
callq 0x1b10... | /External/isl/isl_convex_hull.c |
is_bound | static int is_bound(struct sh_data *data, __isl_keep isl_set *set, int j,
isl_int *ineq, int shift)
{
enum isl_lp_result res;
isl_int opt;
if (!data->p[j].tab) {
data->p[j].tab = isl_tab_from_basic_set(set->p[j], 0);
if (!data->p[j].tab)
return -1;
}
isl_int_init(opt);
res = isl_tab_min(data->p[j].tab,... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdi, %r14
movslq %edx, %rax
movq %rax, %rcx
shlq $0x4, %rcx
leaq (%rdi,%rcx), %r15
addq $0x20, %r15
cmpq $0x0, (%r15)
jne 0x1af7f81
movq 0x38(%rsi,%rax,8), %rdi
xorl %esi, %esi
callq 0x1b7b11e
movq %rax, (%r15)
testq %rax, %rax... | /External/isl/isl_convex_hull.c |
isl_restriction_free | __isl_null isl_restriction *isl_restriction_free(
__isl_take isl_restriction *restr)
{
if (!restr)
return NULL;
isl_set_free(restr->source);
isl_set_free(restr->sink);
free(restr);
return NULL;
} | testq %rdi, %rdi
je 0x1af9f99
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1b139c2
movq 0x10(%rbx), %rdi
callq 0x1b139c2
movq %rbx, %rdi
callq 0x780910
popq %rbx
xorl %eax, %eax
retq
| /External/isl/isl_flow.c |
intermediate_sources | static isl_stat intermediate_sources(__isl_keep isl_access_info *acc,
struct isl_map **temp_rel, int j, int sink_level)
{
int k, level;
isl_size n_in = isl_map_dim(acc->source[j].map, isl_dim_in);
int depth = 2 * n_in + 1;
if (n_in < 0)
return isl_stat_error;
if (isl_map_plain_is_empty(temp_rel[j]))
return i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, %ebx
movq %rsi, %r12
movl %edx, %ebp
leaq (%rbp,%rbp,2), %r15
movq %rdi, 0x10(%rsp)
movq 0x50(%rdi,%r15,8), %rdi
movl $0x2, %esi
callq 0x1b0f278
testl %eax, %eax
js 0x1afc9bd
movl %eax, %r14d
movq (%r12,%r... | /External/isl/isl_flow.c |
isl_id_cmp | int isl_id_cmp(__isl_keep isl_id *id1, __isl_keep isl_id *id2)
{
if (id1 == id2)
return 0;
if (!id1)
return -1;
if (!id2)
return 1;
if (!id1->name != !id2->name)
return !id1->name - !id2->name;
if (id1->name) {
int cmp = strcmp(id1->name, id2->name);
if (cmp != 0)
return cmp;
}
if (id1->user < id2... | cmpq %rsi, %rdi
je 0x1aff362
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rdi, %rdi
je 0x1aff365
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1aff36c
movq 0x10(%r14), %rdi
testq %rdi, %rdi
sete %al
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
sete %cl
cmpb %cl, %al
je 0x1aff373
xorl %eax, %eax
testq %rdi, %rdi
sete %al
c... | /External/isl/isl_id.c |
isl_map_divs_known | isl_bool isl_map_divs_known(__isl_keep isl_map *map)
{
int i;
if (!map)
return isl_bool_error;
for (i = 0; i < map->n; ++i) {
int known = isl_basic_map_divs_known(map->p[i]);
if (known <= 0)
return known;
}
return isl_bool_true;
} | testq %rdi, %rdi
je 0x1b1a5ac
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %eax
cmpl $0x0, 0x28(%rdi)
jle 0x1b1a5b4
xorl %r15d, %r15d
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
xorl %r13d, %r13d
movq 0x38(%r14,%r13,8), %rdi
movl $0xffffffff, %ebx # i... | /External/isl/isl_map.c |
greator | static __isl_give isl_basic_map *greator(__isl_take isl_space *space,
enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
{
isl_basic_map *bmap = NULL;
int i;
isl_size total;
if (isl_space_check_range(space, type1, pos1, 1) < 0 ||
isl_space_check_range(space, type2, pos2, 1) < 0)
goto err... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movl $0x1, %ecx
callq 0x1b71355
testl %eax, %eax
js 0x1b2272b
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x1b71355
testl %eax, %eax
... | /External/isl/isl_map.c |
print_constraint | static __isl_give isl_printer *print_constraint(__isl_take isl_printer *p,
__isl_keep isl_space *space, __isl_keep isl_mat *div,
isl_int *c, int last, const char *op, int latex)
{
isl_int_abs(c[last], c[last]);
p = print_term(space, div, c[last], last, p, latex);
p = isl_printer_print_str(p, " ");
p = isl_print... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movl %r8d, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movl 0x50(%rsp), %ebx
movl %r8d, %eax
movq %rcx, 0x10(%rsp)
leaq (%rcx,%rax,8), %r12
movq (%r12), %rdi
testb $0x1, %dil
jne 0x1b3cee8
movq (%r12), %rsi
c... | /External/isl/isl_output.c |
print_latex_map | static __isl_give isl_printer *print_latex_map(__isl_keep isl_map *map,
__isl_take isl_printer *p, __isl_keep isl_basic_map *aff)
{
struct isl_print_space_data data = { 0 };
data.latex = 1;
p = print_param_tuple(p, map->dim, &data);
p = isl_printer_print_str(p, s_open_set[1]);
data.print_dim = &print_dim_eq;
da... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movaps %xmm0, 0x10(%r15)
movq $0x0, 0x20(%r15)
movl $0x1, (%r15)
movq 0x20(%rdi), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x1b3acfd
leaq 0x33d1dab(%rip), %rsi # ... | /External/isl/isl_output.c |
isl_pw_qpolynomial_restrict_domain | static __isl_give PW *FN(PW,restrict_domain)(__isl_take PW *pw,
__isl_take isl_set *set,
__isl_give isl_set *(*fn)(__isl_take isl_set *set1,
__isl_take isl_set *set2))
{
int i;
isl_size n;
FN(PW,align_params_set)(&pw, &set);
n = FN(PW,n_piece)(pw);
if (n < 0 || !set)
goto error;
for (i = n - 1; i >=... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x1b4fec2
movq (%r14), %r15
testq %r15, %r15
je 0x1b4747c
movl 0x10(%r15), %r13d
jmp 0x1b47482
movl $0xf... | /External/isl/isl_pw_templ.c |
isl_pw_qpolynomial_take_domain_at | static __isl_give isl_set *FN(PW,take_domain_at)(__isl_keep PW *pw, int pos)
{
isl_set *domain;
if (!pw)
return NULL;
if (pw->ref != 1)
return FN(PW,get_domain_at)(pw, pos);
if (FN(PW,check_pos)(pw, pos) < 0)
return NULL;
domain = pw->p[pos].set;
pw->p[pos].set = NULL;
return domain;
} | pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b47e4b
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x1b47e54
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b46fc6
testl %eax, %eax
js 0x1b47e4b
movslq %ebp, %rcx
shlq $0x4, %rcx
movq 0x20(%rbx,%rcx), %rax
movq $0x0, 0x20(%rbx,%rcx)
jmp 0x1b47e4d
xorl %eax, %e... | /External/isl/isl_pw_templ.c |
isl_pw_qpolynomial_restore_domain_at | static __isl_give PW *FN(PW,restore_domain_at)(__isl_take PW *pw, int pos,
__isl_take isl_set *domain)
{
if (FN(PW,check_pos)(pw, pos) < 0 || !domain)
goto error;
if (pw->p[pos].set == domain) {
isl_set_free(domain);
return pw;
}
pw = FN(PW,cow)(pw);
if (!pw)
goto error;
isl_set_free(pw->p[pos].set);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1b46fc6
testq %r14, %r14
je 0x1b47ed0
testl %eax, %eax
js 0x1b47ed0
movslq %ebp, %r15
shlq $0x4, %r15
cmpq %r14, 0x20(%rbx,%r15)
je 0x1b47eac
testq %rbx, %rbx
je 0x1b47eb6
movl (%rbx), %eax
cmpl $0x1, %eax
je ... | /External/isl/isl_pw_templ.c |
isl_pw_qpolynomial_drop_unused_params | __isl_give PW *FN(PW,drop_unused_params)(__isl_take PW *pw)
{
isl_size n;
int i;
if (FN(PW,check_named_params)(pw) < 0)
return FN(PW,free)(pw);
n = FN(PW,dim)(pw, isl_dim_param);
if (n < 0)
return FN(PW,free)(pw);
for (i = n - 1; i >= 0; i--) {
isl_bool involves;
involves = FN(PW,involves_dims)(pw, isl... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1b480e7
movq 0x8(%rbx), %rdi
jmp 0x1b480e9
xorl %edi, %edi
callq 0x1b73e26
testl %eax, %eax
js 0x1b4815a
testq %rbx, %rbx
je 0x1b480fd
movq 0x8(%rbx), %rdi
jmp 0x1b480ff
xorl %edi, %edi
movl $0x1, %esi
callq 0x1b6fb4e
testl %eax, %eax
js 0x1b4815a
m... | /External/isl/isl_pw_templ.c |
isl_schedule_node_gist | __isl_give isl_schedule_node *isl_schedule_node_gist(
__isl_take isl_schedule_node *node, __isl_take isl_union_set *context)
{
struct isl_node_gist_data data;
data.n_expansion = 0;
data.filters = isl_union_set_list_from_union_set(context);
node = traverse(node, &gist_enter, &gist_leave, &data);
isl_union_set_lis... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x0, (%r14)
movq %rsi, %rdi
callq 0x1b6e88f
movq %rax, 0x8(%r14)
leaq 0x29(%rip), %rsi # 0x1b5ac2a
leaq 0x36a(%rip), %rdx # 0x1b5af72
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1b58972
movq %rax, %rbx
movq 0x8(%r14), %rdi
callq ... | /External/isl/isl_schedule_node.c |
isl_space_cow | __isl_give isl_space *isl_space_cow(__isl_take isl_space *space)
{
if (!space)
return NULL;
if (space->ref == 1)
return space;
space->ref--;
return isl_space_dup(space);
} | testq %rdi, %rdi
je 0x1b6fea0
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1b6fea2
decl %eax
movl %eax, (%rdi)
jmp 0x1b6fc64
xorl %edi, %edi
movq %rdi, %rax
retq
| /External/isl/isl_space.c |
isl_space_insert_dims | __isl_give isl_space *isl_space_insert_dims(__isl_take isl_space *space,
enum isl_dim_type type, unsigned pos, unsigned n)
{
isl_ctx *ctx;
isl_id **ids = NULL;
if (!space)
return NULL;
if (n == 0)
return isl_space_reset(space, type);
ctx = isl_space_get_ctx(space);
if (!valid_dim_type(type))
isl_die(ctx,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
je 0x1b7160e
movl %ecx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
testl %ecx, %ecx
je 0x1b71429
movq 0x8(%rbx), %r13
leal -0x4(%r12), %eax
cmpl $-0x4, %eax
ja 0x1b71442
leaq 0x33a0540(%rip), %rdx # 0x4f1194a
leaq 0x33a042... | /External/isl/isl_space.c |
isl_space_factor_range | __isl_give isl_space *isl_space_factor_range(__isl_take isl_space *space)
{
if (!space)
return NULL;
if (isl_space_is_set(space))
return set_factor_range(space);
space = isl_space_domain_factor_range(space);
space = isl_space_range_factor_range(space);
return space;
} | pushq %rbx
testq %rdi, %rdi
je 0x1b7275b
movq %rdi, %rbx
cmpl $0x0, 0x14(%rdi)
jne 0x1b7270b
cmpq $0x0, 0x30(%rbx)
jne 0x1b7270b
movq 0x20(%rbx), %rax
cmpq 0x3d89767(%rip), %rax # 0x58fbe70
je 0x1b7271c
movq %rbx, %rdi
callq 0x1b724b7
movq %rax, %rdi
popq %rbx
jmp 0x1b72652
movq %rbx, %rdi
callq 0x1b736f4
testl %eax,... | /External/isl/isl_space.c |
check_fresh_params | static isl_stat check_fresh_params(__isl_keep isl_space *space,
__isl_keep isl_multi_id *tuple)
{
int i;
isl_size n;
n = isl_multi_id_size(tuple);
if (n < 0)
return isl_stat_error;
for (i = 0; i < n; ++i) {
isl_id *id;
int pos;
id = isl_multi_id_get_at(tuple, i);
if (!id)
return isl_stat_error;
p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1aff692
movl %eax, %ebp
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ebp, %ebp
js 0x1b72f0d
je 0x1b72ed9
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x1aff6a1
testq... | /External/isl/isl_space.c |
isl_space_unwrap | __isl_give isl_space *isl_space_unwrap(__isl_take isl_space *space)
{
isl_space *unwrap;
if (!space)
return NULL;
if (!isl_space_is_wrapping(space))
isl_die(space->ctx, isl_error_invalid, "not a wrapping space",
goto error);
unwrap = isl_space_copy(space->nested[1]);
isl_space_free(space);
return unwra... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b73459
movq %rdi, %rbx
callq 0x1b736f4
testl %eax, %eax
je 0x1b7345e
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x1b73480
incl (%r14)
jmp 0x1b73483
xorl %r14d, %r14d
jmp 0x1b7348b
movq 0x8(%rbx), %rdi
leaq 0x339e664(%rip), %rdx # 0x4f11acd
leaq 0x339e3c3(%rip), %... | /External/isl/isl_space.c |
detect_stride | static isl_stat detect_stride(__isl_take isl_constraint *c, void *user)
{
struct isl_detect_stride_data *data = user;
int i;
isl_size n_div;
isl_ctx *ctx;
isl_stat r = isl_stat_ok;
isl_val *v, *stride, *m;
isl_bool is_eq, relevant, has_stride;
is_eq = isl_constraint_is_equality(c);
relevant = isl_constraint_i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1af0b42
movl %eax, %ebp
movl (%r14), %edx
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1, %ecx
callq 0x1af037e
movl %ebp, %ecx
orl %eax, %ecx
jns 0x1b7458d
movq %rbx, %rdi
callq 0x1aef248
movl $0xffffff... | /External/isl/isl_stride.c |
isl_token_free | void isl_token_free(struct isl_token *tok)
{
if (!tok)
return;
if (tok->type == ISL_TOKEN_VALUE)
isl_int_clear(tok->u.v);
else if (tok->type == ISL_TOKEN_MAP)
isl_map_free(tok->u.map);
else if (tok->type == ISL_TOKEN_AFF)
isl_pw_aff_free(tok->u.pwaff);
else
free(tok->u.s);
free(tok);
} | testq %rdi, %rdi
je 0x1b74b21
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x11f, %eax # imm = 0x11F
je 0x1b74b2d
cmpl $0x11e, %eax # imm = 0x11E
je 0x1b74b22
cmpl $0x101, %eax # imm = 0x101
jne 0x1b74b38
movq 0x10(%rbx), %rdi
testb $0x1, %dil
jne 0x1b74b41
callq 0x1b9b0de
jmp 0x1... | /External/isl/isl_stream.c |
context_gbr_free | isl_context *context_gbr_free(
struct isl_context *context)
{
struct isl_context_gbr *cgbr = (struct isl_context_gbr *)context;
isl_tab_free(cgbr->tab);
isl_tab_free(cgbr->shifted);
isl_tab_free(cgbr->cone);
free(cgbr);
return NULL;
} | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x1b7678d
movq 0x18(%rbx), %rdi
callq 0x1b7678d
movq 0x20(%rbx), %rdi
callq 0x1b7678d
movq %rbx, %rdi
callq 0x780910
xorl %eax, %eax
popq %rbx
retq
| /External/isl/isl_tab_pip.c |
isl_union_set_unwrap | __isl_give isl_union_map *isl_union_set_unwrap(__isl_take isl_union_set *uset)
{
struct isl_un_op_drop_user_data data = { &isl_set_is_wrapping };
struct isl_un_op_control control = {
.filter = &un_op_filter_drop_user,
.filter_user = &data,
.fn_map = &isl_set_unwrap,
};
return un_op(uset, &control);
} | subq $0x38, %rsp
leaq -0x6e647(%rip), %rax # 0x1b20c45
movq %rsp, %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq -0x5da(%rip), %rax # 0x1b8eccb
movq %rax, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
leaq -0x767a0(%rip), %rax # 0x1b18b14
movq %rax, 0x18(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsi... | /External/isl/isl_union_map.c |
reset_params | static isl_stat reset_params(__isl_take isl_map *map, void *user)
{
struct isl_union_map_reset_params_data *data = user;
isl_space *space;
space = isl_map_get_space(map);
space = isl_space_replace_params(space, data->space);
map = isl_map_reset_equal_dim_space(map, space);
data->res = isl_union_map_add_map(data-... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1b0fb77
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x1b719ba
movq %r14, %rdi
movq %rax, %rsi
callq 0x1b182dc
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x1b8d126
movq %rax, 0x8(%rbx)
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbl %ecx, %ecx
movl %ecx, %eax
add... | /External/isl/isl_union_map.c |
plain_injective_on_range | static isl_bool plain_injective_on_range(__isl_take isl_union_map *umap,
int first, int n_range)
{
isl_ctx *ctx;
isl_size n;
struct isl_fixed_dim_data data = { NULL };
ctx = isl_union_map_get_ctx(umap);
n = isl_union_map_n_map(umap);
if (n < 0)
goto error;
if (n <= 1) {
isl_union_map_free(umap);
return... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqa %xmm0, 0x20(%rsp)
testq %rdi, %rdi
je 0x1b9139c
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
jmp 0x1b9139e
xorl %edi, %edi
movl $0xffffffff, %ebp # imm = 0xFFF... | /External/isl/isl_union_map.c |
free_isl_fixed_map_array | static void free_isl_fixed_map_array(struct isl_fixed_map *v, int n)
{
int i;
if (!v)
return;
for (i = 0; i < n; ++i)
isl_int_clear(v[i].v);
free(v);
} | testq %rdi, %rdi
je 0x1b91849
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x1b9183c
movl %esi, %r14d
shlq $0x4, %r14
xorl %r15d, %r15d
movq (%rbx,%r15), %rdi
testb $0x1, %dil
jne 0x1b91833
callq 0x1b9b0de
addq $0x10, %r15
cmpq %r15, %r14
jne 0x1b91824
movq %rbx, %rdi
popq %rbx
popq %r14
popq %... | /External/isl/isl_union_map.c |
isl_val_neg | __isl_give isl_val *isl_val_neg(__isl_take isl_val *v)
{
if (!v)
return NULL;
if (isl_val_is_nan(v))
return v;
if (isl_val_is_zero(v))
return v;
v = isl_val_cow(v);
if (!v)
return NULL;
isl_int_neg(v->n, v->n);
return v;
} | pushq %rbx
testq %rdi, %rdi
je 0x1b936ac
movq %rdi, %rbx
callq 0x1b92c5c
testl %eax, %eax
jne 0x1b936ae
movq %rbx, %rdi
callq 0x1b936ce
testl %eax, %eax
jne 0x1b936ae
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x1b93692
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1b93059
movq %rax, %rbx
testq %rbx, %rbx
je 0x1b936ac
... | /External/isl/isl_val.c |
isl_val_mul | __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1, __isl_take isl_val *v2)
{
if (!v1 || !v2)
goto error;
if (isl_val_is_nan(v1)) {
isl_val_free(v2);
return v1;
}
if (isl_val_is_nan(v2)) {
isl_val_free(v1);
return v2;
}
if ((!isl_val_is_rat(v1) && isl_val_is_zero(v2)) ||
(isl_val_is_zero(v1) &&... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x1b9458b
movq %rbx, %rdi
callq 0x1b92c5c
testl %eax, %eax
je 0x1b9441d
movq %r14, %rdi
callq 0x1b91ce4
jmp 0x1b9459d
movq %r14, %rdi
callq 0x1b92c5c
testl %eax, %eax
je 0x1b94439
movq %... | /External/isl/isl_val.c |
isl_val_div_ui | __isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1, unsigned long v2)
{
if (!v1)
return NULL;
if (isl_val_is_nan(v1))
return v1;
if (v2 == 0)
return isl_val_set_nan(v1);
if (v2 == 1)
return v1;
if (isl_val_is_zero(v1))
return v1;
if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1))
return v1;
... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b94837
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1b92c5c
testl %eax, %eax
jne 0x1b94839
cmpq $0x1, %r14
je 0x1b94839
testq %r14, %r14
jne 0x1b947d9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1b92bf8
movq %rbx, %rdi
callq 0x1b936ce
testl %eax, %eax
jne... | /External/isl/isl_val.c |
isl_val_zero_on_domain | __isl_give isl_val *isl_val_zero_on_domain(__isl_take isl_local_space *ls)
{
isl_ctx *ctx;
if (!ls)
return NULL;
ctx = isl_local_space_get_ctx(ls);
isl_local_space_free(ls);
return isl_val_zero(ctx);
} | testq %rdi, %rdi
je 0x1b95c15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1b0bc28
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b0bd46
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1b92b15
xorl %eax, %eax
retq
| /External/isl/isl_val.c |
isl_multi_val_dup | __isl_give MULTI(BASE) *FN(MULTI(BASE),dup)(__isl_keep MULTI(BASE) *multi)
{
int i;
MULTI(BASE) *dup;
if (!multi)
return NULL;
dup = FN(MULTI(BASE),alloc)(isl_space_copy(multi->space));
if (!dup)
return NULL;
for (i = 0; i < multi->n; ++i)
dup = FN(FN(MULTI(BASE),set),BASE)(dup, i,
FN(EL,copy)(... | testq %rdi, %rdi
je 0x1b95d2f
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1b95c75
testq %rax, %rax
je 0x1b95d32
cmpl $0x0, 0x10(%rbx)
jle 0x1b95d34
xorl %r14d, %r14d
movq 0x18(%rbx,%r14,8), %rdx
testq %rdx, %rdx
je 0x1b95d14
incl (%rdx)
jmp 0x1b95d16
xor... | /External/isl/isl_multi_templ.c |
isl_vec_insert_els | __isl_give isl_vec *isl_vec_insert_els(__isl_take isl_vec *vec,
unsigned pos, unsigned n)
{
isl_vec *ext = NULL;
if (n == 0)
return vec;
if (!vec)
return NULL;
if (pos > vec->size)
isl_die(vec->ctx, isl_error_invalid,
"position out of bounds", goto error);
ext = isl_vec_alloc(vec->ctx, vec->size + n)... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %edx, %edx
je 0x1b98bcf
testq %rbx, %rbx
je 0x1b98b78
movl %esi, %ebp
movl 0x10(%rbx), %esi
movq 0x8(%rbx), %rdi
cmpl %ebp, %esi
jae 0x1b98b7c
leaq 0x33732ed(%rip), %rdx # 0x4f0be4c
leaq 0x337a0ed(%rip), %rcx # 0x4f12c53
movl $0x5, %esi
mo... | /External/isl/isl_vec.c |
isl_vec_move_els | __isl_give isl_vec *isl_vec_move_els(__isl_take isl_vec *vec,
unsigned dst_pos, unsigned src_pos, unsigned n)
{
isl_vec *res;
if (!vec)
return NULL;
if (src_pos + n > vec->size)
isl_die(vec->ctx, isl_error_invalid,
"source range out of bounds", return isl_vec_free(vec));
if (dst_pos + n > vec->size)
isl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1b98c6c
movl %ecx, %r15d
movl %edx, %r13d
movl %esi, %r12d
movq %rdi, %rbx
leal (%r15,%r13), %ebp
movl 0x10(%rdi), %esi
cmpl %esi, %ebp
jbe 0x1b98c70
movq 0x8(%rbx), %rdi
leaq 0x337a076(%rip), %rdx # 0x4f12cce
lea... | /External/isl/isl_vec.c |
isl_multi_id_dump | void FN(TYPE,dump)(__isl_keep TYPE *obj)
{
isl_printer *p;
if (!obj)
return;
p = isl_printer_to_file(FN(TYPE,get_ctx)(obj), stderr);
p = isl_printer_set_dump(p, PRINT_DUMP_DEFAULT);
p = FN(isl_printer_print,BASE)(p, obj);
p = isl_printer_end_line(p);
isl_printer_free(p);
} | testq %rdi, %rdi
je 0x1b9900b
pushq %rbx
movq %rdi, %rbx
callq 0x1aff44b
movq 0x3d62a41(%rip), %rcx # 0x58fba18
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x1b5095c
movq %rax, %rdi
movl $0x1, %esi
callq 0x1b50d30
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b3bc98
movq %rax, %rdi
callq 0x1b50f6d
movq %rax, %rdi
popq %rbx
jm... | /External/isl/print_templ.c |
isl_val_to_str | __isl_give char *FN(TYPE,to_str)(__isl_keep TYPE *obj)
{
isl_printer *p;
char *s;
if (!obj)
return NULL;
p = isl_printer_to_str(FN(TYPE,get_ctx)(obj));
p = FN(isl_printer_print,BASE)(p, obj);
s = isl_printer_get_str(p);
isl_printer_free(p);
return s;
} | testq %rdi, %rdi
je 0x1b990e3
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1b925e5
movq %rax, %rdi
callq 0x1b509c3
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b92795
movq %rax, %rbx
movq %rax, %rdi
callq 0x1b50f7c
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b50a57
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r... | /External/isl/print_templ.c |
isl_union_pw_multi_aff_to_str | __isl_give char *FN(TYPE,to_str)(__isl_keep TYPE *obj)
{
isl_printer *p;
char *s;
if (!obj)
return NULL;
p = isl_printer_to_str(FN(TYPE,get_ctx)(obj));
p = FN(isl_printer_print,BASE)(p, obj);
s = isl_printer_get_str(p);
isl_printer_free(p);
return s;
} | testq %rdi, %rdi
je 0x1b99cdd
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1ab0f1c
movq %rax, %rdi
callq 0x1b509c3
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b3b9d4
movq %rax, %rbx
movq %rax, %rdi
callq 0x1b50f7c
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b50a57
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r... | /External/isl/print_templ.c |
impz_fdiv_q | void GMPZAPI(fdiv_q)(mp_int q, mp_int n, mp_int d) {
mpz_t rz;
mp_int r = &rz;
int qsign, rsign, nsign, dsign;
CHECK(mp_int_init(r));
/* save signs before division because q can alias with n or d */
nsign = mp_int_compare_zero(n);
dsign = mp_int_compare_zero(d);
/* truncating division */
CHECK(mp_in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x1b9adba
movq %r12, %rdi
callq 0x1b9b8ab
movl %eax, %ebp
movq %r15, %rdi
callq 0x1b9b8ab
movl %eax, %r14d
movq %r12, %rdi
movq %r15, %rsi
movq %r... | /External/isl/imath/gmp_compat.c |
impz_fdiv_r | void GMPZAPI(fdiv_r)(mp_int r, mp_int n, mp_int d) {
mpz_t qz;
mpz_t tempz;
mpz_t orig_dz;
mpz_t orig_nz;
mp_int q = &qz;
mp_int temp = &tempz;
mp_int orig_d = &orig_dz;
mp_int orig_n = &orig_nz;
CHECK(mp_int_init(q));
CHECK(mp_int_init(temp));
/* Make a copy of n in case n and d in case they over... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, (%rsp)
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0x1b9adba
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x1b9adba
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0x1b9ae8e
leaq 0x8(... | /External/isl/imath/gmp_compat.c |
s_rat_reduce | static mp_result s_rat_reduce(mp_rat r) {
mpz_t gcd;
mp_result res = MP_OK;
if (mp_int_compare_zero(MP_NUMER_P(r)) == 0) {
mp_int_set_value(MP_DENOM_P(r), 1);
return MP_OK;
}
/* If the greatest common divisor of the numerator and denominator is greater
than 1, divide it out. */
if ((res = mp_... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x1b9b8ab
testl %eax, %eax
je 0x1b9f777
leaq 0x8(%rsp), %rdi
callq 0x1b9adba
movl %eax, %ebp
leaq 0x337364a(%rip), %rax # 0x4f12d38
movl (%rax), %r15d
cmpl %r15d, %ebp
jne 0x1b9f7b5
leaq 0x20(%rbx), %r14
leaq 0x8(%rsp), %rdx
movq %rbx,... | /External/isl/imath/imrat.c |
s_rat_combine | static mp_result s_rat_combine(mp_rat a, mp_rat b, mp_rat c,
mp_result (*comb_f)(mp_int, mp_int, mp_int)) {
mp_result res;
/* Shortcut when denominators are already common */
if (mp_int_compare(MP_DENOM_P(a), MP_DENOM_P(b)) == 0) {
if ((res = (comb_f)(MP_NUMER_P(a), MP_NUMER_P(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
leaq 0x20(%rdi), %r12
leaq 0x20(%rsi), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x1b9d158
testl %eax, %eax
je 0x1b9fb64
movq %rbx, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %r1... | /External/isl/imath/imrat.c |
add_prefix | static int add_prefix(struct isl_prefixes *prefixes, const char *prefix)
{
int n = prefixes->n;
if (!prefix)
return n;
if (prefixes->n >= 10) {
fprintf(stderr, "too many prefixes\n");
exit(EXIT_FAILURE);
}
prefixes->len[prefixes->n] = strlen(prefix);
prefixes->prefix[prefixes->n] = prefix;
prefixes->n++;... | pushq %r15
pushq %r14
pushq %rbx
movslq (%rdi), %rbx
testq %rsi, %rsi
je 0x1ba36d3
cmpl $0xa, %ebx
jge 0x1ba36db
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7802c0
movq %rax, 0x58(%r14,%rbx,8)
movq %r15, 0x8(%r14,%rbx,8)
leal 0x1(%rbx), %eax
movl %eax, (%r14)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
re... | /External/isl/isl_arg.c |
factor_first_vertex | static int factor_first_vertex(struct isl_coefficients_factor_data *factor,
int start)
{
int j;
int n = factor->n_ray + factor->n_vertex;
for (j = start; j < n; ++j) {
if (is_ray(factor->coeff, j))
continue;
factor->pos = j;
return 1;
}
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x18(%rdi), %r15d
addl 0x14(%rdi), %r15d
xorl %ebx, %ebx
cmpl %esi, %r15d
jle 0x1ba61cf
movl %esi, %ebp
movq %rdi, %r14
movq (%r14), %rdi
movl %ebp, %esi
callq 0x1ba6156
testl %eax, %eax
je 0x1ba61c6
incl %ebp
cmpl %ebp, %r15d
jne 0x1ba61af
jmp 0x1ba61cf
movl ... | /External/isl/isl_farkas.c |
isl_pw_qpolynomial_fold_list_free | __isl_null LIST(EL) *FN(LIST(EL),free)(__isl_take LIST(EL) *list)
{
int i;
if (!list)
return NULL;
if (--list->ref > 0)
return NULL;
isl_ctx_deref(list->ctx);
for (i = 0; i < list->n; ++i)
FN(EL,free)(list->p[i]);
free(list);
return NULL;
} | testq %rdi, %rdi
je 0x1ba654b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rdi)
cmpl $0x1, %eax
jg 0x1ba6544
movq 0x8(%rbx), %rdi
callq 0x1af85c7
cmpl $0x0, 0x10(%rbx)
jle 0x1ba653c
xorl %r14d, %r14d
movq 0x20(%rbx,%r14,8), %rdi
callq 0x1ba649c
incq %r14
movslq 0... | /External/isl/isl_list_templ.c |
isl_pw_qpolynomial_fold_dup | __isl_give PW *FN(PW,dup)(__isl_keep PW *pw)
{
int i;
PW *dup;
if (!pw)
return NULL;
dup = FN(PW,alloc_size)(isl_space_copy(pw->dim)
OPT_TYPE_ARG(pw->), pw->n);
if (!dup)
return NULL;
for (i = 0; i < pw->n; ++i)
dup = FN(PW,add_dup_piece)(dup, isl_set_copy(pw->p[i].set),
FN(EL,copy)(pw->p[i]... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1ba7f85
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1b6fd4e
movl 0x4(%rbx), %esi
movl 0x10(%rbx), %edx
movq %rax, %rdi
callq 0x1ba7c15
testq %rax, %rax
je 0x1ba7f85
movq %rax, %r14
cmpl $0x0, 0x10(%rbx)
jle 0x1ba7f88
leaq 0x28(%rbx), %r15
xor... | /External/isl/isl_pw_templ.c |
isl_pw_qpolynomial_fold_align_params_bin | isl_stat FN(FN(ARG1,align_params),SUFFIX)(__isl_keep ARG1 **obj1,
__isl_keep ARG2 **obj2)
{
isl_space *space1, *space2;
isl_bool equal_params;
space1 = FN(ARG1,peek_space)(*obj1);
space2 = FN(ARG2,peek_space)(*obj2);
equal_params = isl_space_has_equal_params(space1, space2);
if (equal_params < 0)
goto error;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x1ba9fbe
movq 0x8(%rax), %rdi
jmp 0x1ba9fc0
xorl %edi, %edi
movq (%rbx), %rax
testq %rax, %rax
je 0x1ba9fce
movq 0x8(%rax), %rsi
jmp 0x1ba9fd0
xorl %esi, %esi
callq 0x1b70e21
testl %eax, %eax
js... | /External/isl/isl_align_params_templ.c |
isl_pw_qpolynomial_fold_grow | static __isl_give PW *FN(PW,grow)(__isl_take PW *pw, int n)
{
int i;
isl_ctx *ctx;
PW *res;
if (!pw)
return NULL;
if (pw->n + n <= pw->size)
return pw;
ctx = FN(PW,get_ctx)(pw);
n += pw->n;
if (pw->ref == 1) {
res = isl_realloc(ctx, pw, struct PW,
sizeof(struct PW) + (n - 1) * sizeof(S(PW,piece)))... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1baa179
movq %rdi, %rbx
movslq 0x10(%rdi), %rax
movslq %esi, %r15
addq %r15, %rax
cmpq %rax, 0x18(%rdi)
jae 0x1baa17b
movq 0x8(%rbx), %rdi
callq 0x1b6f814
movslq 0x10(%rbx), %r14
addq %r15, %r14
cmpl $0x1, (%rbx)
jne 0x1baa103
movq %r14, %rdx
... | /External/isl/isl_pw_add_disjoint_templ.c |
map_apply | static isl_stat map_apply(__isl_take isl_map *map, void *user)
{
struct isl_apply_fold_data *data = user;
isl_stat r;
data->map = map;
r = isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
data->upwf, &pw_qpolynomial_fold_apply, data);
isl_map_free(map);
return r;
} | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rdi, 0x10(%rsi)
movq (%rsi), %rsi
leaq 0xb6f(%rip), %rcx # 0x1bae6e8
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rsi, %rsi
je 0x1badba9
movq 0x8(%rsi), %rax
movq 0x8(%rax), %rdi
addq $0x10, %rsi
leaq -0x29be(%rip), %rdx # 0x1ba... | /External/isl/isl_fold.c |
isl_schedule_band_point | __isl_give isl_schedule_band *isl_schedule_band_point(
__isl_take isl_schedule_band *band, __isl_keep isl_schedule_band *tile,
__isl_take isl_multi_val *sizes)
{
isl_ctx *ctx;
isl_multi_union_pw_aff *scaled;
if (!band || !sizes)
goto error;
ctx = isl_schedule_band_get_ctx(band);
if (!isl_options_get_tile_shi... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x1bb14cf
movq %rsi, %r12
movq 0x18(%rbx), %rdi
callq 0x1acc633
movq %rax, %r15
movq %rax, %rdi
callq 0x1b3902d
testl %eax, %eax
je 0x1bb14c3
movl (%rbx), %eax
cmpl... | /External/isl/isl_schedule_band.c |
isl_schedule_band_align_params | __isl_give isl_schedule_band *isl_schedule_band_align_params(
__isl_take isl_schedule_band *band, __isl_take isl_space *space)
{
band = isl_schedule_band_cow(band);
if (!band || !space)
goto error;
band->mupa = isl_multi_union_pw_aff_align_params(band->mupa,
isl_space_copy(space));
band->ast_build_options... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x1bb1702
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1bb1704
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1bb0500
movq %rax, %rbx
jmp 0x1bb1704
xorl %ebx, %ebx
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x1... | /External/isl/isl_schedule_band.c |
isl_schedule_band_pullback_union_pw_multi_aff | __isl_give isl_schedule_band *isl_schedule_band_pullback_union_pw_multi_aff(
__isl_take isl_schedule_band *band,
__isl_take isl_union_pw_multi_aff *upma)
{
band = isl_schedule_band_cow(band);
if (!band || !upma)
goto error;
band->mupa =
isl_multi_union_pw_aff_pullback_union_pw_multi_aff(band->mupa,
u... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdi, %rdi
je 0x1bb1797
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1bb1799
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1bb0500
movq %rax, %rbx
jmp 0x1bb1799
xorl %ebx, %ebx
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x1... | /External/isl/isl_schedule_band.c |
is_isolate | static isl_bool is_isolate(__isl_keep isl_set *set)
{
if (isl_set_has_tuple_name(set)) {
const char *name;
name = isl_set_get_tuple_name(set);
if (isl_set_is_wrapping(set) && !strcmp(name, "isolate"))
return isl_bool_true;
}
return isl_bool_false;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x1b10116
xorl %ebx, %ebx
testl %eax, %eax
je 0x1bb190c
movq %r14, %rdi
callq 0x1b10145
movq %rax, %r15
movq %r14, %rdi
callq 0x1b20c45
testl %eax, %eax
je 0x1bb190c
leaq 0x33b80a4(%rip), %rsi # 0x4f6999f
movq %r15, %rdi
callq 0x780dc0
testl %eax, %eax
jne 0x1bb1... | /External/isl/isl_schedule_band.c |
llvm::PassBuilder::parseModulePassPipeline(llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>&, llvm::ArrayRef<llvm::PassBuilder::PipelineElement>) | Error PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
ArrayRef<PipelineElement> Pipeline) {
for (const auto &Element : Pipeline) {
if (auto Err = parseModulePass(MPM, Element))
return Err;
}
return Error::success();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %r8, %r8
sete %bpl
je 0x1bc109b
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rbx, %rdi
callq 0x1bb78fa
cmpq $0x0, (%rbx)
jne 0x1bc1096
addq $0x28, %r14
leaq (,%r13,4), %rax
addq %r13, %rax
leaq -0x... | /Passes/PassBuilder.cpp |
std::enable_if<!std::is_same_v<llvm::ModuleInlinerPass, llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>>, void>::type llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::addPass<llvm::ModuleInlinerPass>(llvm::ModuleInlinerPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x60
popq %rdi
callq 0x7808d0
movq (%rbx), %rdx
andq $0x0, (%rbx)
addq $0x8, %rbx
leaq 0x10(%rax), %rdi
pushq $0x4c
popq %rcx
movq %rbx, %rsi
rep movsb (%rsi), %es:(%rdi)
leaq 0x3cbec8a(%rip), %rcx # 0x5881650
addq $0x10, %rcx
movq %rcx, (%rax)
... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::NoOpModulePass, llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>>, void>::type llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::addPass<llvm::NoOpModulePass>(llvm::NoOpModulePass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7808d0
leaq 0x3cbec7e(%rip), %rcx # 0x58816d0
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x807990
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bc2a78
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::InlineAdvisorAnalysisPrinterPass, llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>>, void>::type llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::addPass<llvm::InlineAdvisorAnalysisPrinterPass>(llvm::InlineAdvisorAnalysisPrinterPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x7808d0
movq (%rbx), %rcx
leaq 0x3cbeb50(%rip), %rdx # 0x5881b10
addq $0x10, %rdx
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %rsp, %rbx
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x807990
movq (%rbx), %rdi
test... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::SampleProfileProbePass, llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>>, void>::type llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::addPass<llvm::SampleProfileProbePass>(llvm::SampleProfileProbePass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x7808d0
movq (%rbx), %rcx
leaq 0x3cbea7e(%rip), %rdx # 0x5881b90
addq $0x10, %rdx
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %rsp, %rbx
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x807990
movq (%rbx), %rdi
test... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::StripNonDebugSymbolsPass, llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>>, void>::type llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::addPass<llvm::StripNonDebugSymbolsPass>(llvm::StripNonDebugSymbolsPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7808d0
leaq 0x3cbe810(%rip), %rcx # 0x5881ed0
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x807990
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bc36e6
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::MemProfUsePass, llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>>, void>::type llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::addPass<llvm::MemProfUsePass>(llvm::MemProfUsePass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x30
popq %rdi
callq 0x7808d0
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1c088f4
movq %r15, %rdi
movq %r12, %rsi
callq 0x1c0893c
leaq 0x8(%rsp), %rbx
movq %r15, (%rbx)
movq %r14, %rdi
m... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::StructuralHashPrinterPass, llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>>, void>::type llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>::addPass<llvm::StructuralHashPrinterPass>(llvm::StructuralHashPrinterPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x7808d0
movq (%rbx), %rcx
movb 0x8(%rbx), %dl
leaq 0x3cbd1cd(%rip), %rsi # 0x5882310
addq $0x10, %rsi
movq %rsi, (%rax)
movq %rcx, 0x8(%rax)
movb %dl, 0x10(%rax)
movq %rsp, %rbx
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %... | /llvm/IR/PassManager.h |
llvm::ModuleToFunctionPassAdaptor llvm::createModuleToFunctionPassAdaptor<llvm::NaryReassociatePass>(llvm::NaryReassociatePass&&, bool) | ModuleToFunctionPassAdaptor
createModuleToFunctionPassAdaptor(FunctionPassT &&Pass,
bool EagerlyInvalidate = false) {
using PassModelT =
detail::PassModel<Function, FunctionPassT, FunctionAnalysisManager>;
// Do not use make_unique, it causes too many template instantiations,... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x50, %edi
callq 0x7808d0
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
leaq 0x30(%rsp), %r14
movaps %xmm0, -0x30(%r14)
movaps %xmm1, -0x20(%r14)
movaps %xmm2, -0x10(%r14)
xorps %x... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::InvalidateAnalysisPass<llvm::BasicBlockSectionsProfileReaderAnalysis>, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::InvalidateAnalysisPass<llvm::BasicBlo... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7808d0
leaq 0x3cacf8a(%rip), %rcx # 0x58852d0
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xadff9e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bd836c
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::InvalidateAnalysisPass<llvm::BranchProbabilityAnalysis>, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::InvalidateAnalysisPass<llvm::BranchProbabilityAnaly... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7808d0
leaq 0x3cacf7a(%rip), %rcx # 0x58853d0
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xadff9e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bd847c
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::RequireAnalysisPass<llvm::DebugAssignmentTrackingAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function>>, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7808d0
leaq 0x3cacf66(%rip), %rcx # 0x5885510
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xadff9e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bd85d0
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::InvalidateAnalysisPass<llvm::DebugAssignmentTrackingAnalysis>, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::InvalidateAnalysisPass<llvm::DebugAssignmentT... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7808d0
leaq 0x3cacf62(%rip), %rcx # 0x5885550
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xadff9e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bd8614
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::LowerExpectIntrinsicPass, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::LowerExpectIntrinsicPass>(llvm::LowerExpectIntrinsicPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7808d0
leaq 0x3ca8c8a(%rip), %rcx # 0x5883490
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xadff9e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bda82c
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::ScalarizerPass, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::ScalarizerPass>(llvm::ScalarizerPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x7808d0
movq (%rbx), %rcx
movb 0x8(%rbx), %dl
leaq 0x3ca8a43(%rip), %rsi # 0x58840d0
addq $0x10, %rsi
movq %rsi, (%rax)
movq %rcx, 0x8(%rax)
movb %dl, 0x10(%rax)
movq %rsp, %rbx
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::SinkingPass, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::SinkingPass>(llvm::SinkingPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7808d0
leaq 0x3ca8a28(%rip), %rcx # 0x5884190
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xadff9e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bdb78e
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::LoopVerifierPass, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::LoopVerifierPass>(llvm::LoopVerifierPass&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7808d0
leaq 0x3ca897e(%rip), %rcx # 0x5884510
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xadff9e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bdbbb8
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<(anonymous namespace)::RequireAllMachineFunctionPropertiesPass, llvm::PassManager<llvm::MachineFunction, llvm::AnalysisManager<llvm::MachineFunction>>>, void>::type llvm::PassManager<llvm::MachineFunction, llvm::AnalysisManager<llvm::MachineFunction>>::addPass<(anonymous namespace)::Requi... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7808d0
leaq 0x3ca7a06(%rip), %rcx # 0x5886f60
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xae35ac
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bdf57c
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, ... | /llvm/IR/PassManager.h |
void llvm::StringMapEntry<std::unique_ptr<llvm::GCStrategy, std::default_delete<llvm::GCStrategy>>>::Destroy<llvm::MallocAllocator>(llvm::MallocAllocator&) | void Destroy(AllocatorTy &allocator) {
// Free memory referenced by the item.
size_t AllocSize = sizeof(StringMapEntry) + this->getKeyLength() + 1;
this->~StringMapEntry();
allocator.Deallocate(static_cast<void *>(this), AllocSize,
alignof(StringMapEntry));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1bf823f
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x11, %r14
movq $0x0, 0x8(%rbx)
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b410f1
| /llvm/ADT/StringMapEntry.h |
llvm::detail::AnalysisPassModel<llvm::Function, llvm::DependenceAnalysis, llvm::AnalysisManager<llvm::Function>::Invalidator>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | std::unique_ptr<AnalysisResultConcept<IRUnitT, InvalidatorT>>
run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
ExtraArgTs... ExtraArgs) override {
return std::make_unique<ResultModelT>(
Pass.run(IR, AM, std::forward<ExtraArgTs>(ExtraArgs)...));
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
addq $0x8, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x25bf898
movl $0x38, %edi
callq 0x7808d0
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm0, 0x8(%rax)
movups %xmm1, 0x18(%rax)
movups %xmm2, 0x28(%rax)
leaq 0x3c831ec(%rip... | /llvm/IR/PassManagerInternal.h |
llvm::detail::AnalysisPassModel<llvm::Function, llvm::MemoryDependenceAnalysis, llvm::AnalysisManager<llvm::Function>::Invalidator>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | std::unique_ptr<AnalysisResultConcept<IRUnitT, InvalidatorT>>
run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
ExtraArgTs... ExtraArgs) override {
return std::make_unique<ResultModelT>(
Pass.run(IR, AM, std::forward<ExtraArgTs>(ExtraArgs)...));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x3b8, %rsp # imm = 0x3B8
movq %rdi, %rbx
addq $0x8, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2656316
movl $0x1e0, %edi # imm = 0x1E0
callq 0x7808d0
movq %rax, %r15
leaq 0x1e0(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1bfe072
lea... | /llvm/IR/PassManagerInternal.h |
llvm::detail::AnalysisPassModel<llvm::Function, llvm::BasicAA, llvm::AnalysisManager<llvm::Function>::Invalidator>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | std::unique_ptr<AnalysisResultConcept<IRUnitT, InvalidatorT>>
run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
ExtraArgTs... ExtraArgs) override {
return std::make_unique<ResultModelT>(
Pass.run(IR, AM, std::forward<ExtraArgTs>(ExtraArgs)...));
} | pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
addq $0x8, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x257d170
movl $0xd0, %edi
callq 0x7808d0
movq (%r14), %rcx
movq 0x8(%r14), %rdx
leaq 0x118(%rsp), %rsi
movq %rcx, -0x48(%rsi)
movq %rdx, -0x40(%rsi)
movq 0x10(%r14), %rdi
movq %rd... | /llvm/IR/PassManagerInternal.h |
llvm::detail::AnalysisPassModel<llvm::MachineFunction, llvm::MachineLoopAnalysis, llvm::AnalysisManager<llvm::MachineFunction>::Invalidator>::run(llvm::MachineFunction&, llvm::AnalysisManager<llvm::MachineFunction>&) | std::unique_ptr<AnalysisResultConcept<IRUnitT, InvalidatorT>>
run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
ExtraArgTs... ExtraArgs) override {
return std::make_unique<ResultModelT>(
Pass.run(IR, AM, std::forward<ExtraArgTs>(ExtraArgs)...));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %rbx
addq $0x8, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1d4ed98
movl $0x98, %edi
callq 0x7808d0
movq %rax, %r15
leaq 0x98(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1d4de5e
leaq 0x3c7e781(%rip), %rax #... | /llvm/IR/PassManagerInternal.h |
llvm::DenseMap<llvm::AnalysisKey*, std::unique_ptr<llvm::detail::AnalysisPassConcept<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>::Invalidator, llvm::LoopStandardAnalysisResults&>, std::default_delete<llvm::detail::AnalysisPassConcept<llvm::Loop, llvm::AnalysisManager<llvm::Loop, ll... | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::ilist_alloc_traits<llvm::IVStrideUse>::deleteNode(llvm::IVStrideUse*) | static void deleteNode(NodeTy *V) { delete V; } | testq %rdi, %rdi
je 0x1c02cba
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
cmpq 0x50(%rbx), %rdi
je 0x1c02c68
callq 0x780910
movq 0x48(%rbx), %rax
cmpq $-0x2000, %rax # imm = 0xE000
je 0x1c02c8a
cmpq $-0x1000, %rax # imm = 0xF000
je 0x1c02c8a
testq %rax, %rax
je 0x1c02c8a
leaq 0x38(%rbx), %rdi
cal... | /llvm/ADT/ilist.h |
llvm::detail::AnalysisResultModel<llvm::Loop, llvm::ShouldRunExtraSimpleLoopUnswitch, llvm::ShouldRunExtraSimpleLoopUnswitch::Result, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>::Invalidator, true>::invalidate(llvm::Loop&, llvm::PreservedAnalyses const&, llvm::AnalysisManager<llvm::Loop, llvm:... | bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA,
InvalidatorT &Inv) override {
return Result.invalidate(IR, PA, Inv);
} | pushq %rbx
movq %rdx, %rbx
leaq 0x30(%rdx), %rdi
leaq 0x3d7c707(%rip), %rsi # 0x597f508
callq 0x90b7be
movq 0x38(%rbx), %rcx
xorl %edx, %edx
cmpq 0x30(%rbx), %rcx
sete %dl
movl 0x40(%rbx,%rdx,4), %edx
leaq (%rcx,%rdx,8), %rcx
cmpq %rcx, %rax
setne %al
popq %rbx
retq
nop
| /llvm/IR/PassManagerInternal.h |
llvm::InvalidateAnalysisPass<llvm::CollectorMetadataAnalysis>::printPipeline(llvm::raw_ostream&, llvm::function_ref<llvm::StringRef (llvm::StringRef)>) | void printPipeline(raw_ostream &OS,
function_ref<StringRef(StringRef)> MapClassName2PassName) {
auto ClassName = AnalysisT::name();
auto PassName = MapClassName2PassName(ClassName);
OS << "invalidate<" << PassName << '>';
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0xade8b4
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
movq %rax, %rbx
movq %rdx, %r14
leaq 0x18814a0(%rip), %rsi # 0x3484d55
movl $0xb, %edx
movq %r15, %rdi
callq 0x7f9ba8
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7f9b... | /llvm/IR/PassManager.h |
llvm::RequireAnalysisPass<llvm::IRSimilarityAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module>>::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) | PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM,
ExtraArgTs &&... Args) {
(void)AM.template getResult<AnalysisT>(Arg,
std::forward<ExtraArgTs>(Args)...);
return PreservedAnalyses::all();
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x3d89069(%rip), %rsi # 0x598cd98
movq %rcx, %rdi
callq 0x2a8d498
leaq 0x20(%rbx), %rax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movl $0x2, %eax
movq %rax, 0x10(%rbx)
xorl %ecx, %ecx
movl %ecx, 0x18(%rbx)
leaq 0x50(%rbx), %rdx
movq %rdx, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
... | /llvm/IR/PassManager.h |
llvm::GraphWriter<llvm::PostDominatorTree*>::writeNode(llvm::DomTreeNodeBase<llvm::BasicBlock>*) | void writeNode(NodeRef Node) {
std::string NodeAttributes = DTraits.getNodeAttributes(Node, G);
O << "\tNode" << static_cast<const void *>(Node) << " [shape=";
if (RenderUsingHTML)
O << "none,";
else
O << "record,";
if (!NodeAttributes.empty()) O << NodeAttributes << ",";
O << "lab... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rdi), %rdi
leaq 0x232f881(%rip), %rsi # 0x3f3ba6c
movl $0x5, %edx
callq 0x7f9ba8
movq %rax, %rdi
movq %rbx, %rs... | /llvm/Support/GraphWriter.h |
llvm::GraphWriter<llvm::PostDominatorTree*>::writeEdge(llvm::DomTreeNodeBase<llvm::BasicBlock>*, unsigned int, llvm::DomTreeNodeBase<llvm::BasicBlock>* const*) | void writeEdge(NodeRef Node, unsigned edgeidx, child_iterator EI) {
if (NodeRef TargetNode = *EI) {
int DestPort = -1;
if (DTraits.edgeTargetsEdgeSource(Node, EI)) {
child_iterator TargetIt = DTraits.getEdgeTarget(Node, EI);
// Figure out which edge this targets...
unsigned Offs... | movq (%rcx), %rcx
testq %rcx, %rcx
je 0x1c0c67c
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x8(%rsp), %rbx
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
movq %rbx, %r9
callq 0x1c0c67e
... | /llvm/Support/GraphWriter.h |
llvm::SmallVectorImpl<llvm::AssertingVH<llvm::BasicBlock const>>::operator=(llvm::SmallVectorImpl<llvm::AssertingVH<llvm::BasicBlock const>>&&) | SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If the RHS isn't small, clear this vector and then steal its buffer.
if (!RHS.isSmall()) {
this->assignRemote(std::move(RHS));
return *this;
}
// If we already... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1c0d84c
movq %rsi, %r14
movq (%rsi), %rax
leaq 0x10(%rsi), %rcx
cmpq %rcx, %rax
je 0x1c0d7a6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c0d856
jmp 0x1c0d84c
movl 0x8(%r14), %r15d
movl 0x8(%rbx), %edi
cmpl %r15d, %edi
jae 0x1c0d7d5
cmpl %r15d, 0xc(%rbx)... | /llvm/ADT/SmallVector.h |
llvm::detail::PassModel<llvm::Loop, llvm::PrintLoopPass, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&>::~PassModel() | explicit PassModel(PassT Pass) : Pass(std::move(Pass)) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x3c72341(%rip), %rax # 0x5884dd0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x1c12aae
movq (%rax), %rsi
incq %rsi
callq 0x7800d0
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x7800d0
| /llvm/IR/PassManagerInternal.h |
llvm::InvalidateAnalysisPass<llvm::LoopAnalysis>::printPipeline(llvm::raw_ostream&, llvm::function_ref<llvm::StringRef (llvm::StringRef)>) | void printPipeline(raw_ostream &OS,
function_ref<StringRef(StringRef)> MapClassName2PassName) {
auto ClassName = AnalysisT::name();
auto PassName = MapClassName2PassName(ClassName);
OS << "invalidate<" << PassName << '>';
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x1bf0ab4
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
movq %rax, %rbx
movq %rdx, %r14
leaq 0x186db96(%rip), %rsi # 0x3484d55
movl $0xb, %edx
movq %r15, %rdi
callq 0x7f9ba8
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7f9... | /llvm/IR/PassManager.h |
llvm::RequireAnalysisPass<llvm::ShouldRunExtraVectorPasses, llvm::Function, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM,
ExtraArgTs &&... Args) {
(void)AM.template getResult<AnalysisT>(Arg,
std::forward<ExtraArgTs>(Args)...);
return PreservedAnalyses::all();
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x3d6993b(%rip), %rsi # 0x5982c80
movq %rcx, %rdi
callq 0x2a8ddb2
leaq 0x20(%rbx), %rax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movl $0x2, %eax
movq %rax, 0x10(%rbx)
xorl %ecx, %ecx
movl %ecx, 0x18(%rbx)
leaq 0x50(%rbx), %rdx
movq %rdx, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
... | /llvm/IR/PassManager.h |
llvm::RequireAnalysisPass<llvm::SSPLayoutAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM,
ExtraArgTs &&... Args) {
(void)AM.template getResult<AnalysisT>(Arg,
std::forward<ExtraArgTs>(Args)...);
return PreservedAnalyses::all();
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x3d3edb3(%rip), %rsi # 0x5958450
movq %rcx, %rdi
callq 0x2a8ddb2
leaq 0x20(%rbx), %rax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movl $0x2, %eax
movq %rax, 0x10(%rbx)
xorl %ecx, %ecx
movl %ecx, 0x18(%rbx)
leaq 0x50(%rbx), %rdx
movq %rdx, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
... | /llvm/IR/PassManager.h |
llvm::RequireAnalysisPass<llvm::TargetIRAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function>>::printPipeline(llvm::raw_ostream&, llvm::function_ref<llvm::StringRef (llvm::StringRef)>) | void printPipeline(raw_ostream &OS,
function_ref<StringRef(StringRef)> MapClassName2PassName) {
auto ClassName = AnalysisT::name();
auto PassName = MapClassName2PassName(ClassName);
OS << "require<" << PassName << '>';
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x1bf1286
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
movq %rax, %rbx
movq %rdx, %r14
leaq 0x18692cf(%rip), %rsi # 0x3483096
movl $0x8, %edx
movq %r15, %rdi
callq 0x7f9ba8
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7f9... | /llvm/IR/PassManager.h |
llvm::InvalidateAnalysisPass<llvm::BasicAA>::printPipeline(llvm::raw_ostream&, llvm::function_ref<llvm::StringRef (llvm::StringRef)>) | void printPipeline(raw_ostream &OS,
function_ref<StringRef(StringRef)> MapClassName2PassName) {
auto ClassName = AnalysisT::name();
auto PassName = MapClassName2PassName(ClassName);
OS << "invalidate<" << PassName << '>';
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x1bf1320
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
movq %rax, %rbx
movq %rdx, %r14
leaq 0x186a31a(%rip), %rsi # 0x3484d55
movl $0xb, %edx
movq %r15, %rdi
callq 0x7f9ba8
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7f9... | /llvm/IR/PassManager.h |
llvm::InvalidateAnalysisPass<llvm::IVUsersAnalysis>::printPipeline(llvm::raw_ostream&, llvm::function_ref<llvm::StringRef (llvm::StringRef)>) | void printPipeline(raw_ostream &OS,
function_ref<StringRef(StringRef)> MapClassName2PassName) {
auto ClassName = AnalysisT::name();
auto PassName = MapClassName2PassName(ClassName);
OS << "invalidate<" << PassName << '>';
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x1bf69c0
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
movq %rax, %rbx
movq %rdx, %r14
leaq 0x1868be6(%rip), %rsi # 0x3484d55
movl $0xb, %edx
movq %r15, %rdi
callq 0x7f9ba8
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7f9... | /llvm/IR/PassManager.h |
llvm::RequireAnalysisPass<llvm::MachineLoopAnalysis, llvm::MachineFunction, llvm::AnalysisManager<llvm::MachineFunction>>::run(llvm::MachineFunction&, llvm::AnalysisManager<llvm::MachineFunction>&) | PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM,
ExtraArgTs &&... Args) {
(void)AM.template getResult<AnalysisT>(Arg,
std::forward<ExtraArgTs>(Args)...);
return PreservedAnalyses::all();
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x3d349ff(%rip), %rsi # 0x5952580
movq %rcx, %rdi
callq 0x1d58922
leaq 0x20(%rbx), %rax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movl $0x2, %eax
movq %rax, 0x10(%rbx)
xorl %ecx, %ecx
movl %ecx, 0x18(%rbx)
leaq 0x50(%rbx), %rdx
movq %rdx, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
... | /llvm/IR/PassManager.h |
llvm::RequireAnalysisPass<llvm::MachinePostDominatorTreeAnalysis, llvm::MachineFunction, llvm::AnalysisManager<llvm::MachineFunction>>::printPipeline(llvm::raw_ostream&, llvm::function_ref<llvm::StringRef (llvm::StringRef)>) | void printPipeline(raw_ostream &OS,
function_ref<StringRef(StringRef)> MapClassName2PassName) {
auto ClassName = AnalysisT::name();
auto PassName = MapClassName2PassName(ClassName);
OS << "require<" << PassName << '>';
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x1bf78ca
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
movq %rax, %rbx
movq %rdx, %r14
leaq 0x1864deb(%rip), %rsi # 0x3483096
movl $0x8, %edx
movq %r15, %rdi
callq 0x7f9ba8
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7f9... | /llvm/IR/PassManager.h |
llvm::RequireAnalysisPass<llvm::PassInstrumentationAnalysis, llvm::MachineFunction, llvm::AnalysisManager<llvm::MachineFunction>>::printPipeline(llvm::raw_ostream&, llvm::function_ref<llvm::StringRef (llvm::StringRef)>) | void printPipeline(raw_ostream &OS,
function_ref<StringRef(StringRef)> MapClassName2PassName) {
auto ClassName = AnalysisT::name();
auto PassName = MapClassName2PassName(ClassName);
OS << "require<" << PassName << '>';
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x1a02162
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
movq %rax, %rbx
movq %rdx, %r14
leaq 0x1864a93(%rip), %rsi # 0x3483096
movl $0x8, %edx
movq %r15, %rdi
callq 0x7f9ba8
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7f9... | /llvm/IR/PassManager.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.