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_intersect_domain(executed, domain);
empty = isl_map_is_empty(executed);
if (empty < 0)
goto error;
if (empty) {
isl_map_free(executed);
return isl_stat_ok;
}
sv = isl_map_plain_is_single_valued(executed);
if (sv < 0)
goto error;
if (sv)
return add_domain(executed, isl_map_copy(executed), data);
executed = isl_map_coalesce(executed);
map = isl_map_copy(executed);
map = isl_ast_build_compute_gist_map_domain(data->build, map);
sv = isl_map_is_single_valued(map);
if (sv < 0)
goto error;
if (!sv) {
isl_map_free(map);
if (data->build->single_valued)
map = isl_map_copy(executed);
else
return generate_non_single_valued(executed, data);
}
return add_domain(executed, map, data);
error:
isl_map_free(map);
isl_map_free(executed);
return isl_stat_error;
}
|
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
callq 0x1b0fdb2
jmp 0x1ae1eb6
movq %r14, %rdi
callq 0x1b20758
testl %eax, %eax
js 0x1ae1e40
je 0x1ae1e5a
movq %r14, %rdi
callq 0x1b10b80
movq %r14, %rdi
movq %rax, %rsi
jmp 0x1ae1eae
xorl %r15d, %r15d
movq %r15, %rdi
callq 0x1b0fdb2
movq %r14, %rdi
callq 0x1b0fdb2
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x1ae1eb8
movq %r14, %rdi
callq 0x1ae92c4
movq %rax, %r14
movq %rax, %rdi
callq 0x1b10b80
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x1ad7e0d
movq %rax, %r15
movq %rax, %rdi
callq 0x1b20781
testl %eax, %eax
js 0x1ae1e43
jne 0x1ae1ea8
movq %r15, %rdi
callq 0x1b0fdb2
movq (%rbx), %rax
cmpl $0x0, 0xd0(%rax)
je 0x1ae1ebe
movq %r14, %rdi
callq 0x1b10b80
movq %rax, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1ae2a1e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ae2b5b
jmp 0x1ae1eb6
|
/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(graft);
return NULL;
}
|
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--;
continue;
}
info[i].bmap = isl_basic_map_update_from_tab(info[i].bmap,
info[i].tab);
info[i].bmap = isl_basic_map_gauss(info[i].bmap, NULL);
if (info[i].simplify)
info[i].bmap = isl_basic_map_simplify(info[i].bmap);
info[i].bmap = isl_basic_map_finalize(info[i].bmap);
if (!info[i].bmap)
return isl_map_free(map);
if (!info[i].modified) {
ISL_F_SET(info[i].bmap, ISL_BASIC_MAP_NO_IMPLICIT);
ISL_F_SET(info[i].bmap, ISL_BASIC_MAP_NO_REDUNDANT);
}
isl_basic_map_free(map->p[i]);
map->p[i] = info[i].bmap;
info[i].bmap = NULL;
}
return map;
}
|
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 %eax, %rcx
movq 0x30(%rbx,%rcx,8), %rcx
movq %rcx, 0x30(%rbx,%r14,8)
decl %eax
movl %eax, 0x28(%rbx)
jmp 0x1ae964d
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq 0x1b7b911
movq %rax, (%r15)
movq %rax, %rdi
xorl %esi, %esi
callq 0x1b27ec7
movq %rax, (%r15)
cmpl $0x0, 0x1c(%r15)
je 0x1ae9619
movq %rax, %rdi
callq 0x1b28a4d
movq %rax, (%r15)
movq (%r15), %rdi
callq 0x1b2a464
movq %rax, (%r15)
testq %rax, %rax
je 0x1ae966b
cmpl $0x0, 0x14(%r15)
jne 0x1ae9634
orb $0xc, 0x4(%rax)
movq 0x30(%rbx,%r14,8), %rdi
callq 0x1b0fb02
movq (%r15), %rax
movq %rax, 0x30(%rbx,%r14,8)
movq $0x0, (%r15)
decq %r14
leaq 0x1(%r14), %rax
addq $-0x30, %r15
cmpq $0x1, %rax
jg 0x1ae95be
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1b0fdb2
|
/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_coalesce_bounded_wrapping(ctx);
if (!wraps->bound)
return isl_stat_ok;
isl_int_init(wraps->max);
isl_int_set_si(wraps->max, 0);
if (wraps_update_max(wraps, &info[i]) < 0)
return isl_stat_error;
if (wraps_update_max(wraps, &info[j]) < 0)
return isl_stat_error;
return isl_stat_ok;
}
|
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 0x1b3873d
movl %eax, 0x4(%r14)
testl %eax, %eax
je 0x1aeb67c
movq $0x1, 0x10(%r14)
movslq %r12d, %rax
leaq (%rax,%rax,2), %rsi
shlq $0x4, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x1aeb6ae
testl %eax, %eax
js 0x1aeb67e
movslq %r15d, %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1aeb6ae
movl %eax, %ebp
sarl $0x1f, %ebp
jmp 0x1aeb67e
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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;
isl_ctx_ref(ctx);
list->ref = 1;
list->size = n;
list->n = 0;
return list;
}
|
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(%rbx)
movl $0x0, 0x10(%rbx)
jmp 0x1aef099
leaq 0x341c123(%rip), %rdx # 0x4f0b1a0
leaq 0x341c142(%rip), %rcx # 0x4f0b1c6
movq %r14, %rdi
movl $0x5, %esi
movl $0x25, %r8d
callq 0x1af81bb
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
|
/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 (list->ref == 1 && list->size > list->n) {
for (i = list->n; i > pos; --i)
list->p[i] = list->p[i - 1];
list->n++;
list->p[pos] = el;
return list;
}
res = FN(LIST(EL),alloc)(ctx, list->n + 1);
for (i = 0; i < pos; ++i)
res = FN(LIST(EL),add)(res, FN(EL,copy)(list->p[i]));
res = FN(LIST(EL),add)(res, el);
for (i = pos; i < list->n; ++i)
res = FN(LIST(EL),add)(res, FN(EL,copy)(list->p[i]));
FN(LIST(EL),free)(list);
return res;
error:
FN(EL,free)(el);
FN(LIST(EL),free)(list);
return NULL;
}
|
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), %rcx # 0x4f0b1c6
movl $0x5, %esi
movl $0xd1, %r8d
callq 0x1af81bb
movq %r14, %rdi
callq 0x1aef248
movq %rbx, %rdi
callq 0x1aef27b
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, (%rbx)
jne 0x1aef45e
movslq %esi, %rax
cmpq %rax, 0x18(%rbx)
jbe 0x1aef45e
cmpl %ebp, %esi
jbe 0x1aef450
leaq (%rbx,%rax,8), %rcx
addq $0x20, %rcx
movl %esi, %eax
movq -0x8(%rcx), %rdx
movq %rdx, (%rcx)
addq $-0x8, %rcx
decl %eax
cmpl %ebp, %eax
ja 0x1aef43f
incl %esi
movl %esi, 0x10(%rbx)
movl %ebp, %eax
movq %r14, 0x20(%rbx,%rax,8)
jmp 0x1aef417
incl %esi
callq 0x1aef02d
testl %ebp, %ebp
je 0x1aef48f
movl %ebp, %r15d
xorl %r12d, %r12d
movq 0x20(%rbx,%r12,8), %rsi
testq %rsi, %rsi
je 0x1aef47d
incl (%rsi)
jmp 0x1aef47f
xorl %esi, %esi
movq %rax, %rdi
callq 0x1aef108
incq %r12
cmpq %r12, %r15
jne 0x1aef46f
movq %rax, %rdi
movq %r14, %rsi
callq 0x1aef108
movq %rax, %r14
cmpl %ebp, 0x10(%rbx)
jle 0x1aef4cc
movslq %ebp, %r15
movq 0x20(%rbx,%r15,8), %rsi
testq %rsi, %rsi
je 0x1aef4b3
incl (%rsi)
jmp 0x1aef4b5
xorl %esi, %esi
movq %r14, %rdi
callq 0x1aef108
movq %rax, %r14
incq %r15
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jl 0x1aef4a5
movq %rbx, %rdi
callq 0x1aef27b
movq %r14, %rbx
jmp 0x1aef417
|
/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 bounds",
return isl_stat_error);
return isl_stat_ok;
}
|
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 %cl
notb %cl
cmpl %eax, %r14d
setbe %al
xorl %ebp, %ebp
testb %al, %cl
jne 0x1af048b
testq %rbx, %rbx
je 0x1af0466
movq 0x8(%rbx), %rdi
callq 0x1b0bc28
movq %rax, %rdi
jmp 0x1af0468
xorl %edi, %edi
leaq 0x341eaf9(%rip), %rdx # 0x4f0ef68
leaq 0x341b899(%rip), %rcx # 0x4f0bd0f
movl $0x5, %esi
movl $0x12, %r8d
callq 0x1af81bb
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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);
total = isl_basic_map_dim(bmap, isl_dim_all);
if (total < 0)
return isl_bool_error;
for (i = 0; i < bmap->n_eq; ++i) {
if (isl_int_is_zero(bmap->eq[i][offset + pos]) ||
isl_seq_first_non_zero(bmap->eq[i]+offset+pos+1,
1+total-offset-pos-1) != -1)
continue;
if (c)
*c = isl_basic_map_constraint(isl_basic_map_copy(bmap),
&bmap->eq[i]);
return isl_bool_true;
}
return isl_bool_false;
}
|
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, %r13d
movq %r14, %rdi
movl $0x5, %esi
callq 0x1b0f1c0
testl %eax, %eax
js 0x1af0d26
cmpl $0x0, 0x1c(%r14)
je 0x1af0d23
movl %eax, %ebp
movq %rbx, 0x8(%rsp)
leal (%r15,%r13), %r12d
movl %r13d, %r13d
movslq %r15d, %rax
movq %rax, 0x10(%rsp)
subl %r12d, %ebp
xorl %r15d, %r15d
shlq $0x3, %r13
xorl %ebx, %ebx
movq 0x30(%r14), %rax
movq (%rax,%r15), %rax
movq (%rax,%r12,8), %rdi
testb $0x1, %dil
jne 0x1af0cd8
callq 0x1b9b8ab
jmp 0x1af0ceb
shrq $0x20, %rdi
movl %edi, %ecx
sarl $0x1f, %ecx
xorl %eax, %eax
testq %rdi, %rdi
setne %al
orl %ecx, %eax
testl %eax, %eax
je 0x1af0d13
movq 0x30(%r14), %rax
movq (%rax,%r15), %rax
addq %r13, %rax
movq 0x10(%rsp), %rcx
leaq (%rax,%rcx,8), %rdi
addq $0x8, %rdi
movl %ebp, %esi
callq 0x1b6bab8
cmpl $-0x1, %eax
je 0x1af0d38
incq %rbx
movl 0x1c(%r14), %eax
addq $0x8, %r15
cmpq %rax, %rbx
jb 0x1af0cbf
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %r12d
movq 0x8(%rsp), %rbx
testq %rbx, %rbx
je 0x1af0d26
movq %r14, %rdi
callq 0x1b10877
addq 0x30(%r14), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x1aefe37
movq %rax, (%rbx)
jmp 0x1af0d26
|
/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(set);
set = isl_set_set_rational(set);
if (!set)
return NULL;
if (set->n == 1) {
convex_hull = isl_basic_set_copy(set->p[0]);
isl_set_free(set);
return convex_hull;
}
if (dim == 1)
return convex_hull_1d(set);
bounded = isl_set_is_bounded(set);
if (bounded < 0)
goto error;
if (bounded && set->ctx->opt->convex == ISL_CONVEX_HULL_WRAP)
return uset_convex_hull_wrap(set);
lin = isl_set_combined_lineality_space(isl_set_copy(set));
if (!lin)
goto error;
if (isl_basic_set_plain_is_universe(lin)) {
isl_set_free(set);
return lin;
}
if (lin->n_eq < dim)
return modulo_lineality(set, lin);
isl_basic_set_free(lin);
return uset_convex_hull_unbounded(set);
error:
isl_set_free(set);
isl_basic_set_free(convex_hull);
return NULL;
}
|
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 0x1b10b6d
jmp 0x1af2e8e
testq %rbx, %rbx
je 0x1af2e07
movq %rbx, %rdi
callq 0x1b1bf80
movl %eax, %ebp
movq 0x20(%rbx), %rdi
callq 0x1b6fd4e
movq %rax, %rdi
testl %ebp, %ebp
je 0x1af2e89
callq 0x1b18c03
jmp 0x1af2e8e
xorl %r14d, %r14d
jmp 0x1af2e99
cmpl $0x1, %ebp
jne 0x1af2e20
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1af440a
movq %rbx, %rdi
callq 0x1af296b
testl %eax, %eax
js 0x1af2e75
je 0x1af2e3c
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x24(%rax)
je 0x1af2ea1
movq %rbx, %rdi
callq 0x1b10b72
movq %rax, %rdi
callq 0x1af2b85
testq %rax, %rax
je 0x1af2e75
movq %rax, %r14
movq %rax, %rdi
callq 0x1b13e31
testl %eax, %eax
jne 0x1af2e91
cmpl %ebp, 0x1c(%r14)
jae 0x1af2ead
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1af5fe7
movq %rbx, %rdi
callq 0x1b139c2
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x1b10b8e
jmp 0x1af2e99
callq 0x1b18c1b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b139c2
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1af4e77
movq %r14, %rdi
callq 0x1b10b8e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1af60eb
|
/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, ineq, data->ctx->one,
&opt, NULL, 0);
if (res == isl_lp_ok && isl_int_is_neg(opt)) {
if (shift)
isl_int_sub(ineq[0], ineq[0], opt);
else
res = isl_lp_unbounded;
}
isl_int_clear(opt);
return (res == isl_lp_ok || res == isl_lp_empty) ? 1 :
res == isl_lp_unbounded ? 0 : -1;
}
|
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
je 0x1af7fea
movq %rsp, %rcx
movq $0x1, (%rcx)
movq (%r15), %rdi
movq (%r14), %rdx
addq $0x38, %rdx
movq %rbx, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1b7d0df
movl %eax, %r14d
testl %eax, %eax
jne 0x1af7ff7
movq (%rsp), %rdi
testb $0x1, %dil
jne 0x1af7fbb
callq 0x1b9b8ab
jmp 0x1af7fce
shrq $0x20, %rdi
movl %edi, %ecx
sarl $0x1f, %ecx
xorl %eax, %eax
testq %rdi, %rdi
setne %al
orl %ecx, %eax
xorl %r14d, %r14d
testl %eax, %eax
jns 0x1af7ff7
testl %ebp, %ebp
je 0x1af7ff1
movq (%rbx), %rsi
movq (%rsp), %rdx
movq %rbx, %rdi
callq 0x1b09d2a
jmp 0x1af7ff7
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x1af8020
movl $0x1, %r14d
movq (%rsp), %rdi
testb $0x1, %dil
jne 0x1af8006
callq 0x1b9b0de
xorl %ecx, %ecx
cmpl $0x1, %r14d
setne %cl
negl %ecx
testl $0xfffffffd, %r14d # imm = 0xFFFFFFFD
movl $0x1, %eax
cmovnel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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 isl_stat_ok;
for (k = j - 1; k >= 0; --k) {
int plevel, plevel2;
plevel = acc->level_before(acc->source[k].data, acc->sink.data);
if (plevel < 0)
return isl_stat_error;
if (!can_precede_at_level(plevel, sink_level))
continue;
plevel2 = acc->level_before(acc->source[j].data,
acc->source[k].data);
if (plevel2 < 0)
return isl_stat_error;
for (level = sink_level; level <= depth; ++level) {
struct isl_map *T;
struct isl_set *trest;
struct isl_map *copy;
if (!can_precede_at_level(plevel2, level))
continue;
copy = isl_map_copy(temp_rel[j]);
T = last_later_source(acc, copy, j, sink_level, k,
level, &trest);
if (isl_map_plain_is_empty(T)) {
isl_set_free(trest);
isl_map_free(T);
continue;
}
temp_rel[j] = isl_map_intersect_range(temp_rel[j], trest);
temp_rel[k] = isl_map_union_disjoint(temp_rel[k], T);
}
}
return isl_stat_ok;
}
|
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,%rbp,8), %rdi
callq 0x1b1bf6b
testl %eax, %eax
setne %al
testl %ebx, %ebx
setle %cl
orb %al, %cl
jne 0x1afc9b9
movq 0x10(%rsp), %r13
leaq 0x50(%r13), %rcx
leaq 0x50(,%r15,8), %rdx
addq %r13, %rdx
movq %rdx, 0x38(%rsp)
movl %r14d, %eax
addl %r14d, %eax
leal 0x1(,%r14,2), %edx
movl %edx, 0x20(%rsp)
movq %rcx, %r14
addl $0x2, %eax
movl %eax, 0x24(%rsp)
movq %rbp, 0x40(%rsp)
movq %rcx, 0x30(%rsp)
movq %r12, 0x28(%rsp)
leaq -0x1(%rbp), %rax
movq %rax, 0x18(%rsp)
movq %rbp, 0x58(%rsp)
leaq (,%rbp,2), %rbx
addq %rbp, %rbx
movq -0x10(%r14,%rbx,8), %rdi
movq 0x10(%r13), %rsi
callq *0x20(%r13)
testl %eax, %eax
js 0x1afc808
movl $0x4, %ebp
cmpl 0xc(%rsp), %eax
setg %al
jl 0x1afc9a2
andb 0xc(%rsp), %al
jne 0x1afc9a2
leaq (%r14,%rbx,8), %rax
addq $-0x10, %rax
movl 0xc(%rsp), %ecx
cmpl %ecx, 0x20(%rsp)
setl %bl
movq 0x38(%rsp), %rcx
movq 0x8(%rcx), %rdi
movq (%rax), %rsi
callq *0x20(%r13)
movl %eax, %ebp
testl %eax, %eax
sets %al
orb %bl, %al
je 0x1afc812
shrl $0x1f, %ebp
jmp 0x1afc9a2
movl $0x1, %ebp
jmp 0x1afc9a2
movq 0x18(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (%r14,%rax,8), %rax
movq %rax, 0x50(%rsp)
movl 0xc(%rsp), %ebx
cmpl %ebx, %ebp
jl 0x1afc994
setg %al
testb %bl, %al
jne 0x1afc994
movq 0x40(%rsp), %rax
movq (%r12,%rax,8), %rdi
callq 0x1b10b80
movq %rax, %r14
movq %rax, %rdi
callq 0x1b10b80
movq %rax, %rdi
callq 0x1b1895a
movq %rax, 0x60(%rsp)
movq 0x8(%r13), %rdi
callq 0x1b10b80
movq %rax, %r13
movq 0x50(%rsp), %r15
movq (%r15), %rdi
callq 0x1b10b80
movq %rax, %rdi
callq 0x1b17951
movq %r13, %rdi
movq %rax, %rsi
callq 0x1b17964
movq %rax, %r13
movq (%r15), %rdi
callq 0x1b0fb77
movq %rax, %r15
movq 0x38(%rsp), %rax
movq (%rax), %rdi
callq 0x1b0fb77
movq %rax, %rdi
callq 0x1b71f5b
movq %r15, %rdi
movq 0x10(%rsp), %r15
movq %rax, %rsi
callq 0x1afc55e
movq %rax, %rdi
movl %ebx, %esi
callq 0x1afcdd4
movq %rax, %rdi
movq %r14, %rsi
callq 0x1b17964
movq %rax, %rdi
callq 0x1b17951
movq %r13, %rdi
movq %r15, %r13
movl 0xc(%rsp), %r12d
movq %rax, %rsi
callq 0x1b1421b
movq %rax, %r14
movq %rax, %rdi
callq 0x1b0fb77
movq %rax, %rdi
movl %r12d, %esi
callq 0x1afcdd4
movq %r14, %rdi
movq %rax, %rsi
callq 0x1b1421b
movq %r15, %rdi
movq %rax, %rsi
movq 0x18(%rsp), %r15
movl %r15d, %edx
movq 0x60(%rsp), %rcx
leaq 0x48(%rsp), %r8
callq 0x1afcdf4
movq %rax, %rdi
callq 0x1b17951
movq %rax, %r14
movq %rax, %rdi
callq 0x1b1bf6b
testl %eax, %eax
je 0x1afc95e
movq 0x48(%rsp), %rdi
callq 0x1b139c2
movq %r14, %rdi
callq 0x1b0fdb2
movq 0x28(%rsp), %r12
jmp 0x1afc98f
movq 0x40(%rsp), %r13
movq 0x28(%rsp), %r12
movq (%r12,%r13,8), %rdi
movq 0x48(%rsp), %rsi
callq 0x1b176e0
movq %rax, (%r12,%r13,8)
movq 0x10(%rsp), %r13
movq (%r12,%r15,8), %rdi
movq %r14, %rsi
callq 0x1b1aa01
movq %rax, (%r12,%r15,8)
movq 0x30(%rsp), %r14
incl %ebx
cmpl %ebx, 0x24(%rsp)
jne 0x1afc828
xorl %ebp, %ebp
testb $0x3, %bpl
jne 0x1afc9bd
cmpq $0x1, 0x58(%rsp)
movq 0x18(%rsp), %rbp
jg 0x1afc78c
xorl %eax, %eax
jmp 0x1afc9c2
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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->user)
return -1;
else
return 1;
}
|
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
cmpq $0x1, %rsi
sbbl $0x0, %eax
jmp 0x1aff390
xorl %eax, %eax
retq
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x1aff390
movl $0x1, %eax
jmp 0x1aff390
testq %rdi, %rdi
je 0x1aff381
callq 0x780dc0
testl %eax, %eax
jne 0x1aff390
movq 0x18(%r14), %rcx
xorl %eax, %eax
cmpq 0x18(%rbx), %rcx
sbbl %eax, %eax
orl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x1b1a580
movl 0x40(%rdi), %ebx
callq 0x1b1a4d4
cmpl %ebx, %eax
cmovnel %r15d, %ebp
movl %ebx, %ecx
orl %eax, %ecx
cmovsl %r12d, %ebp
js 0x1b1a5b2
cmpl %ebx, %eax
jne 0x1b1a5b2
incq %r13
movslq 0x28(%r14), %rax
cmpq %rax, %r13
jl 0x1b1a56e
movl $0x1, %eax
jmp 0x1b1a5b4
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 error;
if (type1 == type2 && pos1 == pos2)
return isl_basic_map_empty(space);
bmap = isl_basic_map_alloc_space(space, 0, 0, 1);
total = isl_basic_map_dim(bmap, isl_dim_all);
i = isl_basic_map_alloc_inequality(bmap);
if (total < 0 || i < 0)
return isl_basic_map_free(bmap);
isl_seq_clr(bmap->ineq[i], 1 + total);
pos1 += isl_basic_map_offset(bmap, type1);
pos2 += isl_basic_map_offset(bmap, type2);
isl_int_set_si(bmap->ineq[i][pos1], 1);
isl_int_set_si(bmap->ineq[i][pos2], -1);
isl_int_set_si(bmap->ineq[i][0], -1);
bmap = isl_basic_map_finalize(bmap);
return bmap;
error:
isl_space_free(space);
isl_basic_map_free(bmap);
return NULL;
}
|
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
js 0x1b2272b
movl %r12d, %eax
xorl %r14d, %eax
movl %r15d, %ecx
xorl %ebp, %ecx
movq %rbx, %rdi
xorl %esi, %esi
orl %eax, %ecx
jne 0x1b22744
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1b0f7e0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b11af7
movq %rbx, %rdi
callq 0x1b6fe0a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edx, %edx
movl $0x1, %ecx
callq 0x1b0f7e0
movq %rax, %rbx
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x1b22776
movq 0x10(%rbx), %rdi
movl $0x5, %esi
callq 0x1b6fb4e
testl %eax, %eax
js 0x1b22776
addl 0x40(%rbx), %eax
movl %eax, %r13d
movq %rbx, %rdi
callq 0x1b1110e
movl %r13d, %ecx
orl %eax, %ecx
jns 0x1b2278f
movq %rbx, %rdi
callq 0x1b0fb02
jmp 0x1b22733
movq 0x38(%rbx), %rcx
movl %eax, %eax
movq %rax, (%rsp)
movq (%rcx,%rax,8), %rdi
incl %r13d
movl %r13d, %esi
callq 0x1b6aef8
leal -0x1(%r12), %eax
xorl %ecx, %ecx
movl $0x0, %r13d
cmpl $0x3, %eax
ja 0x1b227cd
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1b0f2e7
xorl %ecx, %ecx
movl %eax, %r13d
incl %r13d
addl %r15d, %r13d
leal -0x1(%r14), %eax
cmpl $0x3, %eax
ja 0x1b227e8
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1b0f2e7
movl %eax, %ecx
incl %ecx
addl %ebp, %ecx
movq 0x38(%rbx), %rax
movq (%rsp), %rbp
movq (%rax,%rbp,8), %r14
movslq %r13d, %r15
movq (%r14,%r15,8), %rdi
testb $0x1, %dil
jne 0x1b2280e
movl %ecx, %r12d
callq 0x1b9b0de
movl %r12d, %ecx
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, (%r14,%r15,8)
movq 0x38(%rbx), %rax
movq (%rax,%rbp,8), %r15
movslq %ecx, %r12
movq (%r15,%r12,8), %rdi
testb $0x1, %dil
jne 0x1b22836
callq 0x1b9b0de
movabsq $-0xffffffff, %r14 # imm = 0xFFFFFFFF00000001
movq %r14, (%r15,%r12,8)
movq 0x38(%rbx), %rax
movq (%rax,%rbp,8), %r15
movq (%r15), %rdi
testb $0x1, %dil
jne 0x1b2285a
callq 0x1b9b0de
movq %r14, (%r15)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b2a464
|
/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_printer_print_str(p, op);
p = isl_printer_print_str(p, " ");
isl_int_set_si(c[last], 0);
p = print_affine(p, space, div, c);
return p;
}
|
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
callq 0x1b9b1c8
jmp 0x1b3cefe
shrq $0x20, %rdi
movl %edi, %eax
negl %eax
cmovsl %edi, %eax
shlq $0x20, %rax
incq %rax
movq %rax, (%r12)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movq %r13, %r8
movl %ebx, %r9d
callq 0x1b3d07f
leaq 0x2d52c47(%rip), %rbx # 0x488fb62
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b50d5d
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x1b50d5d
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b50d5d
movq %rax, %rbx
movq (%r12), %rdi
testb $0x1, %dil
jne 0x1b3cf50
callq 0x1b9b0de
movq $0x1, (%r12)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0x10(%rsp), %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b3d019
|
/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;
data.user = aff;
p = isl_print_space(map->dim, p, 0, &data);
p = print_disjuncts_map(map, map->dim, p, 1);
p = isl_printer_print_str(p, s_close_set[1]);
return p;
}
|
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 # 0x4f0fe68
movq %rax, %rdi
callq 0x1b50d5d
leaq -0x437(%rip), %rcx # 0x1b3dc95
movq %rcx, 0x8(%r15)
movq %r14, 0x10(%r15)
movq 0x20(%rbx), %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1b39814
movq 0x20(%rbx), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x1b3dbe4
leaq 0x33d1d75(%rip), %rsi # 0x4f0fe75
movq %rax, %rdi
callq 0x1b50d5d
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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 >= 0; --i) {
isl_set *domain;
domain = FN(PW,take_domain_at)(pw, i);
domain = fn(domain, isl_set_copy(set));
pw = FN(PW,restore_domain_at)(pw, i, domain);
pw = FN(PW,exploit_equalities_and_remove_if_empty)(pw, i);
}
isl_set_free(set);
return pw;
error:
isl_set_free(set);
FN(PW,free)(pw);
return NULL;
}
|
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 $0xffffffff, %r13d # imm = 0xFFFFFFFF
testl %r13d, %r13d
setns %al
movq 0x10(%rsp), %r14
testq %r14, %r14
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1b474fa
movq 0x8(%rsp), %r15
testl %r13d, %r13d
jle 0x1b474eb
incl %r13d
leal -0x2(%r13), %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x1b47e14
movq %rax, %r12
movq %r14, %rdi
callq 0x1b10b72
movq %r12, %rdi
movq %rax, %rsi
callq *%rbx
movq %r15, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x1b47e64
movq %rax, %rdi
movl %ebp, %esi
callq 0x1b490ff
movq %rax, %r15
decl %r13d
cmpl $0x1, %r13d
jg 0x1b474a7
movq %r15, 0x8(%rsp)
movq %r14, %rdi
callq 0x1b139c2
jmp 0x1b4750d
movq %r14, %rdi
callq 0x1b139c2
movq %r15, %rdi
callq 0x1b42180
xorl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1b50034
|
/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);
pw->p[pos].set = domain;
return pw;
error:
FN(PW,free)(pw);
isl_set_free(domain);
return NULL;
}
|
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 0x1b47eb8
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1b46efa
movq %rax, %rbx
jmp 0x1b47eb8
movq %r14, %rdi
callq 0x1b139c2
jmp 0x1b47ee2
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x1b47ece
movq 0x20(%rbx,%r15), %rdi
callq 0x1b139c2
movq %r14, 0x20(%rbx,%r15)
jmp 0x1b47ee2
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0x1b42180
movq %r14, %rdi
callq 0x1b139c2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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_dim_param, i, 1);
if (involves < 0)
return FN(PW,free)(pw);
if (!involves)
pw = FN(PW,drop_dims)(pw, isl_dim_param, i, 1);
}
return pw;
}
|
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
movl %eax, %ebp
testl %ebp, %ebp
jle 0x1b48164
decl %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x1b47ae0
movl %eax, %r14d
testl %eax, %eax
js 0x1b4814b
jne 0x1b48153
movq %rbx, %rdi
movl $0x1, %esi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x1b47c10
movq %rax, %rbx
jmp 0x1b48153
movq %rbx, %rdi
callq 0x1b42180
testl %r14d, %r14d
jns 0x1b4810f
jmp 0x1b48162
movq %rbx, %rdi
callq 0x1b42180
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
|
/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_list_free(data.filters);
return node;
}
|
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 0x1b6e030
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/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, isl_error_invalid,
"cannot insert dimensions of specified type",
goto error);
if (isl_space_check_range(space, type, pos, 0) < 0)
return isl_space_free(space);
space = isl_space_cow(space);
if (!space)
return NULL;
if (space->ids) {
enum isl_dim_type t, o = isl_dim_param;
int off;
int s[3];
ids = isl_calloc_array(ctx, isl_id *,
space->nparam + space->n_in + space->n_out + n);
if (!ids)
goto error;
off = 0;
s[isl_dim_param - o] = space->nparam;
s[isl_dim_in - o] = space->n_in;
s[isl_dim_out - o] = space->n_out;
for (t = isl_dim_param; t <= isl_dim_out; ++t) {
if (t != type) {
get_ids(space, t, 0, s[t - o], ids + off);
off += s[t - o];
} else {
get_ids(space, t, 0, pos, ids + off);
off += pos + n;
get_ids(space, t, pos, s[t - o] - pos,
ids + off);
off += s[t - o] - pos;
}
}
free(space->ids);
space->ids = ids;
space->n_id = space->nparam + space->n_in + space->n_out + n;
}
switch (type) {
case isl_dim_param: space->nparam += n; break;
case isl_dim_in: space->n_in += n; break;
case isl_dim_out: space->n_out += n; break;
default: ;
}
space = isl_space_reset(space, type);
if (type == isl_dim_param) {
if (space && space->nested[0] &&
!(space->nested[0] = isl_space_insert_dims(space->nested[0],
isl_dim_param, pos, n)))
goto error;
if (space && space->nested[1] &&
!(space->nested[1] = isl_space_insert_dims(space->nested[1],
isl_dim_param, pos, n)))
goto error;
}
return space;
error:
isl_space_free(space);
return NULL;
}
|
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 0x33a0422(%rip), %rcx # 0x4f11833
movq %r13, %rdi
movl $0x5, %esi
movl $0x52f, %r8d # imm = 0x52F
callq 0x1af81bb
jmp 0x1b71606
movq %rbx, %rdi
movl %r12d, %esi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b71254
movl %edx, %r15d
movq %rbx, %rdi
movl %r12d, %esi
xorl %ecx, %ecx
callq 0x1b71355
testl %eax, %eax
js 0x1b71606
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x1b71470
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1b6fc64
movq %rax, %rbx
testq %rbx, %rbx
je 0x1b7160e
cmpq $0x0, 0x48(%rbx)
je 0x1b71581
movl 0x10(%rbx), %esi
addl %r14d, %esi
addl 0x14(%rbx), %esi
addl 0x18(%rbx), %esi
movl $0x8, %edx
movq %r13, %rdi
callq 0x1af8296
testq %rax, %rax
je 0x1b71606
movq %rax, %r13
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movl 0x18(%rbx), %eax
movl %eax, 0x18(%rsp)
movq %r14, 0x28(%rsp)
leal (%r14,%r15), %eax
movl %eax, 0xc(%rsp)
movq %r12, 0x20(%rsp)
movl %r12d, %eax
movq %rax, 0x30(%rsp)
xorl %r12d, %r12d
movl $0x1, %ebp
cmpq %rbp, 0x30(%rsp)
jne 0x1b71524
movslq %r12d, %rax
leaq (,%rax,8), %r8
addq %r13, %r8
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
movl %r15d, %ecx
callq 0x1b71622
addl 0xc(%rsp), %r12d
movl 0xc(%rsp,%rbp,4), %r14d
subl %r15d, %r14d
movslq %r12d, %r12
leaq (,%r12,8), %r8
addq %r13, %r8
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
jmp 0x1b7153e
movl 0xc(%rsp,%rbp,4), %r14d
movslq %r12d, %rax
leaq (,%rax,8), %r8
addq %r13, %r8
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
movl %r14d, %ecx
callq 0x1b71622
addl %r14d, %r12d
incq %rbp
cmpq $0x4, %rbp
jne 0x1b714db
movq 0x48(%rbx), %rdi
callq 0x780910
movl 0x10(%rbx), %eax
movq 0x28(%rsp), %r14
addl %r14d, %eax
addl 0x14(%rbx), %eax
addl 0x18(%rbx), %eax
movq %r13, 0x48(%rbx)
movl %eax, 0x40(%rbx)
testq %r13, %r13
movq 0x20(%rsp), %r12
je 0x1b71606
cmpl $0x3, %r12d
je 0x1b7159f
cmpl $0x2, %r12d
je 0x1b71599
cmpl $0x1, %r12d
jne 0x1b715a3
addl %r14d, 0x10(%rbx)
jmp 0x1b715a3
addl %r14d, 0x14(%rbx)
jmp 0x1b715a3
addl %r14d, 0x18(%rbx)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1b71254
movq %rax, %rbx
cmpl $0x1, %r12d
setne %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x1b71610
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1b715e4
movl $0x1, %esi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x1b713d1
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x1b71606
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1b71610
movl $0x1, %esi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x1b713d1
movq %rax, 0x38(%rbx)
testq %rax, %rax
jne 0x1b71610
movq %rbx, %rdi
callq 0x1b6fe0a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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, %eax
je 0x1b72731
movq %rbx, %rdi
popq %rbx
jmp 0x1b72671
movq 0x8(%rbx), %rdi
leaq 0x339f14d(%rip), %rdx # 0x4f11889
leaq 0x339f0f0(%rip), %rcx # 0x4f11833
movl $0x5, %esi
movl $0x733, %r8d # imm = 0x733
callq 0x1af81bb
movq %rbx, %rdi
callq 0x1b6fe0a
xorl %eax, %eax
popq %rbx
retq
|
/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;
pos = isl_space_find_dim_by_id(space, isl_dim_param, id);
isl_id_free(id);
if (pos >= 0)
isl_die(isl_space_get_ctx(space), isl_error_invalid,
"parameters not unique", return isl_stat_error);
}
return isl_stat_ok;
}
|
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 %rax, %rax
je 0x1b72f08
movq %rax, %r13
movq %r14, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0x1b707b3
movl %eax, %ebx
movq %r13, %rdi
callq 0x1afe3ec
testl %ebx, %ebx
jns 0x1b72edd
incl %r12d
cmpl %r12d, %ebp
jne 0x1b72ea0
xorl %eax, %eax
jmp 0x1b72f0d
testq %r14, %r14
je 0x1b72ee8
movq 0x8(%r14), %rdi
jmp 0x1b72eea
xorl %edi, %edi
leaq 0x339edbf(%rip), %rdx # 0x4f11cb0
leaq 0x339e93b(%rip), %rcx # 0x4f11833
movl $0x5, %esi
movl $0x900, %r8d # imm = 0x900
callq 0x1af81bb
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 unwrap;
error:
isl_space_free(space);
return NULL;
}
|
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), %rcx # 0x4f11833
movl $0x5, %esi
movl $0xb32, %r8d # imm = 0xB32
callq 0x1af81bb
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1b6fe0a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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_involves_dims(c, isl_dim_set, data->pos, 1);
if (is_eq < 0 || relevant < 0)
goto error;
if (!is_eq || !relevant) {
isl_constraint_free(c);
return isl_stat_ok;
}
n_div = isl_constraint_dim(c, isl_dim_div);
if (n_div < 0)
goto error;
ctx = isl_constraint_get_ctx(c);
stride = isl_val_zero(ctx);
for (i = 0; i < n_div; ++i) {
v = isl_constraint_get_coefficient_val(c, isl_dim_div, i);
stride = isl_val_gcd(stride, v);
}
v = isl_constraint_get_coefficient_val(c, isl_dim_set, data->pos);
m = isl_val_gcd(isl_val_copy(stride), isl_val_copy(v));
stride = isl_val_div(stride, isl_val_copy(m));
v = isl_val_div(v, isl_val_copy(m));
has_stride = isl_val_gt_si(stride, 1);
if (has_stride >= 0 && has_stride) {
isl_aff *aff;
isl_val *gcd, *a, *b;
gcd = isl_val_gcdext(v, isl_val_copy(stride), &a, &b);
isl_val_free(gcd);
isl_val_free(b);
aff = isl_constraint_get_aff(c);
for (i = 0; i < n_div; ++i)
aff = isl_aff_set_coefficient_si(aff,
isl_dim_div, i, 0);
aff = isl_aff_set_coefficient_si(aff, isl_dim_in, data->pos, 0);
aff = isl_aff_remove_unused_divs(aff);
a = isl_val_neg(a);
aff = isl_aff_scale_val(aff, a);
aff = isl_aff_scale_down_val(aff, m);
r = set_stride(data, stride, aff);
} else {
isl_val_free(stride);
isl_val_free(m);
isl_val_free(v);
}
isl_constraint_free(c);
if (has_stride < 0)
return isl_stat_error;
return r;
error:
isl_constraint_free(c);
return isl_stat_error;
}
|
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 $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x1b748f0
testl %ebp, %ebp
setne %cl
testl %eax, %eax
setne %al
testb %al, %cl
je 0x1b746e2
movq %rbx, %rdi
movl $0x4, %esi
callq 0x1af036a
testl %eax, %eax
js 0x1b7457b
movl %eax, %r12d
movq %rbx, %rdi
callq 0x1aefb3c
movq %rax, %rdi
callq 0x1b92b0e
movq %rax, %r15
testl %r12d, %r12d
je 0x1b745f1
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x4, %esi
movl %ebp, %edx
callq 0x1af0686
movq %r15, %rdi
movq %rax, %rsi
callq 0x1b94b71
movq %rax, %r15
incl %ebp
cmpl %ebp, %r12d
jne 0x1b745cd
movq %r14, 0x38(%rsp)
movl (%r14), %edx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1af0686
movq %rax, %rbp
movq %r15, %rdi
callq 0x1b91cbb
movq %rax, %r13
movq %rbp, %rdi
callq 0x1b91cbb
movq %r13, %rdi
movq %rax, %rsi
callq 0x1b94b71
movq %rax, %r14
movq %rax, %rdi
callq 0x1b91cbb
movq %r15, %rdi
movq %rax, %rsi
callq 0x1b94632
movq %rax, %r13
movq %r14, %rdi
callq 0x1b91cbb
movq %rbp, %rdi
movq %rax, %rsi
callq 0x1b94632
movq %rax, %rbp
movl $0x1, %esi
movq %r13, %rdi
callq 0x1b95624
movl %eax, %r15d
testl %eax, %eax
jle 0x1b746f1
movl %r15d, 0xc(%rsp)
movq %r13, 0x20(%rsp)
movq %r13, %rdi
callq 0x1b91cbb
leaq 0x28(%rsp), %rdx
leaq 0x40(%rsp), %r15
movq %rbp, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0x1b94ee5
movq %rax, %rdi
callq 0x1b91ce4
movq (%r15), %rdi
callq 0x1b91ce4
movq %rbx, %rdi
callq 0x1af1b20
testl %r12d, %r12d
je 0x1b74710
cmpl $0x2, %r12d
movl $0x1, %r15d
cmovgel %r12d, %r15d
xorl %ebp, %ebp
movq %r14, %r12
movq %rax, %rdi
movl $0x4, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x1ab2c42
incl %ebp
cmpl %ebp, %r15d
jne 0x1b746c8
jmp 0x1b74713
movq %rbx, %rdi
callq 0x1aef248
xorl %eax, %eax
jmp 0x1b748f0
movq %r13, %rdi
callq 0x1b91ce4
movq %r14, %rdi
callq 0x1b91ce4
movq %rbp, %rdi
callq 0x1b91ce4
xorl %ebp, %ebp
jmp 0x1b748dd
movq %r14, %r12
movq 0x38(%rsp), %r14
movl (%r14), %edx
movq %rax, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x1ab2c42
movq %rax, %rdi
callq 0x1ab34bb
movq %rax, %r15
movq 0x28(%rsp), %rdi
callq 0x1b9365e
movq %rax, 0x28(%rsp)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1ab3f81
movq %rax, %rdi
movq %r12, %rsi
callq 0x1ab3ea6
movq %rax, %r12
movq 0x20(%rsp), %r13
testq %r13, %r13
je 0x1b74865
testq %r12, %r12
je 0x1b74865
cmpl $0x0, 0x8(%r14)
je 0x1b74895
movq 0x10(%r14), %rbp
movq %rbp, 0x30(%rsp)
movq %r13, %rdi
callq 0x1b91cbb
movq %rax, %r15
movq %rbp, %rdi
callq 0x1b91cbb
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movq %rax, %rsi
movq %rdx, %rbp
callq 0x1b94ee5
movq %rax, %r15
movq (%rbp), %rbp
movq %r13, %rdi
callq 0x1b91cbb
movq %rbp, %rdi
movq %rax, %rsi
callq 0x1b943e6
movq %rax, %rbp
leaq 0x18(%rsp), %r13
movq %rax, (%r13)
movq %r15, %rdi
callq 0x1b91cbb
movq %rbp, %rdi
movq %rax, %rsi
callq 0x1b94632
movq %rax, (%r13)
movq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x1b94632
movq %rax, %r15
leaq 0x10(%rsp), %rbp
movq (%rbp), %r13
movq %rax, %rdi
callq 0x1b91cbb
movq %r13, %rdi
movq %rax, %rsi
callq 0x1b943e6
movq %rax, (%rbp)
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x1b943e6
movq %rax, %r13
cmpl $0x0, 0x4(%r14)
je 0x1b74881
movq 0x18(%r14), %rdi
movq 0x18(%rsp), %rsi
callq 0x1ab3f81
movq %rax, %r15
movq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x1ab3f81
movq %rax, %rdi
movq %r15, %rsi
callq 0x1ab44b8
movq %rax, %r12
jmp 0x1b74895
movq %r13, %rdi
callq 0x1b91ce4
movq %r12, %rdi
callq 0x1aacce8
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movl 0xc(%rsp), %r15d
jmp 0x1b748dd
movq 0x18(%rsp), %rdi
callq 0x1b91ce4
movq 0x10(%rsp), %rdi
callq 0x1b91ce4
movl 0xc(%rsp), %r15d
movl $0x1, 0x8(%r14)
movq %r13, 0x10(%r14)
cmpl $0x0, 0x4(%r14)
je 0x1b748b3
movq %r12, 0x18(%r14)
jmp 0x1b748bb
movq %r12, %rdi
callq 0x1aacce8
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpq $0x0, 0x10(%r14)
je 0x1b748dd
cmpl $0x0, 0x4(%r14)
je 0x1b74709
cmpq $0x0, 0x18(%r14)
jne 0x1b74709
movq %rbx, %rdi
callq 0x1aef248
testl %r15d, %r15d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovnsl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 0x1b74b41
retq
movq 0x10(%rbx), %rdi
callq 0x1b0fdb2
jmp 0x1b74b41
movq 0x10(%rbx), %rdi
callq 0x1aadb11
jmp 0x1b74b41
movq 0x10(%rbx), %rdi
callq 0x780910
movq %rbx, %rdi
popq %rbx
jmp 0x780910
|
/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)
callq 0x1b8e5ee
addq $0x38, %rsp
retq
|
/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->res, map);
return data->res ? isl_stat_ok : isl_stat_error;
}
|
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
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 isl_bool_true;
}
if (first >= n_range) {
isl_union_map_free(umap);
return isl_bool_false;
}
data.v = alloc_isl_fixed_map_array(ctx, n);
if (!data.v)
goto error;
for (data.pos = first; data.pos < n_range; ++data.pos) {
isl_bool fixed;
int injective;
isl_space *space;
data.n = 0;
fixed = union_map_forall_user(umap, &fixed_at_pos, &data);
if (fixed < 0)
goto error;
if (!fixed)
continue;
space = isl_union_map_get_space(umap);
injective = separates(data.v, n, space, data.pos, n_range);
isl_union_map_free(umap);
return injective;
}
free_isl_fixed_map_array(data.v, n);
isl_union_map_free(umap);
return isl_bool_false;
error:
free_isl_fixed_map_array(data.v, n);
isl_union_map_free(umap);
return isl_bool_error;
}
|
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 = 0xFFFFFFFF
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x1b913b0
movl 0x14(%rbx), %esi
testl %esi, %esi
js 0x1b917a8
movl $0x1, %r13d
cmpl $0x2, %esi
jl 0x1b917b5
xorl %r13d, %r13d
cmpl %r14d, %r12d
jge 0x1b917b5
movl %esi, 0x8(%rsp)
movl %esi, %r15d
movl $0x10, %edx
movq %r15, %rsi
callq 0x1af8296
testq %rax, %rax
je 0x1b9148b
leal 0x1(%r15), %ecx
leaq -0x1(%r15), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
shrl %ecx
shlq $0x5, %rcx
movdqa 0x1023c10(%rip), %xmm1 # 0x2bb5020
xorl %edx, %edx
movdqa 0x1023c16(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x1114396(%rip), %xmm4 # 0x2ca57c0
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x1b91464
movq $0x1, (%rax,%rdx)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x1b9147c
movq $0x1, 0x10(%rax,%rdx)
paddq %xmm4, %xmm1
addq $0x20, %rdx
cmpq %rdx, %rcx
jne 0x1b9142a
jmp 0x1b9148d
xorl %eax, %eax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x1b917a4
movl %r12d, 0x2c(%rsp)
cmpl %r14d, %r12d
jge 0x1b917a2
leaq 0x33818ac(%rip), %rax # 0x4f12d5c
movb (%rax), %al
movb %al, 0xe(%rsp)
leaq 0x33818a0(%rip), %rax # 0x4f12d5d
movb (%rax), %al
movb %al, 0xf(%rsp)
movq %rbx, 0x48(%rsp)
movl %r14d, 0x1c(%rsp)
movq %r15, 0x10(%rsp)
movl $0x0, 0x28(%rsp)
movq %rbx, %rdi
leaq 0x2f9(%rip), %rsi # 0x1b917dd
leaq 0x20(%rsp), %rdx
callq 0x1b8fc25
testl %eax, %eax
js 0x1b914ff
je 0x1b91509
testq %rbx, %rbx
je 0x1b91513
movq 0x8(%rbx), %rdi
jmp 0x1b91515
movl $0x2, %eax
jmp 0x1b9178a
movl $0x5, %eax
jmp 0x1b9178a
xorl %edi, %edi
callq 0x1b6fd4e
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
movq 0x10(%rsp), %rsi
je 0x1b91724
movl 0x2c(%rsp), %ebp
movl $0x10, %edx
movq 0x30(%rsp), %rbx
movq %rbx, %rdi
leaq 0x2fb(%rip), %rcx # 0x1b9184a
callq 0x780cd0
movq 0x10(%rsp), %rdi
incl %ebp
movl %ebp, 0x40(%rsp)
leaq 0x8(%rbx), %rax
movq %rax, 0x50(%rsp)
xorl %r14d, %r14d
movl $0x1, %eax
movl 0x8(%rsp), %ebp
movslq %r14d, %r12
movq %r12, 0x58(%rsp)
shlq $0x4, %r12
movl %eax, 0x44(%rsp)
movslq %eax, %r15
leal 0x1(%r15), %ebx
cmpl %ebx, %ebp
cmovgl %ebp, %ebx
movq 0x30(%rsp), %rax
leaq (%rax,%r12), %r13
movq %r15, %rbp
shlq $0x4, %rbp
addq %rax, %rbp
movq (%r13), %rax
movq (%rbp), %rsi
movq %rax, %rcx
shrq $0x20, %rcx
movl %eax, %edx
andl %esi, %edx
testb $0x1, %dl
je 0x1b915cf
shrq $0x20, %rsi
xorl %eax, %eax
xorl %edx, %edx
cmpl %esi, %ecx
setg %al
setl %dl
subl %edx, %eax
jmp 0x1b9164d
testb $0x1, %sil
jne 0x1b915e3
testb $0x1, %al
jne 0x1b9160b
movq %rax, %rdi
callq 0x1b9d158
jmp 0x1b91648
testb $0x1, %al
je 0x1b9163c
leaq 0x80(%rsp), %rdx
movq %rdx, 0x68(%rsp)
movl $0x2, 0x70(%rsp)
testq %rax, %rax
js 0x1b9161e
movb 0xf(%rsp), %al
movb %al, 0x78(%rsp)
jmp 0x1b91628
sarq $0x20, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1b9d181
negl %eax
jmp 0x1b91648
movb 0xe(%rsp), %al
movb %al, 0x78(%rsp)
negl %ecx
movl %ecx, 0x80(%rsp)
movl $0x1, 0x74(%rsp)
leaq 0x60(%rsp), %rax
sarq $0x20, %rsi
movq %rax, %rdi
callq 0x1b9d181
movq 0x10(%rsp), %rdi
testl %eax, %eax
jne 0x1b91663
incq %r15
addq $0x10, %rbp
cmpq %rdi, %r15
jl 0x1b915a3
jmp 0x1b91666
movl %r15d, %ebx
movl $0x5, %eax
cmpl 0x44(%rsp), %ebx
je 0x1b916f0
movq 0x38(%rsp), %rdi
callq 0x1b6fd4e
movl %ebx, %esi
subl %r14d, %esi
movq %rax, %rdi
callq 0x1b8cbca
movq %rax, %r13
cmpl %r14d, %ebx
jle 0x1b916bd
movslq %ebx, %r15
addq 0x50(%rsp), %r12
subq 0x58(%rsp), %r15
movq (%r12), %rdi
callq 0x1b10b80
movq %r13, %rdi
movq %rax, %rsi
callq 0x1b8d126
movq %rax, %r13
addq $0x10, %r12
decq %r15
jne 0x1b9169d
movq %r13, %rdi
movl 0x40(%rsp), %esi
movl 0x1c(%rsp), %edx
callq 0x1b91369
testl %eax, %eax
js 0x1b916e6
decl %ebx
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
cmovel %r14d, %ebx
leal (%rcx,%rcx,2), %eax
movl %ebx, %r14d
jmp 0x1b916eb
movl $0x2, %eax
movq 0x10(%rsp), %rdi
cmpl $0x5, %eax
ja 0x1b91744
movl %eax, %eax
leaq 0x33812e2(%rip), %rcx # 0x4f129e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leal 0x1(%r14), %ebx
addl $0x2, %r14d
movl %r14d, %eax
movl 0x8(%rsp), %ebp
cmpl %ebp, %r14d
movl %ebx, %r14d
jl 0x1b91574
jmp 0x1b9174d
movq 0x38(%rsp), %rdi
callq 0x1b6fe0a
movq 0x30(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x1b91809
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
jmp 0x1b9176e
jmp 0x1b9176e
movl %r14d, %ebx
movl 0x8(%rsp), %ebp
movq 0x38(%rsp), %rdi
callq 0x1b6fe0a
movq 0x30(%rsp), %rdi
movl %ebp, %esi
callq 0x1b91809
incl %ebx
xorl %r13d, %r13d
cmpl %ebp, %ebx
setge %r13b
movq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x1b8cd9e
movl $0x1, %eax
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movl 0x1c(%rsp), %r14d
cmpl $0x5, %eax
jne 0x1b917d2
movl 0x2c(%rsp), %eax
incl %eax
movl %eax, 0x2c(%rsp)
cmpl %r14d, %eax
jl 0x1b914d2
xorl %ebp, %ebp
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %rdi
callq 0x1b91809
movl %ebp, %r13d
movq %rbx, %rdi
callq 0x1b8cd9e
movl %r13d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %eax
movl 0x8(%rsp), %esi
je 0x1b917a8
jmp 0x1b917bd
|
/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 %r15
jmp 0x780910
retq
|
/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
movq 0x10(%rbx), %rdi
testb $0x1, %dil
jne 0x1b936b3
movq 0x10(%rbx), %rsi
callq 0x1b9b1dd
jmp 0x1b936ae
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %rax, %rdi
movl $0x1, %eax
subq %rdi, %rax
movq %rax, 0x10(%rbx)
jmp 0x1b936ae
|
/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) && !isl_val_is_rat(v2))) {
isl_val_free(v2);
return isl_val_set_nan(v1);
}
if (isl_val_is_zero(v1)) {
isl_val_free(v2);
return v1;
}
if (isl_val_is_zero(v2)) {
isl_val_free(v1);
return v2;
}
if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
if (isl_val_is_neg(v2))
v1 = isl_val_neg(v1);
isl_val_free(v2);
return v1;
}
if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
if (isl_val_is_neg(v1))
v2 = isl_val_neg(v2);
isl_val_free(v1);
return v2;
}
v1 = isl_val_cow(v1);
if (!v1)
goto error;
if (isl_val_is_int(v1) && isl_val_is_int(v2))
isl_int_mul(v1->n, v1->n, v2->n);
else {
isl_int_mul(v1->n, v1->n, v2->n);
isl_int_mul(v1->d, v1->d, v2->d);
v1 = isl_val_normalize(v1);
}
isl_val_free(v2);
return v1;
error:
isl_val_free(v1);
isl_val_free(v2);
return NULL;
}
|
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 %rbx, %rdi
callq 0x1b91ce4
movq %r14, %rbx
jmp 0x1b9459d
movq %rbx, %rdi
callq 0x1b931b5
testl %eax, %eax
je 0x1b944ad
movq %rbx, %rdi
callq 0x1b936ce
testl %eax, %eax
je 0x1b9445d
movq %r14, %rdi
callq 0x1b931b5
testl %eax, %eax
je 0x1b944b9
movq %rbx, %rdi
callq 0x1b936ce
testl %eax, %eax
jne 0x1b94410
movq %r14, %rdi
callq 0x1b936ce
testl %eax, %eax
jne 0x1b94429
movq %rbx, %rdi
callq 0x1b937f8
testl %eax, %eax
jne 0x1b9448d
movq %rbx, %rdi
callq 0x1b93865
testl %eax, %eax
je 0x1b944d0
movq %r14, %rdi
callq 0x1b93bf6
testl %eax, %eax
je 0x1b94410
movq %rbx, %rdi
callq 0x1b9365e
movq %rax, %rbx
jmp 0x1b94410
movq %r14, %rdi
callq 0x1b936ce
testl %eax, %eax
je 0x1b94445
movq %r14, %rdi
callq 0x1b91ce4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1b92bf8
movq %r14, %rdi
callq 0x1b937f8
testl %eax, %eax
jne 0x1b944e8
movq %r14, %rdi
callq 0x1b93865
testl %eax, %eax
je 0x1b94508
movq %rbx, %rdi
callq 0x1b93bf6
testl %eax, %eax
je 0x1b94429
movq %r14, %rdi
callq 0x1b9365e
movq %rax, %r14
jmp 0x1b94429
testq %rbx, %rbx
je 0x1b94525
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x1b94527
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1b93059
movq %rax, %rbx
jmp 0x1b94527
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x1b94589
movq %rbx, %rdi
callq 0x1b92e52
testl %eax, %eax
je 0x1b9455a
movq %r14, %rdi
callq 0x1b92e52
testl %eax, %eax
je 0x1b9455a
leaq 0x10(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq 0x10(%r14), %rdx
callq 0x1b09f03
jmp 0x1b94410
leaq 0x10(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq 0x10(%r14), %rdx
callq 0x1b09f03
leaq 0x18(%rbx), %rdi
movq 0x18(%rbx), %rsi
movq 0x18(%r14), %rdx
callq 0x1b09f03
movq %rbx, %rdi
callq 0x1b9353c
jmp 0x1b944a5
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0x1b91ce4
movq %r14, %rdi
callq 0x1b91ce4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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;
v1 = isl_val_cow(v1);
if (!v1)
return NULL;
isl_int_mul_ui(v1->d, v1->d, v2);
return isl_val_normalize(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 0x1b94839
movq %rbx, %rdi
callq 0x1b937f8
testl %eax, %eax
jne 0x1b94839
movq %rbx, %rdi
callq 0x1b93865
testl %eax, %eax
jne 0x1b94839
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x1b94813
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1b93059
movq %rax, %rbx
testq %rbx, %rbx
je 0x1b94837
leaq 0x18(%rbx), %rdi
movq 0x18(%rbx), %rsi
movq %r14, %rdx
callq 0x1b0a42b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1b9353c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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)(multi->u.p[i]));
if (FN(MULTI(BASE),has_explicit_domain)(multi))
dup = FN(MULTI(BASE),copy_explicit_domain)(dup, multi);
return dup;
}
|
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
xorl %edx, %edx
movq %rax, %rdi
movl %r14d, %esi
callq 0x1b95eb5
incq %r14
movslq 0x10(%rbx), %rcx
cmpq %rcx, %r14
jl 0x1b95d06
jmp 0x1b95d34
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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);
if (!ext)
goto error;
isl_seq_cpy(ext->el, vec->el, pos);
isl_seq_cpy(ext->el + pos + n, vec->el + pos, vec->size - pos);
isl_vec_free(vec);
return ext;
error:
isl_vec_free(vec);
isl_vec_free(ext);
return NULL;
}
|
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
movl $0x23c, %r8d # imm = 0x23C
callq 0x1af81bb
jmp 0x1b98bc1
xorl %ebx, %ebx
jmp 0x1b98bcf
movl %edx, %r15d
addl %edx, %esi
callq 0x1b97dfc
testq %rax, %rax
je 0x1b98bc1
movq %rax, %r14
movq 0x18(%rax), %rdi
movq 0x18(%rbx), %rsi
movl %ebp, %edx
callq 0x1b6b0a5
movl %ebp, %esi
shlq $0x3, %rsi
movq 0x18(%r14), %rax
addq %rsi, %rax
movl %r15d, %ecx
leaq (%rax,%rcx,8), %rdi
addq 0x18(%rbx), %rsi
movl 0x10(%rbx), %edx
subl %ebp, %edx
callq 0x1b6b0a5
jmp 0x1b98bc4
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1b97f0e
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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_die(vec->ctx, isl_error_invalid,
"destination range out of bounds",
return isl_vec_free(vec));
if (n == 0 || dst_pos == src_pos)
return vec;
res = isl_vec_alloc(vec->ctx, vec->size);
if (!res)
return isl_vec_free(vec);
if (dst_pos < src_pos) {
isl_seq_cpy(res->el, vec->el, dst_pos);
isl_seq_cpy(res->el + dst_pos, vec->el + src_pos, n);
isl_seq_cpy(res->el + dst_pos + n,
vec->el + dst_pos, src_pos - dst_pos);
isl_seq_cpy(res->el + src_pos + n,
vec->el + src_pos + n, res->size - src_pos - n);
} else {
isl_seq_cpy(res->el, vec->el, src_pos);
isl_seq_cpy(res->el + src_pos,
vec->el + src_pos + n, dst_pos - src_pos);
isl_seq_cpy(res->el + dst_pos, vec->el + src_pos, n);
isl_seq_cpy(res->el + dst_pos + n,
vec->el + dst_pos + n, res->size - dst_pos - n);
}
isl_vec_free(vec);
return res;
}
|
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
leaq 0x3379ff4(%rip), %rcx # 0x4f12c53
movl $0x5, %esi
movl $0x271, %r8d # imm = 0x271
jmp 0x1b98c95
xorl %ebx, %ebx
jmp 0x1b98ca8
leal (%r15,%r12), %edx
cmpl %esi, %edx
jbe 0x1b98cba
movq 0x8(%rbx), %rdi
leaq 0x337a066(%rip), %rdx # 0x4f12ce9
leaq 0x3379fc9(%rip), %rcx # 0x4f12c53
movl $0x5, %esi
movl $0x275, %r8d # imm = 0x275
callq 0x1af81bb
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1b97f0e
movq %r14, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r15d, %r15d
sete %al
cmpl %r13d, %r12d
sete %cl
orb %al, %cl
jne 0x1b98ca8
movl %edx, 0x10(%rsp)
movq 0x8(%rbx), %rdi
callq 0x1b97dfc
testq %rax, %rax
je 0x1b98c9a
movq %rax, %r14
movl %r12d, %eax
movq 0x18(%r14), %rdi
movq 0x18(%rbx), %rsi
subl %r13d, %eax
jae 0x1b98d4f
movl %r12d, %edx
callq 0x1b6b0a5
movl %r12d, %eax
shlq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%r14), %rdi
addq %rax, %rdi
movl %r13d, %eax
movq %rax, 0x10(%rsp)
leaq (,%rax,8), %rsi
addq 0x18(%rbx), %rsi
movl %r15d, %edx
callq 0x1b6b0a5
movq 0x18(%r14), %rax
movq 0x8(%rsp), %rsi
addq %rsi, %rax
movl %r15d, %r15d
leaq (%rax,%r15,8), %rdi
addq 0x18(%rbx), %rsi
subl %r12d, %r13d
movq 0x10(%rsp), %r12
movl %r13d, %edx
callq 0x1b6b0a5
jmp 0x1b98da5
movl %eax, 0x8(%rsp)
movl %r13d, %edx
callq 0x1b6b0a5
movl %r13d, %r13d
shlq $0x3, %r13
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq 0x18(%rbx), %rax
addq %r13, %rax
movl %r15d, %ebp
leaq (%rax,%rbp,8), %rsi
movl 0x8(%rsp), %edx
callq 0x1b6b0a5
movl %r12d, %r12d
leaq (,%r12,8), %rdi
addq 0x18(%r14), %rdi
addq 0x18(%rbx), %r13
movq %r13, %rsi
movl %r15d, %edx
movq %rbp, %r15
callq 0x1b6b0a5
movl 0x10(%rsp), %ebp
shlq $0x3, %r12
movq 0x18(%r14), %rax
addq %r12, %rax
addq 0x18(%rbx), %r12
leaq (%rax,%r15,8), %rdi
leaq (%r12,%r15,8), %rsi
movl 0x10(%r14), %edx
subl %ebp, %edx
callq 0x1b6b0a5
jmp 0x1b98c9d
|
/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
jmp 0x1b50a57
retq
|
/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 %r14
retq
xorl %eax, %eax
retq
|
/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 %r14
retq
xorl %eax, %eax
retq
|
/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_int_div(n, d, q, r));
/* see: [Note]Overview of division implementation */
qsign = mp_int_compare_zero(q);
rsign = mp_int_compare_zero(r);
if (qsign < 0) { /* q < 0 */
if (rsign != 0) { /* r != 0 */
CHECK(mp_int_sub_value(q, 1, q));
}
} else if (qsign == 0) { /* q == 0 */
if (rsign != 0) { /* r != 0 */
if ((nsign < 0 && dsign > 0) || (nsign > 0 && dsign < 0)) {
CHECK(mp_int_set_value(q, -1));
}
}
}
mp_int_clear(r);
}
|
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 %rbx, %rdx
movq %r13, %rcx
callq 0x1b9c099
movq %rbx, %rdi
callq 0x1b9b8ab
movl %eax, %r15d
movq %r13, %rdi
callq 0x1b9b8ab
testl %r15d, %r15d
js 0x1b9a913
sete %cl
testl %eax, %eax
setne %al
andb %cl, %al
cmpb $0x1, %al
jne 0x1b9a927
testl %ebp, %ebp
sets %al
testl %r14d, %r14d
setg %cl
testb %cl, %al
jne 0x1b9a902
testl %ebp, %ebp
setg %al
testl %r14d, %r14d
sets %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1b9a927
movq %rbx, %rdi
movq $-0x1, %rsi
callq 0x1b9afae
jmp 0x1b9a927
testl %eax, %eax
je 0x1b9a927
movl $0x1, %esi
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x1b9b6a8
leaq 0x8(%rsp), %rdi
callq 0x1b9b0b8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 overlap with q */
CHECK(mp_int_init_copy(orig_d, d));
CHECK(mp_int_init_copy(orig_n, n));
/* floor division */
GMPZAPI(fdiv_q)(q, n, d);
/* see: [Note]Overview of division implementation */
/* n = q * d + r ==> r = n - q * d */
mp_int_mul(q, orig_d, temp);
mp_int_sub(orig_n, temp, r);
mp_int_clear(q);
mp_int_clear(temp);
mp_int_clear(orig_d);
mp_int_clear(orig_n);
}
|
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(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x1b9ae8e
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x1b9a871
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1b9b709
movq %r13, %rdi
movq %r14, %rsi
movq (%rsp), %rdx
callq 0x1b9b546
movq %rbx, %rdi
callq 0x1b9b0b8
movq %r14, %rdi
callq 0x1b9b0b8
movq %r12, %rdi
callq 0x1b9b0b8
movq %r13, %rdi
callq 0x1b9b0b8
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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_int_init(&gcd)) != MP_OK) return res;
if ((res = mp_int_gcd(MP_NUMER_P(r), MP_DENOM_P(r), &gcd)) != MP_OK) {
goto CLEANUP;
}
if (mp_int_compare_value(&gcd, 1) != 0) {
if ((res = mp_int_div(MP_NUMER_P(r), &gcd, MP_NUMER_P(r), NULL)) != MP_OK) {
goto CLEANUP;
}
if ((res = mp_int_div(MP_DENOM_P(r), &gcd, MP_DENOM_P(r), NULL)) != MP_OK) {
goto CLEANUP;
}
}
/* Fix up the signs of numerator and denominator */
if (MP_NUMER_SIGN(r) == MP_DENOM_SIGN(r)) {
MP_NUMER_SIGN(r) = MP_DENOM_SIGN(r) = MP_ZPOS;
} else {
MP_NUMER_SIGN(r) = MP_NEG;
MP_DENOM_SIGN(r) = MP_ZPOS;
}
CLEANUP:
mp_int_clear(&gcd);
return res;
}
|
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, %rdi
movq %r14, %rsi
callq 0x1b9e342
movl %eax, %ebp
cmpl %r15d, %eax
jne 0x1b9f7ab
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x1b9d181
testl %eax, %eax
je 0x1b9f75e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x1b9c099
movl %eax, %ebp
cmpl %r15d, %eax
jne 0x1b9f7ab
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x1b9c099
movl %eax, %ebp
cmpl %r15d, %eax
jne 0x1b9f7ab
movb 0x18(%rbx), %al
cmpb 0x38(%rbx), %al
jne 0x1b9f793
leaq 0x33735f0(%rip), %rax # 0x4f12d5d
movb (%rax), %al
movb %al, 0x38(%rbx)
movb %al, 0x18(%rbx)
jmp 0x1b9f7ab
addq $0x20, %rbx
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1b9afae
leaq 0x33735a9(%rip), %rax # 0x4f12d38
movl (%rax), %ebp
jmp 0x1b9f7b5
leaq 0x33735c2(%rip), %rax # 0x4f12d5c
movb (%rax), %al
movb %al, 0x18(%rbx)
leaq 0x33735b7(%rip), %rax # 0x4f12d5d
movb (%rax), %al
movb %al, 0x38(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x1b9b0b8
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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(b), MP_NUMER_P(c))) !=
MP_OK) {
return res;
}
if ((res = mp_int_copy(MP_DENOM_P(a), MP_DENOM_P(c))) != MP_OK) {
return res;
}
return s_rat_reduce(c);
} else {
mpz_t temp[2];
int last = 0;
SETUP(mp_int_init_copy(TEMP(last), MP_NUMER_P(a)), last);
SETUP(mp_int_init_copy(TEMP(last), MP_NUMER_P(b)), last);
if ((res = mp_int_mul(TEMP(0), MP_DENOM_P(b), TEMP(0))) != MP_OK) {
goto CLEANUP;
}
if ((res = mp_int_mul(TEMP(1), MP_DENOM_P(a), TEMP(1))) != MP_OK) {
goto CLEANUP;
}
if ((res = (comb_f)(TEMP(0), TEMP(1), MP_NUMER_P(c))) != MP_OK) {
goto CLEANUP;
}
res = mp_int_mul(MP_DENOM_P(a), MP_DENOM_P(b), MP_DENOM_P(c));
CLEANUP:
while (--last >= 0) {
mp_int_clear(TEMP(last));
}
if (res == MP_OK) {
return s_rat_reduce(c);
} else {
return res;
}
}
}
|
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 %r15, %rsi
callq 0x1b9ae8e
movl %eax, %r15d
leaq 0x3373253(%rip), %rax # 0x4f12d38
movl (%rax), %ebx
cmpl %ebx, %r15d
movq %r13, (%rsp)
jne 0x1b9fba4
leaq 0x30(%rsp), %rdi
movq %rbp, %rsi
callq 0x1b9ae8e
cmpl %ebx, %eax
jne 0x1b9fbac
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rdi, %rdx
callq 0x1b9b709
movl $0x2, %r13d
cmpl %ebx, %eax
jne 0x1b9fb60
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
movq %rdi, %rdx
callq 0x1b9b709
cmpl %ebx, %eax
jne 0x1b9fb60
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq (%rsp), %rdx
callq *0x8(%rsp)
cmpl %ebx, %eax
jne 0x1b9fb60
movq (%rsp), %rax
leaq 0x20(%rax), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x1b9b709
movl %eax, %ebp
jmp 0x1b9fbb4
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq *%rbx
movl %eax, %ebp
leaq 0x33731c0(%rip), %rax # 0x4f12d38
movl (%rax), %ebx
cmpl %ebx, %ebp
jne 0x1b9fbf2
leaq 0x20(%r13), %rsi
movq %r12, %rdi
callq 0x1b9b015
cmpl %ebx, %eax
jne 0x1b9fbf0
movq %r13, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b9f6c1
xorl %r13d, %r13d
movl %r15d, %ebp
jmp 0x1b9fbb4
movl %eax, %ebp
movl $0x1, %r13d
cmpl %ebx, %r15d
jne 0x1b9fbe3
leaq 0x1(%r13), %r15
shll $0x5, %r13d
leaq 0x10(%rsp), %rax
leaq (%rax,%r13), %r14
addq $-0x20, %r14
movq %r14, %rdi
callq 0x1b9b0b8
decq %r15
addq $-0x20, %r14
cmpq $0x1, %r15
jg 0x1b9fbce
cmpl %ebx, %ebp
jne 0x1b9fbf2
movq (%rsp), %rdi
callq 0x1b9f6c1
movl %eax, %ebp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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++;
return 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
retq
callq 0x78900c
|
/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 %ebp, 0x1c(%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0x1ba6526
movq %rbx, %rdi
callq 0x780910
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
|
/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].FIELD));
return dup;
}
|
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
xorl %r12d, %r12d
movq -0x8(%r15), %rdi
callq 0x1b10b72
movq (%r15), %rdx
testq %rdx, %rdx
je 0x1ba7f63
incl (%rdx)
jmp 0x1ba7f65
xorl %edx, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1ba7d0e
movq %rax, %r14
incq %r12
movslq 0x10(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x1ba7f4e
jmp 0x1ba7f88
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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;
if (equal_params)
return isl_stat_ok;
if (FN(ARG1,check_named_params)(*obj1) < 0 ||
FN(ARG2,check_named_params)(*obj2) < 0)
goto error;
*obj1 = FN(ARG1,align_params)(*obj1, FN(ARG2,get_space)(*obj2));
*obj2 = FN(ARG2,align_params)(*obj2, FN(ARG1,get_space)(*obj1));
if (!*obj1 || !*obj2)
goto error;
return isl_stat_ok;
error:
*obj1 = FN(ARG1,free)(*obj1);
*obj2 = FN(ARG2,free)(*obj2);
return isl_stat_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 0x1baa071
xorl %r15d, %r15d
testl %eax, %eax
jne 0x1baa090
movq (%r14), %rax
testq %rax, %rax
je 0x1ba9ff6
movq 0x8(%rax), %rdi
jmp 0x1ba9ff8
xorl %edi, %edi
callq 0x1b73e26
testl %eax, %eax
js 0x1baa071
movq (%rbx), %rax
testq %rax, %rax
je 0x1baa00f
movq 0x8(%rax), %rdi
jmp 0x1baa011
xorl %edi, %edi
callq 0x1b73e26
testl %eax, %eax
js 0x1baa071
movq (%r14), %r15
movq (%rbx), %rax
testq %rax, %rax
je 0x1baa02b
movq 0x8(%rax), %rdi
jmp 0x1baa02d
xorl %edi, %edi
callq 0x1b6fd4e
movq %r15, %rdi
movq %rax, %rsi
callq 0x1ba8186
movq %rax, (%r14)
movq (%rbx), %r12
xorl %r15d, %r15d
testq %rax, %rax
je 0x1baa051
movq 0x8(%rax), %rdi
jmp 0x1baa053
xorl %edi, %edi
callq 0x1b6fd4e
movq %r12, %rdi
movq %rax, %rsi
callq 0x1ba8186
movq %rax, (%rbx)
cmpq $0x0, (%r14)
je 0x1baa071
testq %rax, %rax
jne 0x1baa090
movq (%r14), %rdi
callq 0x1ba649c
xorl %r15d, %r15d
movq %r15, (%r14)
movq (%rbx), %rdi
callq 0x1ba649c
movq %r15, (%rbx)
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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)));
if (!res)
return FN(PW,free)(pw);
res->size = n;
return res;
}
res = FN(PW,alloc_size)(isl_space_copy(pw->dim) OPT_TYPE_ARG(pw->), n);
if (!res)
return FN(PW,free)(pw);
for (i = 0; i < pw->n; ++i)
res = FN(PW,add_piece)(res, isl_set_copy(pw->p[i].set),
FN(EL,copy)(pw->p[i].FIELD));
FN(PW,free)(pw);
return res;
}
|
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
shlq $0x4, %rdx
addq $0x20, %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1af82fa
testq %rax, %rax
je 0x1baa171
movslq %r14d, %rcx
movq %rcx, 0x18(%rax)
movq %rax, %rbx
jmp 0x1baa17b
movq 0x8(%rbx), %rdi
callq 0x1b6fd4e
movl 0x4(%rbx), %esi
movq %rax, %rdi
movl %r14d, %edx
callq 0x1ba7c15
testq %rax, %rax
je 0x1baa171
movq %rax, %r14
cmpl $0x0, 0x10(%rbx)
jle 0x1baa164
leaq 0x28(%rbx), %r15
xorl %r12d, %r12d
movq -0x8(%r15), %rdi
callq 0x1b10b72
movq (%r15), %rdx
testq %rdx, %rdx
je 0x1baa144
incl (%rdx)
jmp 0x1baa146
xorl %edx, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1ba7c9e
movq %rax, %r14
incq %r12
movslq 0x10(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x1baa12f
movq %rbx, %rdi
callq 0x1ba649c
movq %r14, %rbx
jmp 0x1baa17b
movq %rbx, %rdi
callq 0x1ba649c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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 # 0x1bab1dd
leaq 0x8(%rsp), %rcx
callq 0x1afdf5a
movl %eax, %ebp
jmp 0x1badbae
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x1b0fdb2
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
|
/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_shift_point_loops(ctx)) {
isl_multi_val_free(sizes);
return band;
}
band = isl_schedule_band_cow(band);
if (!band)
goto error;
scaled = isl_schedule_band_get_partial_schedule(tile);
if (!isl_options_get_tile_scale_tile_loops(ctx))
scaled = isl_multi_union_pw_aff_scale_multi_val(scaled, sizes);
else
isl_multi_val_free(sizes);
band->mupa = isl_multi_union_pw_aff_sub(band->mupa, scaled);
if (!band->mupa)
return isl_schedule_band_free(band);
return band;
error:
isl_schedule_band_free(band);
isl_multi_val_free(sizes);
return NULL;
}
|
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 $0x1, %eax
je 0x1bb14aa
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1bb0500
movq %rax, %rbx
testq %rbx, %rbx
je 0x1bb14cd
testq %r12, %r12
je 0x1bb14f0
movq 0x18(%r12), %rdi
callq 0x1acc7e8
movq %rax, %r12
jmp 0x1bb14f3
movq %r14, %rdi
callq 0x1b95d6a
jmp 0x1bb14e1
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0x1bb04b2
movq %r14, %rdi
callq 0x1b95d6a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x1b38f9e
testl %eax, %eax
je 0x1bb1509
movq %r14, %rdi
callq 0x1b95d6a
jmp 0x1bb1517
movq %r12, %rdi
movq %r14, %rsi
callq 0x1ace08b
movq %rax, %r12
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0x1acdf1e
movq %rax, 0x18(%rbx)
testq %rax, %rax
jne 0x1bb14e1
movq %rbx, %rdi
callq 0x1bb04b2
jmp 0x1bb14df
|
/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 =
isl_union_set_align_params(band->ast_build_options, space);
if (!band->mupa || !band->ast_build_options)
return isl_schedule_band_free(band);
return band;
error:
isl_space_free(space);
isl_schedule_band_free(band);
return NULL;
}
|
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 0x1bb1755
movq 0x18(%rbx), %r15
movq %r14, %rdi
callq 0x1b6fd4e
movq %r15, %rdi
movq %rax, %rsi
callq 0x1acca6c
movq %rax, 0x18(%rbx)
movq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x1b8cf65
movq %rax, 0x28(%rbx)
cmpq $0x0, 0x18(%rbx)
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
cmpb $0x1, %al
je 0x1bb175d
jmp 0x1bb1767
movq %r14, %rdi
callq 0x1b6fe0a
movq %rbx, %rdi
callq 0x1bb04b2
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/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,
upma);
if (!band->mupa)
return isl_schedule_band_free(band);
return band;
error:
isl_union_pw_multi_aff_free(upma);
isl_schedule_band_free(band);
return NULL;
}
|
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 0x1bb17c0
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1ad024b
movq %rax, 0x18(%rbx)
testq %rax, %rax
jne 0x1bb17d2
jmp 0x1bb17c8
movq %r14, %rdi
callq 0x1ab0607
movq %rbx, %rdi
callq 0x1bb04b2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 0x1bb190c
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
|
/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 -0x28(,%rax,8), %r13
testq %r13, %r13
sete %bpl
je 0x1bc109b
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1bb78fa
addq $0x28, %r14
addq $-0x28, %r13
cmpq $0x0, (%rbx)
je 0x1bc106e
testb %bpl, %bpl
je 0x1bc10a2
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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)
movq %rdx, 0x8(%rax)
movq %rsp, %rbx
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x807990
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1bc29f0
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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
testq %rdi, %rdi
je 0x1bc2fea
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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
testq %rdi, %rdi
je 0x1bc313c
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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
movq %rbx, %rsi
callq 0x807990
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1bc4d26
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x1bc4dc6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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, %rsi
callq 0x807990
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1bc5170
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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,
// causing terrible compile times.
return ModuleToFunctionPassAdaptor(
std::unique_ptr<ModuleToFunctionPassAdaptor::PassConceptT>(
new PassModelT(std::forward<FunctionPassT>(Pass))),
EagerlyInvalidate);
}
|
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 %xmm0, %xmm0
movaps %xmm0, (%r14)
xorl %ecx, %ecx
movl %ecx, 0x10(%r14)
movq 0x30(%r15), %rdx
movq %rdx, (%r14)
movq %rcx, 0x30(%r15)
movl 0x38(%r15), %esi
movl %esi, 0x8(%r14)
movl %ecx, 0x38(%r15)
movl 0x3c(%r15), %edi
movl 0x40(%r15), %r8d
movq 0xc(%r14), %r9
movl %edi, 0xc(%r14)
movl %r8d, 0x10(%r14)
movq %r9, 0x3c(%r15)
leaq 0x3cbdf75(%rip), %r9 # 0x58836d0
addq $0x10, %r9
movq %r9, (%rax)
movups (%r15), %xmm1
movups 0x10(%r15), %xmm2
movups 0x20(%r15), %xmm3
movups %xmm1, 0x8(%rax)
movups %xmm2, 0x18(%rax)
movups %xmm3, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movl %ecx, 0x48(%rax)
movq %rdx, 0x38(%rax)
movq %rcx, (%r14)
movl %esi, 0x40(%rax)
movl %ecx, 0x8(%r14)
movq 0x44(%rax), %rcx
movl %edi, 0x44(%rax)
movl %r8d, 0x48(%rax)
movq %rcx, 0xc(%r14)
movq %rax, (%rbx)
movb %bpl, 0x8(%rbx)
movq %r14, %rdi
callq 0x1be8f5e
movq (%r14), %rdi
movl 0x10(%r14), %eax
shlq $0x3, %rax
leaq (%rax,%rax,8), %rsi
movl $0x8, %edx
callq 0x2b410f1
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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::BasicBlockSectionsProfileReaderAnalysis>>(llvm::InvalidateAnalysisPass<llvm::BasicBlockSectionsProfileReaderAnalysis>&&)
|
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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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::BranchProbabilityAnalysis>>(llvm::InvalidateAnalysisPass<llvm::BranchProbabilityAnalysis>&&)
|
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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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::RequireAnalysisPass<llvm::DebugAssignmentTrackingAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function>>>(llvm::RequireAnalysisPass<llvm::DebugAssignmentTrackingAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function>>&&)
|
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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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::DebugAssignmentTrackingAnalysis>>(llvm::InvalidateAnalysisPass<llvm::DebugAssignmentTrackingAnalysis>&&)
|
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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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, %rsi
callq 0xadff9e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1bdb6ba
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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)::RequireAllMachineFunctionPropertiesPass>((anonymous namespace)::RequireAllMachineFunctionPropertiesPass&&)
|
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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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, %rsp
popq %rbx
popq %r14
retq
|
/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), %rcx # 0x587f6a8
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
|
/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
leaq 0x3c81c03(%rip), %rax # 0x587fa70
addq $0x10, %rax
movq %rax, (%r15)
leaq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0x1bfe072
movq %r12, %rdi
callq 0x1bfdeac
movq %r15, (%rbx)
movq %r14, %rdi
callq 0x1bfdeac
movq %rbx, %rax
addq $0x3b8, %rsp # imm = 0x3B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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 %rdi, -0x38(%rsi)
movq 0x18(%r14), %r8
movq %r8, -0x30(%rsi)
movq 0x20(%r14), %r9
movq %r9, -0x28(%rsi)
movq %rsi, -0x20(%rsi)
movq %rsi, -0x18(%rsi)
movl $0x10, %r10d
movq %r10, -0x10(%rsi)
xorl %r11d, %r11d
movl %r11d, -0x8(%rsi)
leaq 0x3c8003d(%rip), %rsi # 0x587fff0
addq %r10, %rsi
movq %rsi, (%rax)
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rdi, 0x18(%rax)
movq %r8, 0x20(%rax)
movq %r9, 0x28(%rax)
leaq 0x50(%rax), %rcx
movq %rcx, 0x30(%rax)
movq %rcx, 0x38(%rax)
movq %r10, 0x40(%rax)
movl %r11d, 0x48(%rax)
movq %rax, (%rbx)
movq 0x30(%r14), %rdi
cmpq 0x28(%r14), %rdi
je 0x1bffff3
callq 0x780910
movq %rbx, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r14
retq
nop
|
/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 # 0x5880360
addq $0x10, %rax
movq %rax, (%r15)
leaq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0x1d4de5e
movq %r12, %rdi
callq 0x1d4fd06
movq %r15, (%rbx)
movq %r14, %rdi
callq 0x1d4fd06
movq %rbx, %rax
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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, llvm::LoopStandardAnalysisResults&>::Invalidator, llvm::LoopStandardAnalysisResults&>>>, llvm::DenseMapInfo<llvm::AnalysisKey*, void>, llvm::detail::DenseMapPair<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, llvm::LoopStandardAnalysisResults&>::Invalidator, llvm::LoopStandardAnalysisResults&>>>>>::grow(unsigned int)
|
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->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
}
|
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, %ecx
orl %eax, %ecx
incl %ecx
cmpl $0x41, %ecx
movl $0x40, %edi
cmovael %ecx, %edi
movl %edi, 0x10(%r15)
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%r15)
testq %r14, %r14
je 0x1c02574
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c0263c
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2b410f1
movq $0x0, 0x8(%r15)
movl 0x10(%r15), %ecx
testq %rcx, %rcx
je 0x1c02635
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x10, %rax
xorl %edx, %edx
movdqa 0xfb2a62(%rip), %xmm1 # 0x2bb5020
movdqa 0xfb2a6a(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x1c02612
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1c02628
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x1c025ce
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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
callq 0x2aa1dc0
movq 0x18(%rbx), %rax
cmpq $-0x2000, %rax # imm = 0xE000
je 0x1c02cac
cmpq $-0x1000, %rax # imm = 0xF000
je 0x1c02cac
testq %rax, %rax
je 0x1c02cac
leaq 0x8(%rbx), %rdi
callq 0x2aa1dc0
movl $0x80, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x7800d0
retq
nop
|
/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::LoopStandardAnalysisResults&>::Invalidator&)
|
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 0x7f9ba8
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x1c038eb
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0x3e, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
movl $0x3e, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2b7d68e
nop
|
/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)
movq %rax, 0x40(%rbx)
movl %ecx, 0x48(%rbx)
leaq 0x3da2b4e(%rip), %rdx # 0x59a68b8
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xade436
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
|
/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 << "label=";
if (RenderUsingHTML) {
// Count the numbewr of edges out of the node to determine how
// many columns to span (max 64)
unsigned ColSpan = 0;
child_iterator EI = GTraits::child_begin(Node);
child_iterator EE = GTraits::child_end(Node);
for (; EI != EE && ColSpan != 64; ++EI, ++ColSpan)
;
if (ColSpan == 0)
ColSpan = 1;
// Include truncated messages when counting.
if (EI != EE)
++ColSpan;
O << "<<table border=\"0\" cellborder=\"1\" cellspacing=\"0\""
<< " cellpadding=\"0\"><tr><td align=\"text\" colspan=\"" << ColSpan
<< "\">";
} else
O << "\"{";
if (!DTraits.renderGraphFromBottomUp()) {
if (RenderUsingHTML)
O << DTraits.getNodeLabel(Node, G) << "</td>";
else
O << DOT::EscapeString(DTraits.getNodeLabel(Node, G));
// If we should include the address of the node in the label, do so now.
std::string Id = DTraits.getNodeIdentifierLabel(Node, G);
if (!Id.empty())
O << "|" << DOT::EscapeString(Id);
std::string NodeDesc = DTraits.getNodeDescription(Node, G);
if (!NodeDesc.empty())
O << "|" << DOT::EscapeString(NodeDesc);
}
std::string edgeSourceLabels;
raw_string_ostream EdgeSourceLabels(edgeSourceLabels);
bool hasEdgeSourceLabels = getEdgeSourceLabels(EdgeSourceLabels, Node);
if (hasEdgeSourceLabels) {
if (!DTraits.renderGraphFromBottomUp())
if (!RenderUsingHTML)
O << "|";
if (RenderUsingHTML)
O << edgeSourceLabels;
else
O << "{" << edgeSourceLabels << "}";
if (DTraits.renderGraphFromBottomUp())
if (!RenderUsingHTML)
O << "|";
}
if (DTraits.renderGraphFromBottomUp()) {
if (RenderUsingHTML)
O << DTraits.getNodeLabel(Node, G);
else
O << DOT::EscapeString(DTraits.getNodeLabel(Node, G));
// If we should include the address of the node in the label, do so now.
std::string Id = DTraits.getNodeIdentifierLabel(Node, G);
if (!Id.empty())
O << "|" << DOT::EscapeString(Id);
std::string NodeDesc = DTraits.getNodeDescription(Node, G);
if (!NodeDesc.empty())
O << "|" << DOT::EscapeString(NodeDesc);
}
if (DTraits.hasEdgeDestLabels()) {
O << "|{";
unsigned i = 0, e = DTraits.numEdgeDestLabels(Node);
for (; i != e && i != 64; ++i) {
if (i) O << "|";
O << "<d" << i << ">"
<< DOT::EscapeString(DTraits.getEdgeDestLabel(Node, i));
}
if (i != e)
O << "|<d64>truncated...";
O << "}";
}
if (RenderUsingHTML)
O << "</tr></table>>";
else
O << "}\"";
O << "];\n"; // Finish printing the "node" line
// Output all of the edges now
child_iterator EI = GTraits::child_begin(Node);
child_iterator EE = GTraits::child_end(Node);
for (unsigned i = 0; EI != EE && i != 64; ++EI, ++i)
if (!DTraits.isNodeHidden(*EI, G))
writeEdge(Node, i, EI);
for (; EI != EE; ++EI)
if (!DTraits.isNodeHidden(*EI, G))
writeEdge(Node, 64, EI);
}
|
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, %rsi
callq 0x2b7d64e
leaq 0x232f86b(%rip), %rsi # 0x3f3ba72
movl $0x8, %edx
movq %rax, %rdi
callq 0x7f9ba8
movq (%r14), %rdi
cmpb $0x1, 0x10(%r14)
jne 0x1c0c22c
leaq 0x33b26b2(%rip), %rsi # 0x4fbe8d7
movl $0x5, %edx
jmp 0x1c0c238
leaq 0x232f848(%rip), %rsi # 0x3f3ba7b
movl $0x7, %edx
callq 0x7f9ba8
movq 0x28(%rsp), %rdx
testq %rdx, %rdx
je 0x1c0c268
movq (%r14), %rdi
movq 0x20(%rsp), %rsi
callq 0x2b7d704
leaq 0x1c0488e(%rip), %rsi # 0x3810ae9
movl $0x1, %edx
movq %rax, %rdi
callq 0x7f9ba8
movq (%r14), %rdi
leaq 0x232f811(%rip), %rsi # 0x3f3ba83
movl $0x6, %edx
callq 0x7f9ba8
cmpb $0x1, 0x10(%r14)
jne 0x1c0c2b0
movl 0x20(%rbx), %eax
testq %rax, %rax
setne %cl
je 0x1c0c2c1
leaq -0x8(,%rax,8), %rdx
xorl %esi, %esi
leal 0x1(%rsi), %eax
testq %rdx, %rdx
setne %cl
je 0x1c0c2c3
addq $-0x8, %rdx
cmpl $0x3f, %esi
movl %eax, %esi
jne 0x1c0c298
jmp 0x1c0c2c3
movq (%r14), %rdi
leaq 0x232f835(%rip), %rsi # 0x3f3baef
movl $0x2, %edx
jmp 0x1c0c30f
xorl %eax, %eax
cmpl $0x1, %eax
movzbl %cl, %r15d
adcl %eax, %r15d
movq (%r14), %rdi
leaq 0x232f7b3(%rip), %rsi # 0x3f3ba8a
movl $0x31, %edx
callq 0x7f9ba8
leaq 0x232f7d4(%rip), %rsi # 0x3f3babc
movl $0x2f, %edx
movq %rax, %rdi
callq 0x7f9ba8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2b7d110
leaq 0x232f7e5(%rip), %rsi # 0x3f3baec
movl $0x2, %edx
movq %rax, %rdi
callq 0x7f9ba8
movq (%r14), %r15
cmpb $0x1, 0x10(%r14)
jne 0x1c0c377
leaq 0x11(%r14), %rsi
movq 0x8(%r14), %rax
movq (%rax), %rax
movq 0x48(%rax), %rcx
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x1c0b040
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x2b7d704
leaq 0x332d2f3(%rip), %rsi # 0x4f39648
movl $0x5, %edx
movq %rax, %rdi
callq 0x7f9ba8
movq (%r12), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x1c0c3ea
movq 0x50(%rsp), %rsi
jmp 0x1c0c3e2
leaq 0x11(%r14), %rsi
movq 0x8(%r14), %rax
movq (%rax), %rax
movq 0x48(%rax), %rcx
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x1c0b040
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2b34c95
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r15, %rdi
callq 0x2b7d704
movq (%r13), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x1c0c3cf
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x7800d0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c0c3ea
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7800d0
leaq 0x50(%rsp), %rdi
movq %rdi, -0x10(%rdi)
movq $0x0, -0x8(%rdi)
movb $0x0, (%rdi)
movb $0x1, %al
testb %al, %al
jne 0x1c0c411
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x7800d0
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x40(%rsp), %r15
movl $0x0, 0x8(%r15)
movb %al, 0x28(%r15)
movl $0x1, 0x2c(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
leaq 0x3cedb32(%rip), %rax # 0x58f9f80
addq $0x10, %rax
movq %rax, (%r15)
movq %rsp, %rax
movq %rax, 0x30(%r15)
movq %r15, %rdi
callq 0x7fa22e
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1c0c5d6
testb %al, %al
je 0x1c0c4e1
cmpb $0x0, 0x10(%r14)
jne 0x1c0c491
movq (%r14), %rdi
leaq 0x34a6286(%rip), %rsi # 0x50b270d
movl $0x1, %edx
callq 0x7f9ba8
movq (%r14), %rdi
cmpb $0x1, 0x10(%r14)
jne 0x1c0c4ab
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2b7d704
jmp 0x1c0c4e1
leaq 0x2cf0ddf(%rip), %rsi # 0x48fd291
movl $0x1, %edx
callq 0x7f9ba8
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0x2b7d704
leaq 0x2cef1a4(%rip), %rsi # 0x48fb678
movl $0x1, %edx
movq %rax, %rdi
callq 0x7f9ba8
movq (%r14), %rdi
cmpb $0x1, 0x10(%r14)
jne 0x1c0c4f9
leaq 0x232f600(%rip), %rsi # 0x3f3baf2
movl $0xe, %edx
jmp 0x1c0c505
leaq 0x232f601(%rip), %rsi # 0x3f3bb01
movl $0x2, %edx
callq 0x7f9ba8
movq (%r14), %rdi
leaq 0x235e31f(%rip), %rsi # 0x3f6a833
movl $0x3, %edx
callq 0x7f9ba8
movq 0x18(%rbx), %r15
movl 0x20(%rbx), %eax
leaq (%r15,%rax,8), %rbp
testq %rax, %rax
je 0x1c0c57e
leaq -0x8(,%rax,8), %r13
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
movq %r15, %rcx
callq 0x1c0c624
addq $0x8, %r15
testq %r13, %r13
je 0x1c0c57e
leal 0x1(%r12), %eax
addq $-0x8, %r13
cmpl $0x3f, %r12d
movl %eax, %r12d
jne 0x1c0c539
jmp 0x1c0c57e
movq %r14, %rdi
movq %rbx, %rsi
movl $0x40, %edx
movq %r15, %rcx
callq 0x1c0c624
addq $0x8, %r15
cmpq %rbp, %r15
jne 0x1c0c567
leaq 0x40(%rsp), %rdi
callq 0x2b7e98e
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1c0c5a8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7800d0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x1c0c5c4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7800d0
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 Offset =
(unsigned)std::distance(GTraits::child_begin(TargetNode), TargetIt);
DestPort = static_cast<int>(Offset);
}
if (DTraits.getEdgeSourceLabel(Node, EI).empty())
edgeidx = -1;
emitEdge(static_cast<const void*>(Node), edgeidx,
static_cast<const void*>(TargetNode), DestPort,
DTraits.getEdgeAttributes(Node, EI, G));
}
}
|
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
movq (%rbx), %rdi
cmpq %r14, %rdi
je 0x1c0c675
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7800d0
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
|
/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 have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (CurSize >= RHSSize) {
// Assign common elements.
iterator NewEnd = this->begin();
if (RHSSize)
NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd);
// Destroy excess elements and trim the bounds.
this->destroy_range(NewEnd, this->end());
this->set_size(RHSSize);
// Clear the RHS.
RHS.clear();
return *this;
}
// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
// FIXME: this may not actually make any sense if we can efficiently move
// elements.
if (this->capacity() < RHSSize) {
// Destroy current elements.
this->clear();
CurSize = 0;
this->grow(RHSSize);
} else if (CurSize) {
// Otherwise, use assignment for the already-constructed elements.
std::move(RHS.begin(), RHS.begin()+CurSize, this->begin());
}
// Move-construct the new elements in place.
this->uninitialized_move(RHS.begin()+CurSize, RHS.end(),
this->begin()+CurSize);
// Set end.
this->set_size(RHSSize);
RHS.clear();
return *this;
}
|
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)
jae 0x1c0d7fa
movl $0x0, 0x8(%rbx)
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2b4ed86
jmp 0x1c0d81f
testl %r15d, %r15d
je 0x1c0d840
movq (%rbx), %rcx
leaq 0x1(%r15), %rdx
xorl %esi, %esi
movq (%rax,%rsi), %rdi
movq %rdi, (%rcx,%rsi)
decq %rdx
addq $0x8, %rsi
cmpq $0x1, %rdx
jg 0x1c0d7e3
jmp 0x1c0d840
testq %rdi, %rdi
je 0x1c0d81f
movq (%rbx), %rcx
leaq 0x1(%rdi), %rdx
xorl %esi, %esi
movq (%rax,%rsi), %r8
movq %r8, (%rcx,%rsi)
decq %rdx
addq $0x8, %rsi
cmpq $0x1, %rdx
jg 0x1c0d808
jmp 0x1c0d821
xorl %edi, %edi
movl 0x8(%r14), %edx
subq %rdi, %rdx
je 0x1c0d840
shlq $0x3, %rdi
movq (%r14), %rsi
addq %rdi, %rsi
addq (%rbx), %rdi
shlq $0x3, %rdx
callq 0x780890
movl %r15d, 0x8(%rbx)
movl $0x0, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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 0x7f9ba8
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x1c171f5
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0x3e, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
movl $0x3e, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2b7d68e
nop
|
/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)
movq %rax, 0x40(%rbx)
movl %ecx, 0x48(%rbx)
leaq 0x3d8d538(%rip), %rdx # 0x59a68b8
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xade436
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
|
/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)
movq %rax, 0x40(%rbx)
movl %ecx, 0x48(%rbx)
leaq 0x3d8d1e0(%rip), %rdx # 0x59a68b8
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xade436
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
|
/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 0x7f9ba8
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x1c19dfd
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0x3e, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
movl $0x3e, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2b7d68e
nop
|
/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 0x7f9ba8
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x1c1aa71
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0x3e, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
movl $0x3e, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2b7d68e
nop
|
/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 0x7f9ba8
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x1c1c1a5
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0x3e, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
movl $0x3e, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2b7d68e
nop
|
/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)
movq %rax, 0x40(%rbx)
movl %ecx, 0x48(%rbx)
leaq 0x3d88cfc(%rip), %rdx # 0x59a68b8
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xade436
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
|
/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 0x7f9ba8
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x1c1e2e1
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0x3e, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
movl $0x3e, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2b7d68e
nop
|
/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 0x7f9ba8
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x1c1e639
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0x3e, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
movl $0x3e, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2b7d68e
nop
|
/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.