name string | code string | asm string | file string |
|---|---|---|---|
llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::InstructionCost>* llvm::DenseMapBase<llvm::SmallDenseMap<llvm::BasicBlock*, llvm::InstructionCost, 4u, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::InstructionCost>>, llvm::BasicBlock*, llvm::InstructionCost, llvm::D... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdi), %edx
movl %edx, %ecx
shrl %ecx
movl $0x4, %esi
testb $0x1, %dl
jne 0x2587d73
movl 0x10(%rbx), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x2587daa
notl %ecx
addl %esi, %ecx
subl ... | /llvm/ADT/DenseMap.h |
bool llvm::concat_iterator<llvm::BasicBlock* const, llvm::BasicBlock* const*, llvm::BasicBlock* const*, llvm::BasicBlock**>::incrementHelper<2ul>() | bool incrementHelper() {
auto &Begin = std::get<Index>(Begins);
auto &End = std::get<Index>(Ends);
if (Begin == End)
return false;
++Begin;
return true;
} | movq (%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq %rcx, %rax
je 0x258a733
leaq 0x8(%rax), %rdx
movq %rdx, (%rdi)
cmpq %rcx, %rax
setne %al
retq
| /llvm/ADT/STLExtras.h |
void llvm::SmallVectorImpl<llvm::WeakVH>::append<llvm::SmallPtrSetIterator<llvm::BasicBlock*>, void>(llvm::SmallPtrSetIterator<llvm::BasicBlock*>, llvm::SmallPtrSetIterator<llvm::BasicBlock*>) | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
xorl %ebp, %ebp
cmpq %rcx, %rsi
je 0x258d64d
movq %r13, %rax
addq $0x8, %rax
cmpq %r12, %rax
je 0x258d645
cmpq $-0x2, (%rax)
jae 0x258d636
incq %rbp
cmpq %r15, %rax... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::StructurizeCFG::init(llvm::Region*) | void StructurizeCFG::init(Region *R) {
LLVMContext &Context = R->getEntry()->getContext();
Boolean = Type::getInt1Ty(Context);
BoolTrue = ConstantInt::getTrue(Context);
BoolFalse = ConstantInt::getFalse(Context);
BoolPoison = PoisonValue::get(Boolean);
this->UA = nullptr;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
andq $-0x8, %rdi
callq 0x19b8816
movq %rax, %r14
movq %rax, %rdi
callq 0x1a89f26
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x19d30da
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x19d315e
movq %rax, 0x10(%rbx)
movq (%rbx), %rdi
callq 0x19d3b52
movq %rax, 0x... | /Transforms/Scalar/StructurizeCFG.cpp |
llvm::detail::DenseSetPair<llvm::RegionNode*>* llvm::DenseMapBase<llvm::SmallDenseMap<llvm::RegionNode*, llvm::detail::DenseSetEmpty, 4u, llvm::DenseMapInfo<llvm::RegionNode*, void>, llvm::detail::DenseSetPair<llvm::RegionNode*>>, llvm::RegionNode*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::RegionNode*, voi... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdi), %edx
movl %edx, %ecx
shrl %ecx
movl $0x4, %esi
testb $0x1, %dl
jne 0x2594bcd
movl 0x10(%rbx), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x2594c04
notl %ecx
addl %esi, %ecx
subl ... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<llvm::RegionNode*, llvm::detail::DenseSetEmpty, 4u, llvm::DenseMapInfo<llvm::RegionNode*, void>, llvm::detail::DenseSetPair<llvm::RegionNode*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
if (AtLeast > InlineBuckets)
AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
if (Small) {
// First move the inline buckets into a temporary storage.
AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
BucketT *TmpBegin = reinterpret_cast<Bu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x5, %esi
jb 0x2594c6b
decl %ebp
movl %ebp, %eax
shrl %eax
orl %ebp, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::MapVector<llvm::PHINode*, llvm::SmallVector<std::pair<llvm::BasicBlock*, llvm::Value*>, 2u>, llvm::DenseMap<llvm::PHINode*, unsigned int, llvm::DenseMapInfo<llvm::PHINode*, void>, llvm::detail::DenseMapPair<llvm::PHINode*, unsigned int>>, llvm::SmallVector<std::pair<l... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x25966d9
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /llvm/ADT/DenseMap.h |
matchAndOrChain(llvm::Value*, MaskOps&) | static bool matchAndOrChain(Value *V, MaskOps &MOps) {
Value *Op0, *Op1;
if (MOps.MatchAndChain) {
// Recurse through a chain of 'and' operands. This requires an extra check
// vs. the 'or' matcher: we must find an "and X, 1" instruction somewhere
// in the chain to know that all of the high bits are cl... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x18(%rsi)
jne 0x259f953
leaq 0x8(%rsp), %rax
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq %r14, %rsi
callq 0xf1f0bc
testb %al, %al
je 0x259f99a
movb $0x1, 0x19(%rbx)
movq 0x8(%rsp), %rdi
movq %r... | /Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp |
isl_aff_list_check_index | static isl_stat FN(LIST(EL),check_index)(__isl_keep LIST(EL) *list, int index)
{
if (!list)
return isl_stat_error;
if (index < 0 || index >= list->n)
isl_die(FN(LIST(EL),get_ctx)(list), isl_error_invalid,
"index out of bounds", return isl_stat_error);
return isl_stat_ok;
} | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x25a38a2
testl %esi, %esi
js 0x25a3876
xorl %eax, %eax
cmpl %esi, 0x10(%rdi)
jg 0x25a38a2
pushq %rax
movq 0x8(%rdi), %rdi
leaq 0x291452b(%rip), %rdx # 0x4eb7dad
leaq 0x2a7f28d(%rip), %rcx # 0x5022b16
movl $0x5, %esi
movl $0x89, %r8d
callq 0x25eea5... | /External/isl/isl_list_templ.c |
isl_aff_list_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 0x25a4075
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x32e89d9(%rip), %rax # 0x588ca20
movq (%rax), %rsi
callq 0x26471d7
movq %rax, %rdi
xorl %esi, %esi
callq 0x26475ab
movq %rax, %rdi
movq %rbx, %rsi
callq 0x25a3fb5
movq %rax, %rdi
callq 0x26477e8
movq %rax, %rdi
popq %rbx
jmp 0x26472d2... | /External/isl/print_templ.c |
isl_aff_list_read_from_str | __isl_give TYPE *FN(isl,FN(TYPE_BASE,read_from_str))(isl_ctx *ctx,
const char *str)
{
TYPE *obj;
isl_stream *s = isl_stream_new_str(ctx, str);
if (!s)
return NULL;
obj = FN(isl_stream_read,TYPE_BASE)(s);
isl_stream_free(s);
return obj;
} | pushq %r14
pushq %rbx
pushq %rax
callq 0x266b5b8
testq %rax, %rax
je 0x25a4182
movq %rax, %rbx
movq %rax, %rdi
callq 0x25a40ba
movq %rax, %r14
movq %rbx, %rdi
callq 0x266c325
movq %r14, %rax
jmp 0x25a4184
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /External/isl/isl_read_from_str_templ.c |
isl_aff_set_constant_val | __isl_give isl_aff *isl_aff_set_constant_val(__isl_take isl_aff *aff,
__isl_take isl_val *v)
{
if (!aff || !v)
goto error;
if (isl_aff_is_nan(aff)) {
isl_val_free(v);
return aff;
}
if (!isl_val_is_rat(v))
isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
"expecting rational value", goto error);
if (i... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x25a8c33
movq 0x10(%rbx), %rax
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x2662319
shrl $0x1f, %eax
movl %eax, %edi
callq 0x25ee9b4
testl %eax, %eax
je 0x25a8a2b
movq... | /External/isl/isl_aff.c |
isl_aff_add | __isl_give isl_aff *isl_aff_add(__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2)
{
isl_ctx *ctx;
int *exp1 = NULL;
int *exp2 = NULL;
isl_mat *div;
isl_size n_div1, n_div2;
if (!aff1 || !aff2)
goto error;
ctx = isl_aff_get_ctx(aff1);
if (!isl_space_is_equal(aff1->ls->dim, aff2->ls->dim))
isl_die(ctx, i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x25aadec
movq 0x8(%r14), %rdi
callq 0x26024b2
movq %rax, %r15
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rbx), %rax
movq 0x8(%rax), ... | /External/isl/isl_aff.c |
isl_union_pw_aff_find_part_entry | static struct isl_hash_table_entry *FN(UNION,find_part_entry)(
__isl_keep UNION *u, __isl_keep isl_space *space, int reserve)
{
isl_ctx *ctx;
uint32_t hash;
struct isl_hash_table_entry *entry;
isl_bool equal;
PART *part;
if (!u || !space)
return NULL;
ctx = FN(UNION,get_ctx)(u);
hash = isl_space_get_tuple_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x25afce1
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r14
movq %rsi, %rdi
callq 0x2669f15
leaq 0x10(%rbx), %rsi
leaq 0x1758e(%rip), %rcx # 0x25c71f5
m... | /External/isl/isl_union_single.c |
isl_pw_multi_aff_union_add_ | static __isl_give PW *FN(PW,union_add_)(__isl_take PW *pw1, __isl_take PW *pw2)
{
int i, j, n;
struct PW *res;
isl_ctx *ctx;
isl_set *set;
if (FN(PW,align_params_bin)(&pw1, &pw2) < 0)
goto error;
ctx = isl_space_get_ctx(pw1->dim);
if (!OPT_EQUAL_TYPES(pw1->, pw2->))
isl_die(ctx, isl_error_invalid,
"fold... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
leaq 0x10(%rsp), %rcx
movq %rsi, (%rcx)
movq %rax, %rdi
movq %rcx, %rsi
callq 0x25b850a
testl %eax, %eax
js 0x25b691a
movq 0x8(%rsp), %r15
movq 0x8(%r15), %rdi
callq 0x266606e
movq 0x10(%rsp), %rbx
... | /External/isl/isl_pw_templ.c |
isl_multi_aff_lift | __isl_give isl_multi_aff *isl_multi_aff_lift(__isl_take isl_multi_aff *maff,
__isl_give isl_local_space **ls)
{
int i;
isl_space *space;
isl_aff *aff;
isl_size n, n_div;
if (ls)
*ls = NULL;
n = isl_multi_aff_size(maff);
if (n < 0)
return isl_multi_aff_free(maff);
if (n == 0) {
if (ls) {
isl_space *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x25bca95
movq $0x0, (%r14)
testq %rbx, %rbx
je 0x25bcaa0
movl 0x10(%rbx), %r12d
jmp 0x25bcaa6
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
testl %r12d, %r12d
js 0x25bcbf4
je 0x25bcaf2
movq %rbx, %rdi
callq 0x2... | /External/isl/isl_aff.c |
isl_multi_union_pw_aff_restore_space | __isl_give MULTI(BASE) *FN(MULTI(BASE),restore_space)(
__isl_take MULTI(BASE) *multi, __isl_take isl_space *space)
{
if (!multi || !space)
goto error;
if (multi->space == space) {
isl_space_free(space);
return multi;
}
multi = FN(MULTI(BASE),cow)(multi);
if (!multi)
goto error;
isl_space_free(multi->sp... | 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 0x25c317d
cmpq %r14, 0x8(%rbx)
je 0x25c3171
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x25c315d
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x25c2fe9
movq %rax, %rbx
testq %rbx, %rbx
je... | /External/isl/isl_multi_templ.c |
isl_multi_union_pw_aff_check_has_explicit_domain | static isl_stat FN(MULTI(BASE),check_has_explicit_domain)(
__isl_keep MULTI(BASE) *multi)
{
if (!multi)
return isl_stat_error;
if (!FN(MULTI(BASE),has_explicit_domain)(multi))
isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_internal,
"expression does not have an explicit domain",
return isl_stat_error);
... | pushq %rbx
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x25c56c7
cmpl $0x0, 0x10(%rdi)
je 0x25c56c5
movq 0x8(%rdi), %rdi
callq 0x266606e
leaq 0x2a5e420(%rip), %rdx # 0x5023ac9
leaq 0x2a5e445(%rip), %rcx # 0x5023af5
movq %rax, %rdi
movl $0x4, %esi
movl $0x24, %r8d
callq 0x25eea52
jmp 0x25c56c... | /External/isl/isl_multi_explicit_domain.c |
isl_ast_build_set_executed | __isl_give isl_ast_build *isl_ast_build_set_executed(
__isl_take isl_ast_build *build, __isl_take isl_union_map *executed)
{
build = isl_ast_build_cow(build);
if (!build)
goto error;
isl_union_map_free(build->executed);
build->executed = executed;
return build;
error:
isl_ast_build_free(build);
isl_union_ma... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdi, %rdi
je 0x25cd5b0
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x25cd5b2
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x25cc570
movq %rax, %rbx
jmp 0x25cd5b2
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x25cd5cc
movq 0xc8(%rbx), %rdi
callq 0x26835eb
movq... | /External/isl/isl_ast_build.c |
isl_ast_build_get_stride_constraint | __isl_give isl_set *isl_ast_build_get_stride_constraint(
__isl_keep isl_ast_build *build)
{
isl_aff *aff;
isl_set *set;
isl_val *stride;
int pos;
if (!build)
return NULL;
pos = build->depth;
if (!isl_ast_build_has_stride(build, pos))
return isl_set_universe(isl_ast_build_get_space(build, 1));
stride = ... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x25cd916
movq %rdi, %r14
movl 0x8(%rdi), %ebx
movl %ebx, %esi
callq 0x25cd934
testl %eax, %eax
je 0x25cd91e
movq 0x40(%r14), %rdi
movl %ebx, %esi
callq 0x268eae5
movq %rax, %r15
movq 0x48(%r14), %rdi
movl %ebx, %esi
callq 0x25b2ec5
movq %rax, %rdi
movl $0x2, %esi
mo... | /External/isl/isl_ast_build.c |
isl_ast_expr_list_dup | __isl_give LIST(EL) *FN(LIST(EL),dup)(__isl_keep LIST(EL) *list)
{
int i;
LIST(EL) *dup;
if (!list)
return NULL;
dup = FN(LIST(EL),alloc)(FN(LIST(EL),get_ctx)(list), list->n);
if (!dup)
return NULL;
for (i = 0; i < list->n; ++i)
dup = FN(LIST(EL),add)(dup, FN(EL,copy)(list->p[i]));
return dup;
} | testq %rdi, %rdi
je 0x25d1846
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl 0x10(%rbx), %esi
callq 0x25d1778
testq %rax, %rax
je 0x25d1849
cmpl $0x0, 0x10(%rbx)
jle 0x25d184b
xorl %r14d, %r14d
movq 0x20(%rbx,%r14,8), %rsi
testq %rsi, %rsi
je 0x25d182e
incl (%rsi)
jmp 0x25d1830
xorl %esi, %e... | /External/isl/isl_list_templ.c |
isl_ast_node_list_foreach_scc | isl_stat FN(LIST(EL),foreach_scc)(__isl_keep LIST(EL) *list,
isl_bool (*follows)(__isl_keep EL *a, __isl_keep EL *b, void *user),
void *follows_user,
isl_stat (*fn)(__isl_take LIST(EL) *scc, void *user), void *fn_user)
{
S(LIST(EL),foreach_scc_data) data = { list, follows, follows_user };
int i, n;
isl_ctx *ctx;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x25d309e
movq %rdi, %r14
movl 0x10(%rdi), %ebp
testl %ebp, %... | /External/isl/isl_list_templ.c |
isl_ast_print_options_dup | __isl_give isl_ast_print_options *isl_ast_print_options_dup(
__isl_keep isl_ast_print_options *options)
{
isl_ctx *ctx;
isl_ast_print_options *dup;
if (!options)
return NULL;
ctx = isl_ast_print_options_get_ctx(options);
dup = isl_ast_print_options_alloc(ctx);
if (!dup)
return NULL;
dup->print_for = opti... | testq %rdi, %rdi
je 0x25d3442
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x25d33da
testq %rax, %rax
je 0x25d3445
movups 0x10(%rbx), %xmm0
movups %xmm0, 0x10(%rax)
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x20(%rax)
jmp 0x25d3447
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
retq
| /External/isl/isl_ast.c |
isl_ast_expr_list_is_equal | static isl_bool isl_ast_expr_list_is_equal(__isl_keep isl_ast_expr_list *list1,
__isl_keep isl_ast_expr_list *list2)
{
int i;
isl_size n1, n2;
if (!list1 || !list2)
return isl_bool_error;
if (list1 == list2)
return isl_bool_true;
n1 = isl_ast_expr_list_size(list1);
n2 = isl_ast_expr_list_size(list2);
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
orb %al, %cl
jne 0x25d3b4c
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, %rdi
je 0x25d3b47
movl 0x10(%r14), %edx
movl 0x10(%rbx), %eax
movl ... | /External/isl/isl_ast.c |
alloc_note | static __isl_give isl_printer *alloc_note(__isl_take isl_printer *p,
__isl_keep isl_id *id, void *(*note_create)(isl_ctx *),
void (*note_free)(void *))
{
isl_ctx *ctx;
isl_id *note_id;
isl_bool has_note;
void *note;
has_note = isl_printer_has_note(p, id);
if (has_note < 0)
return isl_printer_free(p);
if (ha... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2647475
testl %eax, %eax
js 0x25d6c53
je 0x25d6c18
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x2647325
movq %rax, %r13
movq %rax, %rdi
callq *... | /External/isl/isl_ast.c |
aff_constant_is_negative | static isl_bool aff_constant_is_negative(__isl_keep isl_set *set,
__isl_keep isl_aff *aff, void *user)
{
isl_bool is_neg;
isl_val *v;
v = isl_aff_get_constant_val(aff);
is_neg = isl_val_is_neg(v);
isl_val_free(v);
return is_neg;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rdi
callq 0x25a8703
movq %rax, %rbx
movq %rax, %rdi
callq 0x268a440
movl %eax, %ebp
movq %rbx, %rdi
callq 0x268852e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /External/isl/isl_ast_codegen.c |
graft_extend_body | static __isl_give isl_ast_graft_list *graft_extend_body(
__isl_take isl_ast_graft_list *list,
__isl_keep isl_ast_node **body, __isl_take isl_ast_graft *graft,
__isl_keep isl_ast_build *build)
{
isl_size n;
isl_size depth;
isl_ast_graft *last;
isl_space *space;
isl_basic_set *enforced;
n = isl_ast_graft_list_n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
testq %rdi, %rdi
je 0x25df847
movl 0x10(%r14), %ebp
jmp 0x25df84c
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movq %r12, %rdi
callq 0x25ccfac
movl %eax, %r15d
movl %ebp,... | /External/isl/isl_ast_graft.c |
any_ineq | static int any_ineq(struct isl_coalesce_info *info, int status)
{
isl_size n_ineq;
n_ineq = isl_basic_map_n_inequality(info->bmap);
return any(info->ineq, n_ineq, status);
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x2605cde
testl %eax, %eax
je 0x25e0ede
movq 0x28(%r14), %rcx
movl %eax, %eax
xorl %edx, %edx
cmpl %ebx, (%rcx,%rdx,4)
je 0x25e0ee2
incq %rdx
cmpq %rdx, %rax
jne 0x25e0ed1
xorl %eax, %eax
jmp 0x25e0ee7
movl $0x1, %eax
addq $0x8, %r... | /External/isl/isl_coalesce.c |
modulo_lineality | static __isl_give isl_basic_set *modulo_lineality(__isl_take isl_set *set,
__isl_take isl_basic_set *lin)
{
isl_size total = isl_basic_set_dim(lin, isl_dim_all);
unsigned lin_dim;
struct isl_basic_set *hull;
struct isl_mat *M, *U, *Q;
if (!set || total < 0)
goto error;
lin_dim = total - lin->n_eq;
M = isl_ma... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x5, %esi
callq 0x2605c28
movl %eax, %ebp
testq %rbx, %rbx
sete %al
testl %ebp, %ebp
sets %cl
orb %al, %cl
jne 0x25ec965
movl 0x1c(%r15), %r14d
movq 0x18(%rbx), %rdi
movq 0x30(%r15), %rsi
xorl %edx, %edx
m... | /External/isl/isl_convex_hull.c |
intermediate_sources | static isl_stat intermediate_sources(__isl_keep isl_access_info *acc,
struct isl_map **temp_rel, int j, int sink_level)
{
int k, level;
isl_size n_in = isl_map_dim(acc->source[j].map, isl_dim_in);
int depth = 2 * n_in + 1;
if (n_in < 0)
return isl_stat_error;
if (isl_map_plain_is_empty(temp_rel[j]))
return i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, %ebx
movq %rsi, %r12
movl %edx, %ebp
leaq (%rbp,%rbp,2), %r15
movq %rdi, 0x10(%rsp)
movq 0x50(%rdi,%r15,8), %rdi
movl $0x2, %esi
callq 0x2605b02
testl %eax, %eax
js 0x25f3254
movl %eax, %r14d
movq (%r12,%r... | /External/isl/isl_flow.c |
isl_hash_table_find | struct isl_hash_table_entry *isl_hash_table_find(struct isl_ctx *ctx,
struct isl_hash_table *table,
uint32_t key_hash,
isl_bool (*eq)(const void *entry, const void *val),
const void *val, int reserve)
{
size_t size;
uint32_t h, key_bits;
key_bits = isl_hash_bits(key_hash, table->bits);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %edx, %r8d
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movl %edx, 0x8(%rsp)
movl (%r14), %ecx
movl %r8d, %r15d
cmpl $0x20, %ecx
je 0x25f45f3
movl %r8d, %eax
shrl %cl, %eax
mo... | /External/isl/isl_hash.c |
isl_id_list_from_id | __isl_give LIST(EL) *FN(FN(LIST(EL),from),EL_BASE)(__isl_take EL *el)
{
isl_ctx *ctx;
LIST(EL) *list;
if (!el)
return NULL;
ctx = FN(EL,get_ctx)(el);
list = FN(LIST(EL),alloc)(ctx, 1);
if (!list)
goto error;
list = FN(LIST(EL),add)(list, el);
return list;
error:
FN(EL,free)(el);
return NULL;
} | pushq %rbx
testq %rdi, %rdi
je 0x25f55d7
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl $0x1, %esi
callq 0x25f4a4e
testq %rax, %rax
je 0x25f55cf
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x25f4b31
movq %rbx, %rdi
callq 0x25f4c81
xorl %eax, %eax
popq %rbx
retq
| /External/isl/isl_list_templ.c |
isl_printer_print_id | __isl_give isl_printer *isl_printer_print_id(__isl_take isl_printer *p,
__isl_keep isl_id *id)
{
if (!id)
goto error;
if (id->name)
p = isl_printer_print_str(p, id->name);
if (id->user) {
char buffer[50];
snprintf(buffer, sizeof(buffer), "@%p", id->user);
p = isl_printer_print_str(p, buffer);
}
return ... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x25f57fb
movq %rsi, %r14
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x25f57c9
movq %rbx, %rdi
callq 0x26475d8
movq %rax, %rbx
movq 0x18(%r14), %rcx
testq %rcx, %rcx
je 0x25f5805
leaq 0x2a2f944(%rip), %rdx # 0x502511d
movq %rsp, %r14
movl $0x32... | /External/isl/isl_id.c |
isl_multi_id_range_splice | __isl_give MULTI(BASE) *FN(MULTI(BASE),range_splice)(
__isl_take MULTI(BASE) *multi1, unsigned pos,
__isl_take MULTI(BASE) *multi2)
{
MULTI(BASE) *res;
isl_size dim;
dim = FN(MULTI(BASE),size)(multi1);
if (dim < 0 || !multi2)
goto error;
if (FN(MULTI(BASE),check_range)(multi1, isl_dim_out, pos, 0) < 0)
got... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testq %rdi, %rdi
je 0x25f6c95
movl 0x10(%r14), %r15d
jmp 0x25f6c9b
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
testl %r15d, %r15d
sets %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x25f6ccd
movq %r14, %rdi
movl ... | /External/isl/isl_multi_templ.c |
isl_multi_id_plain_is_equal | isl_bool FN(MULTI(BASE),plain_is_equal)(__isl_keep MULTI(BASE) *multi1,
__isl_keep MULTI(BASE) *multi2)
{
int i;
isl_bool equal;
if (!multi1 || !multi2)
return isl_bool_error;
if (multi1->n != multi2->n)
return isl_bool_false;
equal = isl_space_is_equal(multi1->space, multi2->space);
if (equal < 0 || !equal... | testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
orb %cl, %dl
jne 0x25f6e3d
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10(%rdi), %ecx
xorl %eax, %eax
cmpl 0x10(%rsi), %ecx
jne 0x25f6e36
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2669... | /External/isl/isl_multi_templ.c |
isl_id_to_ast_expr_is_equal | isl_bool ISL_HMAP_IS_EQUAL(__isl_keep ISL_HMAP *hmap1,
__isl_keep ISL_HMAP *hmap2)
{
if (!hmap1 || !hmap2)
return isl_bool_error;
if (hmap1 == hmap2)
return isl_bool_true;
if (hmap1->table.n != hmap2->table.n)
return isl_bool_false;
return ISL_FN(ISL_HMAP,every)(hmap1, &has_entry, hmap2);
} | testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
orb %cl, %dl
jne 0x25f7472
movq %rdi, %r8
cmpq %rsi, %rdi
je 0x25f7473
movl 0x14(%r8), %ecx
xorl %eax, %eax
cmpl 0x14(%rsi), %ecx
jne 0x25f7472
subq $0x18, %rsp
leaq 0x2e(%rip), %rax # 0x25f7479
leaq 0x8(%rsp), %r... | /External/isl/include/isl/hmap_templ.c |
isl_id_to_ast_expr_read_from_str | __isl_give ISL_HMAP *ISL_FN(ISL_HMAP,read_from_str)(isl_ctx *ctx,
const char *str)
{
ISL_HMAP *hmap;
isl_stream *s;
s = isl_stream_new_str(ctx, str);
if (!s)
return NULL;
hmap = ISL_FN(isl_stream_read,ISL_HMAP_SUFFIX)(s);
isl_stream_free(s);
return hmap;
} | pushq %r14
pushq %rbx
pushq %rax
callq 0x266b5b8
testq %rax, %rax
je 0x25f7716
movq %rax, %rbx
movq %rax, %rdi
callq 0x25f7628
movq %rax, %r14
movq %rbx, %rdi
callq 0x266c325
movq %r14, %rax
jmp 0x25f7718
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /External/isl/include/isl/hmap_templ.c |
piece_opt | static isl_stat piece_opt(__isl_take isl_set *set, __isl_take isl_aff *aff,
void *user)
{
struct isl_pw_aff_opt_data *data = user;
isl_val *opt;
opt = isl_set_opt_val(set, data->max, aff);
isl_set_free(set);
isl_aff_free(aff);
data->res = val_opt(data->res, opt, data->max);
if (!data->res)
return isl_stat_e... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %esi
movq %r14, %rdx
callq 0x25f8763
movq %rax, %r12
movq %r15, %rdi
callq 0x260a24c
movq %r14, %rdi
callq 0x25a358b
movq 0x8(%rbx), %rdi
movl (%rbx), %edx
movq %r12, %rsi
callq 0x25f8c64
movq %rax, 0x8(%... | /External/isl/isl_ilp.c |
isl_union_pw_multi_aff_read_from_str | __isl_give TYPE *FN(isl,FN(TYPE_BASE,read_from_str))(isl_ctx *ctx,
const char *str)
{
TYPE *obj;
isl_stream *s = isl_stream_new_str(ctx, str);
if (!s)
return NULL;
obj = FN(isl_stream_read,TYPE_BASE)(s);
isl_stream_free(s);
return obj;
} | pushq %r14
pushq %rbx
pushq %rax
callq 0x266b5b8
testq %rax, %rax
je 0x25faa0b
movq %rax, %rbx
movq %rax, %rdi
callq 0x25fa84c
movq %rax, %r14
movq %rbx, %rdi
callq 0x266c325
movq %r14, %rax
jmp 0x25faa0d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /External/isl/isl_read_from_str_templ.c |
read_tuple_id | static __isl_give isl_space *read_tuple_id(__isl_keep isl_stream *s,
struct vars *v, __isl_take isl_space *space, int rational, void *user)
{
struct isl_token *tok;
tok = next_token(s);
if (!tok) {
isl_stream_error(s, NULL, "unexpected EOF");
return isl_space_free(space);
}
if (tok->type == ISL_TOKEN_IDENT)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
callq 0x25f8e97
testq %rax, %rax
je 0x25fb9b3
movq %rax, %r14
movl (%rax), %eax
cmpl $0x2a, %eax
je 0x25fb9c6
cmpl $0x102, %eax # imm = 0x102
jne 0x25fb9d4
movl 0x8(%r12), %ebp
movq 0x10(%r14), %rsi
movq %r... | /External/isl/isl_input.c |
read_factor | static __isl_give isl_pw_qpolynomial *read_factor(__isl_keep isl_stream *s,
__isl_keep isl_map *map, struct vars *v)
{
isl_pw_qpolynomial *pwqp;
struct isl_token *tok;
tok = next_token(s);
if (!tok) {
isl_stream_error(s, NULL, "unexpected EOF");
return NULL;
}
if (tok->type == '(') {
int pow;
isl_token... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x25f8e97
testq %rax, %rax
je 0x25fe538
movq %rax, %r12
movl (%rax), %eax
cmpl $0x100, %eax # imm = 0x100
jle 0x25fe551
leal -0x113(%rax), %ecx
cmpl $0xe, %ecx
ja 0x25fe5b1
movl ... | /External/isl/isl_input.c |
to_union | static struct isl_obj to_union(isl_ctx *ctx, struct isl_obj obj)
{
if (obj.type == isl_obj_map) {
obj.v = isl_union_map_from_map(obj.v);
obj.type = isl_obj_union_map;
} else if (obj.type == isl_obj_set) {
obj.v = isl_union_set_from_set(obj.v);
obj.type = isl_obj_union_set;
} else if (obj.type == isl_obj_pw_q... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpq 0x328e187(%rip), %rsi # 0x588caa0
je 0x25fe967
movq %rsi, %r14
cmpq 0x328e52b(%rip), %rsi # 0x588ce50
je 0x25fe97b
cmpq 0x328e06a(%rip), %r14 # 0x588c998
je 0x25fe98f
cmpq 0x328e2b1(%rip), %r14 # 0x588cbe8
je 0x25fe9a3
leaq 0x2a26e75(%rip), %rdx # 0x50257b... | /External/isl/isl_input.c |
isl_sioimath_cmp | inline int isl_sioimath_cmp(isl_sioimath_src lhs, isl_sioimath_src rhs)
{
isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
int32_t lhssmall, rhssmall;
if (isl_sioimath_decode_small(lhs, &lhssmall) &&
isl_sioimath_decode_small(rhs, &rhssmall))
return (lhssmall > rhssmall) - (lhssmall < rhssmall);
if (isl... | subq $0x28, %rsp
movq %rdi, %rax
movq %rdi, %rcx
shrq $0x20, %rcx
movl %eax, %edx
andl %esi, %edx
testb $0x1, %dl
jne 0x260207c
testb $0x1, %sil
jne 0x2602090
testb $0x1, %al
jne 0x26020b8
movq %rax, %rdi
addq $0x28, %rsp
jmp 0x269399e
shrq $0x20, %rsi
xorl %eax, %eax
xorl %edx, %edx
cmpl %esi, %ecx
setg %al
setl %dl
s... | /External/isl/isl_int_sioimath.h |
isl_local_space_swap_div | __isl_give isl_local_space *isl_local_space_swap_div(
__isl_take isl_local_space *ls, int a, int b)
{
int offset;
ls = isl_local_space_cow(ls);
if (!ls)
return NULL;
if (a < 0 || a >= ls->div->n_row || b < 0 || b >= ls->div->n_row)
isl_die(isl_local_space_get_ctx(ls), isl_error_invalid,
"index out of bound... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
testq %rdi, %rdi
je 0x26035dc
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x26035de
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x260267e
movq %rax, %rbx
jmp 0x26035de
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x2603656
testl %r14d, %r14d
js 0x2... | /External/isl/isl_local_space.c |
normalize_div | static __isl_give isl_local_space *normalize_div(
__isl_take isl_local_space *ls, int div)
{
isl_ctx *ctx = ls->div->ctx;
unsigned total = ls->div->n_col - 2;
isl_seq_gcd(ls->div->row[div] + 2, total, &ctx->normalize_gcd);
isl_int_gcd(ctx->normalize_gcd,
ctx->normalize_gcd, ls->div->row[div][0]);
if (isl_i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x8(%rax), %r12
movl 0x18(%rax), %ebp
addl $-0x2, %ebp
movq 0x20(%rax), %rax
movslq %esi, %r15
movq (%rax,%r15,8), %rdi
addq $0x10, %rdi
leaq 0x50(%r12), %r14
movl %ebp, %esi
movq %r14, %rdx
callq 0x26626ca
movq 0x50(%r12)... | /External/isl/isl_local_space.c |
isl_local_space_substitute_seq | __isl_give isl_local_space *isl_local_space_substitute_seq(
__isl_take isl_local_space *ls,
enum isl_dim_type type, unsigned pos, isl_int *subs, int subs_len,
int first, int n)
{
int i;
isl_int v;
if (n == 0)
return ls;
ls = isl_local_space_cow(ls);
if (!ls)
return NULL;
ls->div = isl_mat_cow(ls->div);
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0x4(%rsp)
movq %rdi, %rbx
movl 0x50(%rsp), %r12d
testl %r12d, %r12d
je 0x2604035
movl %r9d, %r15d
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r13d
testq %rbx, %rbx
je 0x2603fe0
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x2603fe2
de... | /External/isl/isl_local_space.c |
isl_map_reset_tuple_id | __isl_give isl_map *isl_map_reset_tuple_id(__isl_take isl_map *map,
enum isl_dim_type type)
{
isl_space *space;
space = isl_map_take_space(map);
space = isl_space_reset_tuple_id(space, type);
map = isl_map_restore_space(map, space);
return isl_map_reset_space(map, isl_map_get_space(map));
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x26068a0
cmpl $0x1, (%rbx)
movq 0x20(%rbx), %rdi
jne 0x26068a4
movq $0x0, 0x20(%rbx)
jmp 0x26068ac
xorl %edi, %edi
jmp 0x26068ac
callq 0x26665a8
movq %rax, %rdi
movl %ebp, %esi
callq 0x2666a5c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2... | /External/isl/isl_map.c |
isl_basic_map_insert_div | __isl_give isl_basic_map *isl_basic_map_insert_div(
__isl_take isl_basic_map *bmap, int pos, __isl_keep isl_vec *div)
{
int i, k;
isl_size total;
bmap = isl_basic_map_cow(bmap);
total = isl_basic_map_dim(bmap, isl_dim_all);
if (total < 0 || !div)
return isl_basic_map_free(bmap);
if (div->size != 1 + 1 + tota... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
callq 0x2607cb4
movq %rax, %rbx
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x2607e1a
movq 0x10(%rbx), %rdi
movl $0x5, %esi
callq 0x26663a8
testl %eax, %eax
js 0x2607e1a
addl 0x40(%rbx), %eax
movl %eax, %r15d
... | /External/isl/isl_map.c |
isl_basic_map_drop | __isl_give isl_basic_map *isl_basic_map_drop(__isl_take isl_basic_map *bmap,
enum isl_dim_type type, unsigned first, unsigned n)
{
if (!bmap)
return NULL;
if (n == 0 && !isl_space_is_named_or_nested(bmap->dim, type))
return bmap;
bmap = isl_basic_map_cow(bmap);
if (!bmap)
return NULL;
bmap = isl_basic_map... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x26085c8
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
testl %ecx, %ecx
jne 0x2608592
movq 0x10(%r14), %rdi
movl %r15d, %esi
callq 0x2669fdf
testl %eax, %eax
je 0x26085cb
movq %r14, %rdi
callq 0x2607cb4
testq %rax, %rax
je 0x... | /External/isl/isl_map.c |
isl_basic_map_involves_dims | isl_bool isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap,
enum isl_dim_type type, unsigned first, unsigned n)
{
int i;
if (isl_basic_map_check_range(bmap, type, first, n) < 0)
return isl_bool_error;
first += isl_basic_map_offset(bmap, type);
for (i = 0; i < bmap->n_eq; ++i)
if (isl_seq_first_non_z... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
callq 0x2607d79
testl %eax, %eax
js 0x26094f6
leal -0x1(%r15), %ecx
xorl %eax, %eax
cmpl $0x3, %ecx
ja 0x260941a
movq %r14, %rdi
movl %r15d, %esi
callq 0x2605b71
incl %eax
addl %... | /External/isl/isl_map.c |
isl_basic_map_div_is_marked_unknown | isl_bool isl_basic_map_div_is_marked_unknown(__isl_keep isl_basic_map *bmap,
int div)
{
if (isl_basic_map_check_range(bmap, isl_dim_div, div, 1) < 0)
return isl_bool_error;
return isl_int_is_zero(bmap->div[div][0]);
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x4, %esi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x2607d79
testl %eax, %eax
js 0x2609bc8
movq 0x48(%r14), %rax
movslq %ebx, %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
testb $0x1, %dil
jne 0x2609bcf
callq 0x26920f1
jmp 0x2609be2
movl $0xffffffff,... | /External/isl/isl_map.c |
isl_basic_map_remove_unknown_divs | __isl_give isl_basic_map *isl_basic_map_remove_unknown_divs(
__isl_take isl_basic_map *bmap)
{
int i;
if (!bmap)
return NULL;
for (i = bmap->n_div - 1; i >= 0; --i) {
if (isl_basic_map_div_is_known(bmap, i))
continue;
bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
if (!bmap)
return NULL;... | pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2609c31
movq %rdi, %rbx
movl 0x40(%rbx), %ebp
decl %ebp
js 0x2609c33
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2609aa4
testl %eax, %eax
jne 0x2609c01
movq %rbx, %rdi
movl $0x4, %esi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x2608b93
testq %rax, %rax
je 0x2609c31
movq %r... | /External/isl/isl_map.c |
isl_basic_map_reset | __isl_give isl_basic_map *isl_basic_map_reset(__isl_take isl_basic_map *bmap,
enum isl_dim_type type)
{
isl_space *space;
space = isl_basic_map_take_space(bmap);
space = isl_space_reset(space, type);
bmap = isl_basic_map_restore_space(bmap, space);
bmap = isl_basic_map_mark_final(bmap);
return bmap;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x260b929
cmpl $0x1, (%rbx)
movq 0x10(%rbx), %rdi
jne 0x260b92d
movq $0x0, 0x10(%rbx)
jmp 0x260b935
xorl %edi, %edi
jmp 0x260b935
callq 0x26665a8
movq %rax, %rdi
movl %ebp, %esi
callq 0x2667aae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2... | /External/isl/isl_map.c |
map_lex_lte_first | static __isl_give isl_map *map_lex_lte_first(__isl_take isl_space *space,
unsigned n, int equal)
{
struct isl_map *map;
int i;
if (n == 0 && equal)
return isl_map_universe(space);
map = isl_map_alloc_space(isl_space_copy(space), n, ISL_MAP_DISJOINT);
for (i = 0; i + 1 < n; ++i)
map = isl_map_add_basic_map(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
setne %al
testl %edx, %edx
sete %cl
orb %al, %cl
jne 0x260dc4e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2609a3a
movl %edx, %ebp
movl %esi, %r14d
movq %rb... | /External/isl/isl_map.c |
map_lex_gte_first | static __isl_give isl_map *map_lex_gte_first(__isl_take isl_space *space,
unsigned n, int equal)
{
struct isl_map *map;
int i;
if (n == 0 && equal)
return isl_map_universe(space);
map = isl_map_alloc_space(isl_space_copy(space), n, ISL_MAP_DISJOINT);
for (i = 0; i + 1 < n; ++i)
map = isl_map_add_basic_map(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
setne %al
testl %edx, %edx
sete %cl
orb %al, %cl
jne 0x260dd75
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2609a3a
movl %edx, %ebp
movl %esi, %r14d
movq %rb... | /External/isl/isl_map.c |
isl_basic_map_overlying_set | __isl_give isl_basic_map *isl_basic_map_overlying_set(
__isl_take isl_basic_set *bset, __isl_take isl_basic_map *like)
{
struct isl_basic_map *bmap;
struct isl_ctx *ctx;
isl_size dim, bmap_total;
unsigned total;
int i;
if (!bset || !like)
goto error;
ctx = bset->ctx;
if (isl_basic_set_check_no_params(bset) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x260e8b7
movq 0x8(%r14), %r13
movq %r14, %rdi
callq 0x2607422
testl %eax, %eax
js 0x260e8b7
movq %r14, %rdi
callq 0x2607485
testl %eax, %eax
... | /External/isl/isl_map.c |
isl_map_transform | static __isl_give isl_map *isl_map_transform(__isl_take isl_map *map,
__isl_give isl_space *(*fn_space)(__isl_take isl_space *space),
__isl_give isl_basic_map *(*fn_bmap)(__isl_take isl_basic_map *bmap))
{
int i;
isl_space *space;
map = isl_map_cow(map);
if (!map)
return NULL;
for (i = 0; i < map->n; ++i) {
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
callq 0x2606595
testq %rax, %rax
je 0x260f2ea
movq %rax, %r14
cmpl $0x0, 0x28(%rax)
jle 0x260f2a9
xorl %r12d, %r12d
movq 0x38(%r14,%r12,8), %rdi
callq *%r15
movq %rax, 0x38(%r14,%r12,8)
testq %rax, %rax
je 0x260f2e2
incq %r12
movslq ... | /External/isl/isl_map.c |
map_bound_si | static __isl_give isl_map *map_bound_si(__isl_take isl_map *map,
enum isl_dim_type type, unsigned pos, int value, int upper)
{
int i;
map = isl_map_cow(map);
if (isl_map_check_range(map, type, pos, 1) < 0)
return isl_map_free(map);
for (i = 0; i < map->n; ++i) {
map->p[i] = basic_map_bound_si(map->p[i],
... | 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
callq 0x2606595
movq %rax, %rbx
movq %rax, %rdi
movl %r12d, %esi
movl %r15d, %edx
movl $0x1, %ecx
callq 0x26085de
testl %eax, %eax
js 0x260ff7f
cmpl $0x0, 0x28(%rbx)
jle 0x260f... | /External/isl/isl_map.c |
isl_set_foreach_orthant | isl_stat isl_set_foreach_orthant(__isl_keep isl_set *set,
isl_stat (*fn)(__isl_take isl_set *orthant, int *signs, void *user),
void *user)
{
isl_size nparam;
isl_size nvar;
int *signs;
isl_stat r;
if (!set)
return isl_stat_error;
if (isl_set_plain_is_empty(set))
return isl_stat_ok;
nparam = isl_set_dim(s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x2612527
movq %rdi, %r15
cmpl $0x0, 0x28(%rdi)
je 0x2612525
movq %rdx, %rbx
movq %rsi, %r14
movq 0x20(%r15), %rdi
movl $0x1, %esi
callq 0x26663a8
movl %eax, %r13d
movq 0x20(%... | /External/isl/isl_map.c |
foreach_orthant | static isl_stat foreach_orthant(__isl_take isl_set *set, int *signs, int first,
int len,
isl_stat (*fn)(__isl_take isl_set *orthant, int *signs, void *user),
void *user)
{
isl_set *half;
if (!set)
return isl_stat_error;
if (isl_set_plain_is_empty(set)) {
isl_set_free(set);
return isl_stat_ok;
}
if (first... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x20(%rsp)
movq %r8, 0x28(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %rbp
movl %ecx, %r13d
movslq %edx, %r12
leaq 0x10(%rsp), %r14
movq %r13, 0x30(%rsp)
movq 0x18(%rsp), %rbx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %r... | /External/isl/isl_map.c |
isl_basic_map_expand_divs | __isl_give isl_basic_map *isl_basic_map_expand_divs(
__isl_take isl_basic_map *bmap, __isl_take isl_mat *div, int *exp)
{
int i, j;
int n_div;
bmap = isl_basic_map_cow(bmap);
if (!bmap || !div)
goto error;
if (div->n_row < bmap->n_div)
isl_die(isl_mat_get_ctx(div), isl_error_invalid,
"not an expansion", ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
callq 0x2607cb4
movq %rax, %r14
testq %rax, %rax
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x2612e1d
movl 0x14(%rbx), %esi
movl 0x40(%r14), %r13d
subl %r13d, %esi
jae 0x2612dc4
movq %rbx, %rdi
callq 0x... | /External/isl/isl_map.c |
isl_map_remove_empty_parts | __isl_give isl_map *isl_map_remove_empty_parts(__isl_take isl_map *map)
{
int i;
if (!map)
return NULL;
for (i = map->n - 1; i >= 0; --i)
map = remove_if_empty(map, i);
return map;
} | testq %rdi, %rdi
je 0x261349a
pushq %rbx
movq %rdi, %rax
movl 0x28(%rdi), %ebx
testl %ebx, %ebx
jle 0x2613498
incl %ebx
leal -0x2(%rbx), %esi
movq %rax, %rdi
callq 0x260faa1
decl %ebx
cmpl $0x1, %ebx
jg 0x2613486
popq %rbx
retq
xorl %eax, %eax
retq
| /External/isl/isl_map.c |
isl_set_remove_empty_parts | __isl_give isl_map *isl_map_remove_empty_parts(__isl_take isl_map *map)
{
int i;
if (!map)
return NULL;
for (i = map->n - 1; i >= 0; --i)
map = remove_if_empty(map, i);
return map;
} | testq %rdi, %rdi
je 0x26134c3
pushq %rbx
movq %rdi, %rax
movl 0x28(%rdi), %ebx
testl %ebx, %ebx
jle 0x26134c1
incl %ebx
leal -0x2(%rbx), %esi
movq %rax, %rdi
callq 0x260faa1
decl %ebx
cmpl $0x1, %ebx
jg 0x26134af
popq %rbx
retq
xorl %eax, %eax
retq
| /External/isl/isl_map.c |
isl_basic_set_is_box | isl_bool isl_basic_set_is_box(__isl_keep isl_basic_set *bset)
{
int i, j;
isl_size nvar, n_div;
unsigned ovar;
n_div = isl_basic_set_dim(bset, isl_dim_div);
if (n_div < 0)
return isl_bool_error;
if (n_div != 0)
return isl_bool_false;
nvar = isl_basic_set_dim(bset, isl_dim_set);
if (nvar < 0)
return isl_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x2617261
movl 0x40(%rbx), %eax
testl %eax, %eax
js 0x2617450
je 0x2617273
xorl %r14d, %r14d
jmp 0x261745... | /External/isl/isl_map.c |
isl_map_wrap | static __isl_give isl_map *isl_map_change_space(__isl_take isl_map *map,
isl_bool (*can_change)(__isl_keep isl_map *map),
const char *cannot_change,
__isl_give isl_space *(*change)(__isl_take isl_space *space))
{
isl_bool ok;
isl_space *space;
if (!map)
return NULL;
ok = can_change ? can_change(map) : isl_bo... | testq %rdi, %rdi
je 0x2617546
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x26665a8
movq %rax, %rdi
callq 0x266872d
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x26067a9
xorl %eax, %eax
retq
| /External/isl/isl_map.c |
isl_basic_map_align_params | __isl_give isl_basic_map *isl_basic_map_align_params(
__isl_take isl_basic_map *bmap, __isl_take isl_space *model)
{
isl_ctx *ctx;
isl_bool equal_params;
isl_space *bmap_space;
if (!bmap || !model)
goto error;
ctx = isl_space_get_ctx(model);
if (!isl_space_has_named_params(model))
isl_die(ctx, isl_error_in... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x261789f
movq %r14, %rdi
callq 0x266606e
movq %rax, %r15
movq %r14, %rdi
callq 0x266a649
testl %eax, %eax
je 0x261787e
movq 0x10(%rbx), %rdi
callq 0x266a680
testl ... | /External/isl/isl_map.c |
isl_basic_map_inequalities_matrix | __isl_give isl_mat *isl_basic_map_inequalities_matrix(
__isl_keep isl_basic_map *bmap, enum isl_dim_type c1,
enum isl_dim_type c2, enum isl_dim_type c3,
enum isl_dim_type c4, enum isl_dim_type c5)
{
enum isl_dim_type c[5] = { c1, c2, c3, c4, c5 };
struct isl_mat *mat;
int i, j, k;
int pos;
isl_size total;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r10
movl %esi, 0x20(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x28(%rsp)
movl %r8d, 0x2c(%rsp)
movl %r9d, 0x30(%rsp)
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testq %rdi, %rdi
movq %rdi, 0x8(%rsp)
je 0x26180bd
movq 0x10(%r... | /External/isl/isl_map.c |
setup_constraint_index | static isl_stat setup_constraint_index(struct isl_constraint_index *ci,
__isl_keep isl_basic_set *bset)
{
int k, h;
if (create_constraint_index(ci, bset) < 0)
return isl_stat_error;
for (k = 0; k < bset->n_ineq; ++k) {
h = set_hash_index(ci, bset, k);
ci->index[h] = &bset->ineq[k];
}
return isl_stat_ok;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x261ed6d
testl %eax, %eax
js 0x262658a
cmpl $0x0, 0x20(%rbx)
je 0x2626592
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x38(%rbx), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x2625b1d
movq 0x38(%rbx), %rcx
addq %... | /External/isl/isl_map_simplify.c |
test_ineq_data_clear | static void test_ineq_data_clear(struct test_ineq_data *data)
{
isl_tab_free(data->tab);
isl_vec_free(data->v);
isl_int_clear(data->g);
isl_int_clear(data->fl);
isl_int_clear(data->fu);
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x266cfe3
movq 0x8(%rbx), %rdi
callq 0x268e754
movq 0x10(%rbx), %rdi
testb $0x1, %dil
jne 0x262753c
callq 0x2691924
movq 0x18(%rbx), %rdi
testb $0x1, %dil
jne 0x262754b
callq 0x2691924
movq 0x20(%rbx), %rdi
testb $0x1, %dil
jne 0x262755b
popq %rbx
jmp 0x2691924
popq %r... | /External/isl/isl_map_simplify.c |
isl_map_subtract_range | __isl_give isl_map *isl_map_subtract_range(__isl_take isl_map *map,
__isl_take isl_set *dom)
{
isl_bool ok;
isl_map *ext_dom;
isl_map_align_params_set(&map, &dom);
ok = isl_map_compatible_range(map, dom);
if (ok < 0)
goto error;
if (!ok)
isl_die(isl_set_get_ctx(dom), isl_error_invalid,
"incompatible spac... | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %rbx
movq %rdi, (%rbx)
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2607694
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0x2605dca
testl %eax, %eax
js 0x26279c3
je 0x2627998
movq 0x10(%rsp), %rdi
callq 0x2606401
movq %rax, %rdi
callq... | /External/isl/isl_map_subtract.c |
map_is_singleton_subset | static isl_bool map_is_singleton_subset(__isl_keep isl_map *map1,
__isl_keep isl_map *map2)
{
int i;
isl_bool is_subset = isl_bool_false;
struct isl_point *point;
if (!map1 || !map2)
return isl_bool_error;
if (map1->n != 1)
isl_die(isl_map_get_ctx(map1), isl_error_invalid,
"expecting single-disjunct input... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x2628bd0
cmpl $0x1, 0x28(%rdi)
jne 0x2628b4d
movq %rsi, %r14
movq 0x38(%rdi), %r12
movq %r12, %rdi
movl $0x5, %esi
callq 0x2605a4a
testl %eax, %eax
js 0x2628b93
movl %e... | /External/isl/isl_map_subtract.c |
check_row | static isl_stat check_row(__isl_keep isl_mat *mat, int row)
{
if (!mat)
return isl_stat_error;
if (row < 0 || row >= mat->n_row)
isl_die(isl_mat_get_ctx(mat), isl_error_invalid,
"row out of range", return isl_stat_error);
return isl_stat_ok;
} | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x262963a
testl %esi, %esi
js 0x262960e
xorl %eax, %eax
cmpl %esi, 0x14(%rdi)
ja 0x262963a
pushq %rax
movq 0x8(%rdi), %rdi
leaq 0x29fd262(%rip), %rdx # 0x502687c
leaq 0x29fcf0a(%rip), %rcx # 0x502652b
movl $0x5, %esi
movl $0x11f, %r8d # ... | /External/isl/isl_mat.c |
isl_mat_insert_zero_cols | __isl_give isl_mat *isl_mat_insert_zero_cols(__isl_take isl_mat *mat,
unsigned first, unsigned n)
{
int i;
if (!mat)
return NULL;
mat = isl_mat_insert_cols(mat, first, n);
if (!mat)
return NULL;
for (i = 0; i < mat->n_row; ++i)
isl_seq_clr(mat->row[i] + first, n);
return mat;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x262cb34
movl %edx, %ebp
movl %esi, %r14d
callq 0x262c9d7
testq %rax, %rax
je 0x262cb34
movq %rax, %rbx
cmpl $0x0, 0x14(%rax)
je 0x262cb36
movl %r14d, %r14d
xorl %r15d, %r15d
shlq $0x3, %r14
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq %... | /External/isl/isl_mat.c |
isl_basic_set_variable_compression_with_id | __isl_give isl_morph *isl_basic_set_variable_compression_with_id(
__isl_keep isl_basic_set *bset, __isl_keep isl_id *id)
{
isl_morph *morph;
morph = isl_basic_set_variable_compression(bset, isl_dim_set);
morph = isl_morph_set_ran_tuple_id(morph, id);
return morph;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movl $0x3, %esi
callq 0x262e2e3
testq %rax, %rax
je 0x262e609
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x1, %eax
je 0x262e60b
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x262dbf9
movq %rax, %rbx
jmp 0x262e60b
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x262e638
movq 0x10(... | /External/isl/isl_morph.c |
isl_basic_set_parameter_compression | __isl_give isl_morph *isl_basic_set_parameter_compression(
__isl_keep isl_basic_set *bset)
{
isl_size nparam;
isl_size nvar;
isl_size n_div;
int n_eq;
isl_mat *H, *B;
isl_mat *map, *inv;
isl_basic_set *dom, *ran;
if (!bset)
return NULL;
if (isl_basic_set_plain_is_empty(bset))
return isl_morph_empty(bset... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x262e755
movq %rdi, %rbx
callq 0x2612b48
testl %eax, %eax
je 0x262e679
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x262e278
movl 0x1c(%rbx), %ebp
testl %ebp, %ebp
je 0x2... | /External/isl/isl_morph.c |
need_exists | static isl_bool need_exists(__isl_keep isl_printer *p, __isl_keep isl_mat *div)
{
int i;
isl_size n;
n = isl_mat_rows(div);
if (!p || n < 0)
return isl_bool_error;
if (n == 0)
return isl_bool_false;
if (p->dump)
return isl_bool_true;
for (i = 0; i < n; ++i)
if (!can_print_div_expr(p, div, i))
return ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x262954b
movl %eax, %r15d
testq %r14, %r14
sete %al
testl %r15d, %r15d
sets %cl
orb %al, %cl
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
jne 0x263165d
testl %r15d, %r15d
je 0x263165b
movl $0x1, %ebp
cmpl $0... | /External/isl/isl_output.c |
isl_qpolynomial_list_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 0x26387d0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x264723e
movq %rax, %rdi
movq %rbx, %rsi
callq 0x26386ce
movq %rax, %rbx
movq %rax, %rdi
callq 0x26477f7
movq %rax, %r14
movq %rbx, %rdi
callq 0x26472d2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xor... | /External/isl/print_templ.c |
isl_pw_qpolynomial_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 0x2638aaa
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rdi)
cmpl $0x1, %eax
jg 0x2638aa3
movq 0x8(%rbx), %rdi
callq 0x25eee5e
cmpl $0x0, 0x10(%rbx)
jle 0x2638a9b
xorl %r14d, %r14d
movq 0x20(%rbx,%r14,8), %rdi
callq 0x26389fb
incq %r14
movslq 0... | /External/isl/isl_list_templ.c |
isl_pw_qpolynomial_list_map | __isl_give LIST(EL) *FN(LIST(EL),map)(__isl_keep LIST(EL) *list,
__isl_give EL *(*fn)(__isl_take EL *el, void *user), void *user)
{
int i, n;
if (!list)
return NULL;
n = list->n;
for (i = 0; i < n; ++i) {
EL *el = FN(FN(LIST(EL),take),EL_BASE)(list, i);
if (!el)
return FN(LIST(EL),free)(list);
el = fn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2639064
movq %rdi, %rbx
movl 0x10(%rdi), %r13d
testl %r13d, %r13d
jle 0x2639066
movq %rdx, %r14
movq %rsi, %r15
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2638ea1
movq %rax, %r12
testq %rax, %rax
je 0x263904e... | /External/isl/isl_list_templ.c |
compatible_divs | static isl_bool compatible_divs(__isl_keep isl_mat *div1,
__isl_keep isl_mat *div2)
{
int n_row, n_col;
isl_bool equal;
isl_assert(div1->ctx, div1->n_row >= div2->n_row &&
div1->n_col >= div2->n_col,
return isl_bool_error);
if (div1->n_row == div2->n_row)
return isl_mat_is_equal(div1, div2);
n_row ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x14(%rdi), %ebp
movl 0x14(%rsi), %eax
cmpl %eax, %ebp
jb 0x263b4a0
movl 0x18(%rbx), %r14d
movl 0x18(%rsi), %ecx
cmpl %ecx, %r14d
jae 0x263b4cc
movq 0x8(%rbx), %rdi
leaq 0x29ec8b3(%rip), %rdx # 0x5027d5e
leaq 0x29ec53f(%rip), %rcx # 0x50279f1
movl $0x3, %esi
mov... | /External/isl/isl_polynomial.c |
isl_pw_qpolynomial_realign_domain | static __isl_give PW *FN(PW,realign_domain)(__isl_take PW *pw,
__isl_take isl_reordering *exp)
{
int i;
isl_size n;
n = FN(PW,n_piece)(pw);
if (n < 0 || !exp)
goto error;
for (i = 0; i < n; ++i) {
isl_set *domain;
EL *el;
domain = FN(PW,take_domain_at)(pw, i);
domain = isl_set_realign(domain, isl_reo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x263dacf
movl 0x10(%r14), %r12d
jmp 0x263dad5
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
testl %r12d, %r12d
sets %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x263db7c
testl %r12d, %r12d
jle 0x263db59
xorl... | /External/isl/isl_pw_templ.c |
isl_pw_qpolynomial_align_params_bin | isl_stat FN(FN(ARG1,align_params),SUFFIX)(__isl_keep ARG1 **obj1,
__isl_keep ARG2 **obj2)
{
isl_space *space1, *space2;
isl_bool equal_params;
space1 = FN(ARG1,peek_space)(*obj1);
space2 = FN(ARG2,peek_space)(*obj2);
equal_params = isl_space_has_equal_params(space1, space2);
if (equal_params < 0)
goto error;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x263f4f8
movq 0x8(%rax), %rdi
jmp 0x263f4fa
xorl %edi, %edi
movq (%rbx), %rax
testq %rax, %rax
je 0x263f508
movq 0x8(%rax), %rsi
jmp 0x263f50a
xorl %esi, %esi
callq 0x266767b
testl %eax, %eax
js... | /External/isl/isl_align_params_templ.c |
isl_pw_qpolynomial_mul | __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
__isl_take isl_pw_qpolynomial *pwqp1,
__isl_take isl_pw_qpolynomial *pwqp2)
{
int i, j, n;
struct isl_pw_qpolynomial *res;
if (!pwqp1 || !pwqp2)
goto error;
isl_assert(pwqp1->dim->ctx, isl_space_is_equal(pwqp1->dim, pwqp2->dim),
goto error);
if (isl_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x26427b5
movq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x2669bb0
testl %eax, %eax
je 0x264278f
xorl %edi, %edi
cmpl $0x0, 0x10(%rbx)
... | /External/isl/isl_polynomial.c |
isl_schedule_node_dup | __isl_give isl_schedule_node *isl_schedule_node_dup(
__isl_keep isl_schedule_node *node)
{
if (!node)
return NULL;
return isl_schedule_node_alloc(isl_schedule_copy(node->schedule),
isl_schedule_tree_copy(node->tree),
isl_schedule_tree_list_copy(node->ancestors),
node->child_pos);
} | testq %rdi, %rdi
je 0x264e0fa
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x264c760
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x2654072
movq %rax, %r15
movq 0x10(%rbx), %rdi
callq 0x2653ef4
movq 0x18(%rbx), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %... | /External/isl/isl_schedule_node.c |
subtree_contraction_enter | static __isl_give isl_schedule_node *subtree_contraction_enter(
__isl_take isl_schedule_node *node, void *user)
{
struct isl_subtree_contraction_data *data = user;
do {
enum isl_schedule_node_type type;
isl_union_set *filter;
isl_union_pw_multi_aff *inner, *contraction;
isl_size n;
switch (isl_schedule_n... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rbx, %rbx
je 0x2651e4d
movq 0x20(%rbx), %rdi
callq 0x2654c41
jmp 0x2651e52
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x3, %eax
je 0x2651e91
cmpl $0x5, %eax
je 0x2651e6a
cmpl $-0x1, %eax
jne 0x2651f27
jmp 0x2651f4b
... | /External/isl/isl_schedule_node.c |
read_domain | static __isl_give isl_schedule_tree *read_domain(__isl_keep isl_stream *s)
{
isl_union_set *domain = NULL;
isl_schedule_tree *tree;
isl_ctx *ctx;
struct isl_token *tok;
enum isl_schedule_key key;
char *str;
isl_bool more;
ctx = isl_stream_get_ctx(s);
key = get_key(s);
if (isl_stream_yaml_next(s) < 0)
ret... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x266c319
movq %rax, %r14
movq %rbx, %rdi
callq 0x2653d06
movq %rbx, %rdi
callq 0x266c3e2
testl %eax, %eax
js 0x26536bb
movq %rbx, %rdi
callq 0x266b670
testq %rax, %rax
je 0x26536aa
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x266b3... | /External/isl/isl_schedule_read.c |
isl_schedule_tree_list_concat | __isl_give LIST(EL) *FN(LIST(EL),concat)(__isl_take LIST(EL) *list1,
__isl_take LIST(EL) *list2)
{
int i;
isl_ctx *ctx;
LIST(EL) *res;
if (!list1 || !list2)
goto error;
if (list1->ref == 1 && list1->n + list2->n <= list1->size)
return FN(LIST(EL),concat_inplace)(list1, list2);
ctx = FN(LIST(EL),get_ctx)(l... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x2654ac0
cmpl $0x1, (%r14)
jne 0x2654a37
movslq 0x10(%r14), %rcx
movslq 0x10(%rbx), %rax
addq %rax, %rcx
cmpq %rcx, 0x18(%r14)
jae 0x2654ae2
movq 0x8(%r14), %rdi
m... | /External/isl/isl_list_templ.c |
isl_schedule_tree_from_filter | __isl_give isl_schedule_tree *isl_schedule_tree_from_filter(
__isl_take isl_union_set *filter)
{
isl_ctx *ctx;
isl_schedule_tree *tree;
if (!filter)
return NULL;
ctx = isl_union_set_get_ctx(filter);
tree = isl_schedule_tree_alloc(ctx, isl_schedule_node_filter);
if (!tree)
goto error;
tree->filter = filte... | testq %rdi, %rdi
je 0x2654f40
pushq %rbx
movq %rdi, %rbx
callq 0x26834b3
movq %rax, %rdi
movl $0x5, %esi
callq 0x2654d58
testq %rax, %rax
je 0x2654f43
movq %rbx, 0x18(%rax)
jmp 0x2654f4d
xorl %eax, %eax
retq
movq %rbx, %rdi
callq 0x26838b5
xorl %eax, %eax
popq %rbx
retq
| /External/isl/isl_schedule_tree.c |
isl_schedule_tree_expansion_get_contraction | __isl_give isl_union_pw_multi_aff *isl_schedule_tree_expansion_get_contraction(
__isl_keep isl_schedule_tree *tree)
{
if (!tree)
return NULL;
if (tree->type != isl_schedule_node_expansion)
isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
"not an expansion node", return NULL);
return isl_union_pw... | testq %rdi, %rdi
je 0x26560f0
cmpl $0x3, 0x14(%rdi)
jne 0x26560c9
movq 0x18(%rdi), %rdi
jmp 0x25a6e81
pushq %rax
movq 0x8(%rdi), %rdi
leaq 0x29d2c5d(%rip), %rdx # 0x5028d32
leaq 0x29d2b8a(%rip), %rcx # 0x5028c66
movl $0x5, %esi
movl $0x568, %r8d # imm = 0x568
callq 0x25eea52
addq $0x8, %rsp
xorl %eax, %e... | /External/isl/isl_schedule_tree.c |
isl_schedule_tree_first_schedule_descendant | __isl_give isl_schedule_tree *isl_schedule_tree_first_schedule_descendant(
__isl_take isl_schedule_tree *tree, __isl_keep isl_schedule_tree *leaf)
{
isl_bool down;
while ((down = domain_less(tree)) == isl_bool_true) {
if (!isl_schedule_tree_has_children(tree)) {
isl_schedule_tree_free(tree);
return isl_sche... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x29d292b(%rip), %r12 # 0x5028c66
movl $0xcf9, %ebp # imm = 0xCF9
movl $0x304, %r15d # imm = 0x304
testq %r14, %r14
je 0x2656351
movl 0x14(%r14), %ecx
jmp 0x2656356
movl $0xffffffff, ... | /External/isl/isl_schedule_tree.c |
isl_schedule_tree_append_to_leaves | __isl_give isl_schedule_tree *isl_schedule_tree_append_to_leaves(
__isl_take isl_schedule_tree *tree1,
__isl_take isl_schedule_tree *tree2)
{
int i;
isl_size n;
n = isl_schedule_tree_n_children(tree1);
if (n < 0 || !tree2)
goto error;
if (n == 0) {
isl_schedule_tree_list *list;
list = isl_schedule_tree_li... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x26572a0
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x26572a8
movl 0x10(%rax), %r15d
jmp 0x26572ab
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
jmp 0x26572ab
xorl %r15d, %r15d
testq %r14, %r14
je 0x26572f2
test... | /External/isl/isl_schedule_tree.c |
print_yaml_field_set | static __isl_give isl_printer *FN(print_yaml_field,BASE)(
__isl_take isl_printer *p, const char *name, __isl_keep TYPE *val)
{
p = isl_printer_print_str(p, name);
p = isl_printer_yaml_next(p);
p = isl_printer_print_str(p, "\"");
p = FN(isl_printer_print,BASE)(p, val);
p = isl_printer_print_str(p, "\"");
p = isl_... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0x26475d8
movq %rax, %rdi
callq 0x2647afe
leaq 0x2866b98(%rip), %r14 # 0x4ebe7df
movq %rax, %rdi
movq %r14, %rsi
callq 0x26475d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x263041f
movq %rax, %rdi
movq %r14, %rsi
callq 0x26475d8
movq %rax, %rdi
addq $0x8, %rsp
popq %... | /External/isl/print_yaml_field_templ.c |
isl_sched_graph_compute_maxvar | isl_stat isl_sched_graph_compute_maxvar(struct isl_sched_graph *graph)
{
int i;
graph->maxvar = 0;
for (i = 0; i < graph->n; ++i) {
struct isl_sched_node *node = &graph->node[i];
int nvar;
if (isl_sched_node_update_vmap(node) < 0)
return isl_stat_error;
nvar = node->nvar + graph->n_row - node->rank;
i... | movl $0x0, 0x24(%rdi)
cmpl $0x0, 0x20(%rdi)
jle 0x2658ffd
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x18(%rbx), %r12
leaq (%r12,%r14), %rdi
callq 0x2658b37
testl %eax, %eax
js 0x2659000
movl 0x2c(%rbx), %eax
addl 0x54(%r12,%r14), %eax
subl 0x38(%r12,... | /External/isl/isl_scheduler.c |
graph_find_edge_entry | static struct isl_hash_table_entry *graph_find_edge_entry(
struct isl_sched_graph *graph,
enum isl_edge_type type,
struct isl_sched_node *src, struct isl_sched_node *dst)
{
isl_ctx *ctx = isl_space_get_ctx(src->space);
uint32_t hash;
struct isl_sched_edge temp = { .src = src, .dst = dst };
hash = isl_hash_init(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x266606e
movq %rax, %r14
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r13
movaps %xmm0, -0x10(%r13)
movaps %xmm0, (%r13)
movaps %xmm0, 0x10(%r13)
movaps %xm... | /External/isl/isl_scheduler.c |
isl_seq_is_neg | int isl_seq_is_neg(isl_int *p1, isl_int *p2, unsigned len)
{
int i;
for (i = 0; i < len; ++i) {
if (isl_int_abs_ne(p1[i], p2[i]))
return 0;
if (isl_int_is_zero(p1[i]))
continue;
if (isl_int_eq(p1[i], p2[i]))
return 0;
}
return 1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
testl %edx, %edx
je 0x2662303
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x29c8551(%rip), %rax # 0x502a694
movb (%rax), %al
movb %al, 0x7(%rsp)
leaq 0x29c8545(%rip), %rax # 0x502a695
movb (%rax), %r13b
movl %edx, %r15d
xorl %r12d, %r12d
xo... | /External/isl/isl_seq.c |
isl_union_set_list_dup | __isl_give LIST(EL) *FN(LIST(EL),dup)(__isl_keep LIST(EL) *list)
{
int i;
LIST(EL) *dup;
if (!list)
return NULL;
dup = FN(LIST(EL),alloc)(FN(LIST(EL),get_ctx)(list), list->n);
if (!dup)
return NULL;
for (i = 0; i < list->n; ++i)
dup = FN(LIST(EL),add)(dup, FN(EL,copy)(list->p[i]));
return dup;
} | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2664756
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl 0x10(%rbx), %esi
callq 0x2664684
testq %rax, %rax
je 0x2664756
movq %rax, %r14
cmpl $0x0, 0x10(%rbx)
jle 0x2664759
xorl %r15d, %r15d
movq 0x20(%rbx,%r15,8), %rdi
callq 0x26833e6
movq %r14, %rdi
movq %rax, %rsi
callq... | /External/isl/isl_list_templ.c |
isl_space_product | __isl_give isl_space *isl_space_product(__isl_take isl_space *left,
__isl_take isl_space *right)
{
isl_space *dom1, *dom2, *nest1, *nest2;
int is_set;
if (!left || !right)
goto error;
is_set = isl_space_is_set(left);
if (is_set != isl_space_is_set(right))
isl_die(isl_space_get_ctx(left), isl_error_invalid,
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x266855d
xorl %eax, %eax
cmpl $0x0, 0x14(%r14)
movl $0x0, %ecx
jne 0x2668500
cmpq $0x0, 0x30(%r14)
jne 0x2668500
movq 0x20(%r14), %rdx
xorl %ecx, %ecx
cmpq 0x32249... | /External/isl/isl_space.c |
isl_space_drop_dims | __isl_give isl_space *isl_space_drop_dims(__isl_take isl_space *space,
enum isl_dim_type type, unsigned first, unsigned num)
{
int i;
if (!space)
return NULL;
if (num == 0)
return isl_space_reset(space, type);
if (!valid_dim_type(type))
isl_die(space->ctx, isl_error_invalid,
"cannot drop dimensions of ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2668c91
movl %ecx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
testl %ecx, %ecx
je 0x2668af5
leal -0x4(%r12), %eax
cmpl $-0x4, %eax
ja 0x2668b0e
movq 0x8(%rbx), %rdi
leaq 0x29c08d3(%rip), %rdx # 0x50293ac
leaq 0x29c068f(%rip... | /External/isl/isl_space.c |
isl_space_unbind_params_insert_domain | __isl_give isl_space *isl_space_unbind_params_insert_domain(
__isl_take isl_space *space, __isl_keep isl_multi_id *tuple)
{
int i;
isl_size n;
isl_space *tuple_space;
n = isl_multi_id_size(tuple);
if (!space || n < 0)
return isl_space_free(space);
for (i = n - 1; i >= 0; --i) {
isl_id *id;
int pos;
id ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x25f5f27
movl %eax, %r15d
testq %rbx, %rbx
sete %al
testl %r15d, %r15d
sets %cl
orb %al, %cl
jne 0x2669a42
testl %r15d, %r15d
jle 0x26699dc
leal 0x1(%r15), %r13d
leal -0x2(%r13), %esi
movq... | /External/isl/isl_space.c |
isl_space_has_range_tuples | isl_bool isl_space_has_range_tuples(__isl_keep isl_space *space1,
__isl_keep isl_space *space2)
{
isl_bool is_set;
is_set = isl_space_is_set(space1);
if (is_set < 0 || !is_set)
return is_set;
return isl_space_tuple_is_equal(space1, isl_dim_set,
space2, isl_dim_out);
} | movq %rsi, %rdx
testq %rdi, %rdi
je 0x2669c77
xorl %eax, %eax
cmpl $0x0, 0x14(%rdi)
jne 0x2669c7c
cmpq $0x0, 0x30(%rdi)
jne 0x2669c7c
movq 0x20(%rdi), %rcx
xorl %eax, %eax
cmpq 0x3223206(%rip), %rcx # 0x588ce78
sete %al
jmp 0x2669c7c
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x2669c8f
movl ... | /External/isl/isl_space.c |
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.