name
string | code
string | asm
string | file
string |
|---|---|---|---|
(anonymous namespace)::MaximalStaticExpansionImpl::expandAccess(polly::MemoryAccess*)
|
ScopArrayInfo *expandAccess(MemoryAccess *MA) {
// Get the current AM.
auto CurrentAccessMap = MA->getAccessRelation();
unsigned in_dimensions =
unsignedFromIslSize(CurrentAccessMap.domain_tuple_dim());
// Get domain from the current AM.
auto Domain = CurrentAccessMap.domain();
// Create a new AM from the domain.
auto NewAccessMap = isl::map::from_domain(Domain);
// Add dimensions to the new AM according to the current in_dim.
NewAccessMap = NewAccessMap.add_dims(isl::dim::out, in_dimensions);
// Create the string representing the name of the new SAI.
// One new SAI for each statement so that each write go to a different
// memory cell.
auto CurrentStmtDomain = MA->getStatement()->getDomain();
auto CurrentStmtName = CurrentStmtDomain.get_tuple_name();
auto CurrentOutId = CurrentAccessMap.get_tuple_id(isl::dim::out);
std::string CurrentOutIdString =
MA->getScopArrayInfo()->getName() + "_" + CurrentStmtName + "_expanded";
// Set the tuple id for the out dimension.
NewAccessMap = NewAccessMap.set_tuple_id(isl::dim::out, CurrentOutId);
// Create the size vector.
std::vector<unsigned> Sizes;
for (unsigned i = 0; i < in_dimensions; i++) {
assert(isDimBoundedByConstant(CurrentStmtDomain, i) &&
"Domain boundary are not constant.");
auto UpperBound = getConstant(CurrentStmtDomain.dim_max(i), true, false);
assert(!UpperBound.is_null() && UpperBound.is_pos() &&
!UpperBound.is_nan() &&
"The upper bound is not a positive integer.");
assert(UpperBound.le(isl::val(CurrentAccessMap.ctx(),
std::numeric_limits<int>::max() - 1)) &&
"The upper bound overflow a int.");
Sizes.push_back(UpperBound.get_num_si() + 1);
}
// Get the ElementType of the current SAI.
auto ElementType = MA->getLatestScopArrayInfo()->getElementType();
// Create (or get if already existing) the new expanded SAI.
auto ExpandedSAI =
S.createScopArrayInfo(ElementType, CurrentOutIdString, Sizes);
ExpandedSAI->setIsOnHeap(true);
// Get the out Id of the expanded Array.
auto NewOutId = ExpandedSAI->getBasePtrId();
// Set the out id of the new AM to the new SAI id.
NewAccessMap = NewAccessMap.set_tuple_id(isl::dim::out, NewOutId);
// Add constraints to linked output with input id.
auto SpaceMap = NewAccessMap.get_space();
auto ConstraintBasicMap = isl::basic_map::equal(
SpaceMap, unsignedFromIslSize(SpaceMap.dim(isl::dim::in)));
NewAccessMap = isl::map(ConstraintBasicMap);
// Set the new access relation map.
MA->setNewAccessRelation(NewAccessMap);
return ExpandedSAI;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %rsi, 0x10(%rsp)
callq 0x1a22ca8
movq (%rbx), %rdi
callq 0x1b0f28d
movl %eax, %ebx
leaq 0xd0(%rsp), %r14
movq $0x0, (%r14)
movl $0x18, %edi
callq 0x7808d0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x3e4ae90(%rip), %rcx # 0x587aff8
addq $0x10, %rcx
movq %rcx, 0x98(%rsp)
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %rcx, (%r14)
movl %ebx, 0x10(%r14)
movb $0x1, 0x10(%rax)
movq %r14, %rdi
callq 0x1a0d056
movl %eax, %ebp
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1a301a6
callq 0xa775b8
movq 0x18(%rsp), %rdi
callq 0x1b10b80
movq %rax, %rdi
callq 0x1b1aacf
movq %rax, 0xa8(%rsp)
movq %rax, %rdi
callq 0x1b10b72
movq %rax, %rdi
callq 0x1b15bba
movq %rax, %rbx
movq %rax, %rdi
callq 0x1b10b80
movq %rax, %rdi
movl $0x3, %esi
movl %ebp, %edx
callq 0x1b14c88
movq %rax, %r13
testq %rbx, %rbx
je 0x1a301fa
movq %rbx, %rdi
callq 0x1b0fdb2
movq 0x10(%rsp), %r14
movq 0x18(%r14), %rsi
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x1a51c60
movq (%rbx), %rdi
callq 0x1b10145
leaq 0xd0(%rsp), %rdi
leaq 0x70(%rsp), %rdx
movq %rax, %rsi
callq 0x7f9ea4
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x1b100aa
movq %rax, %r15
movq %r14, %rdi
callq 0x1a51a6a
leaq 0xb0(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1a5058c
leaq 0x20dfcd2(%rip), %rsi # 0x3b0ff33
movq %rbx, %rdi
callq 0x780c80
leaq 0x60(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1a30290
movq %rdx, 0x50(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x60(%rsp)
jmp 0x1a30296
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
leaq 0x50(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0xd0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
callq 0x780d70
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1a302ee
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x1a302f5
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x34d5b8a(%rip), %rsi # 0x4f05ea2
callq 0x780c80
leaq 0x80(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1a3034a
movq %rdx, 0x70(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x80(%rsp)
jmp 0x1a30350
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x78(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a3037f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7800d0
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1a30396
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x7800d0
leaq 0xc0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a303b7
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x7800d0
movq %r15, 0xa0(%rsp)
movq %r15, %rdi
callq 0x1afe3bb
movq %rax, %rbx
movq %r13, %rdi
callq 0x1b10b80
movq %rax, %rdi
movl $0x3, %esi
movq %rbx, %rdx
callq 0x1b0feb6
movq %rax, 0x90(%rsp)
testq %r13, %r13
je 0x1a303f7
movq %r13, %rdi
callq 0x1b0fdb2
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
testl %ebp, %ebp
je 0x1a304b7
xorl %r13d, %r13d
leaq 0x50(%rsp), %r12
leaq 0x40(%rsp), %r15
leaq 0x20(%rsp), %r14
leaq 0xb0(%rsp), %rbx
movq 0x48(%rsp), %rdi
callq 0x1b10b72
movq %rax, %rdi
movl %r13d, %esi
callq 0x1b1a46b
movq %rax, 0x40(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1a91beb
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1a30465
callq 0x1aadb11
movq 0x50(%rsp), %rdi
callq 0x1b93111
incl %eax
movl %eax, 0xb0(%rsp)
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0x1a30491
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x28(%rsp)
jmp 0x1a3049c
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8e70c8
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1a304ab
callq 0x1b91ce4
incl %r13d
cmpl %r13d, %ebp
jne 0x1a3042a
movq 0x10(%rsp), %rdi
callq 0x1a51aa6
movq 0x48(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x70(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x1a57e78
movb $0x1, 0x58(%rax)
leaq 0xb0(%rsp), %rbx
movq %rbx, %rdi
movq %rax, 0x8(%rsp)
movq %rax, %rsi
callq 0x1a505e0
movq (%rbx), %rdi
callq 0x1afe3bb
movq %rax, %rbx
movq 0x90(%rsp), %r14
movq %r14, %rdi
callq 0x1b10b80
movq %rax, %rdi
movl $0x3, %esi
movq %rbx, %rdx
callq 0x1b0feb6
movq %rax, %r15
testq %r14, %r14
je 0x1a30534
movq %r14, %rdi
callq 0x1b0fdb2
movq %r15, %rdi
callq 0x1b0fb77
movq %rax, %r13
movq %rax, %rdi
callq 0x1b6fd4e
movq %rax, %rbx
movq %r13, %rdi
movl $0x2, %esi
callq 0x1b6fb4e
movl %eax, %ebp
leaq 0x50(%rsp), %r12
movq $0x0, (%r12)
movl $0x18, %edi
callq 0x7808d0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
movq 0x98(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%r12)
movq %rcx, (%r12)
movl %ebp, 0x10(%r12)
movb $0x1, 0x10(%rax)
movq %r12, %rdi
callq 0x1a0d056
movq %rbx, %rdi
movl %eax, %esi
callq 0x1b16c3c
movq %rax, %r14
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x1a305c7
callq 0xa775b8
movq %r14, %rdi
callq 0x1b10877
movq %rax, %rdi
callq 0x1b138e8
movq %rax, %rbx
testq %r15, %r15
je 0x1a305e7
movq %r15, %rdi
callq 0x1b0fdb2
leaq 0xf0(%rsp), %r15
movq $0x0, (%r15)
movq %rbx, %rdi
callq 0x1b10b80
movq %rax, (%r15)
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x1a54680
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1a3061b
callq 0x1b0fdb2
testq %r14, %r14
movq 0xa0(%rsp), %r15
je 0x1a30630
movq %r14, %rdi
callq 0x1b0fb02
testq %r13, %r13
je 0x1a3063d
movq %r13, %rdi
callq 0x1b6fe0a
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x1a3064f
callq 0x1afe3ec
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1a30666
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x1a30688
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x7800d0
testq %r15, %r15
je 0x1a30695
movq %r15, %rdi
callq 0x1afe3ec
leaq 0xe0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a306b6
movq 0xe0(%rsp), %rsi
incq %rsi
callq 0x7800d0
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x1a306c5
callq 0x1b139c2
testq %rbx, %rbx
je 0x1a306d2
movq %rbx, %rdi
callq 0x1b0fdb2
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a306e4
callq 0x1b139c2
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1a306f3
callq 0x1b0fdb2
movq 0x8(%rsp), %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Transform/MaximalStaticExpansion.cpp
|
void llvm::SmallVectorImpl<polly::ScopArrayInfo*>::append<polly::ScopArrayInfo* const*, void>(polly::ScopArrayInfo* const*, polly::ScopArrayInfo* const*)
|
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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq $0x3, %r13
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %r13, %rdx
cmpq %rax, %rdx
jbe 0x1a30a16
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x2b4ed86
cmpq %r12, %r14
je 0x1a30a30
movl 0x8(%rbx), %edi
shlq $0x3, %rdi
addq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x780890
addl %r13d, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/llvm/ADT/SmallVector.h
|
llvm::Pass* llvm::callDefaultCtor<(anonymous namespace)::MaximalStaticExpanderWrapperPass, true>()
|
Pass *callDefaultCtor() {
return new PassName();
}
|
pushq %rax
movl $0x28, %edi
callq 0x7808d0
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x3f0f688(%rip), %rdx # 0x59405cc
movq %rdx, 0x10(%rax)
movl $0x0, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x3e4a8ce(%rip), %rcx # 0x587b828
movq %rcx, (%rax)
popq %rcx
retq
nop
|
/llvm/PassSupport.h
|
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [17], llvm::cl::desc, llvm::cl::initializer<bool>, llvm::cl::NumOccurrencesFlag, llvm::cl::cat>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [17], llvm::cl::desc const&, llvm::cl::initializer<bool> const&, llvm::cl::NumOccurrencesFlag const&, llvm::cl::cat const&)
|
void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7802c0
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x2b1f336
movups (%r13), %xmm0
movups %xmm0, 0x20(%r14)
movq (%r12), %rax
movb (%rax), %cl
movb %cl, 0x80(%r14)
movb $0x1, 0x91(%r14)
movb (%rax), %al
movb %al, 0x90(%r14)
movzwl (%r15), %eax
movzwl 0xa(%r14), %ecx
andl $0x7, %eax
andl $-0x8, %ecx
orl %eax, %ecx
movw %cx, 0xa(%r14)
movq (%rbx), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b1f3c8
|
/llvm/Support/CommandLine.h
|
polly::Dependences::getDependences(int) const
|
isl::union_map Dependences::getDependences(int Kinds) const {
assert(hasValidDependences() && "No valid dependences available");
isl::space Space = isl::manage_copy(RAW).get_space();
isl::union_map Deps = Deps.empty(Space.ctx());
if (Kinds & TYPE_RAW)
Deps = Deps.unite(isl::manage_copy(RAW));
if (Kinds & TYPE_WAR)
Deps = Deps.unite(isl::manage_copy(WAR));
if (Kinds & TYPE_WAW)
Deps = Deps.unite(isl::manage_copy(WAW));
if (Kinds & TYPE_RED)
Deps = Deps.unite(isl::manage_copy(RED));
if (Kinds & TYPE_TC_RED)
Deps = Deps.unite(isl::manage_copy(TC_RED));
Deps = Deps.coalesce();
Deps = Deps.detect_equalities();
return Deps;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x1b8d04d
movq %rax, %r12
movq %rax, %rdi
callq 0x1b8cc91
movq %rax, %r14
testq %r12, %r12
je 0x1a3b486
movq %r12, %rdi
callq 0x1b8cd9e
movq %r14, %rdi
callq 0x1b6f814
movq %rax, %rdi
callq 0x1b8cbac
movq %rax, (%rbx)
testb $0x2, %bpl
je 0x1a3b4d0
movq %rax, %r12
movq (%r15), %rdi
callq 0x1b8d04d
movq %rax, %r13
movq %r12, %rdi
callq 0x1b8d04d
movq %rax, %rdi
movq %r13, %rsi
callq 0x1b8cf6a
movq %rax, (%rbx)
testq %r12, %r12
je 0x1a3b4d0
movq %r12, %rdi
callq 0x1b8cd9e
testb $0x1, %bpl
je 0x1a3b508
movq 0x8(%r15), %rdi
callq 0x1b8d04d
movq %rax, %r13
movq (%rbx), %r12
movq %r12, %rdi
callq 0x1b8d04d
movq %rax, %rdi
movq %r13, %rsi
callq 0x1b8cf6a
movq %rax, (%rbx)
testq %r12, %r12
je 0x1a3b508
movq %r12, %rdi
callq 0x1b8cd9e
testb $0x4, %bpl
je 0x1a3b540
movq 0x10(%r15), %rdi
callq 0x1b8d04d
movq %rax, %r13
movq (%rbx), %r12
movq %r12, %rdi
callq 0x1b8d04d
movq %rax, %rdi
movq %r13, %rsi
callq 0x1b8cf6a
movq %rax, (%rbx)
testq %r12, %r12
je 0x1a3b540
movq %r12, %rdi
callq 0x1b8cd9e
testb $0x8, %bpl
je 0x1a3b578
movq 0x18(%r15), %rdi
callq 0x1b8d04d
movq %rax, %r13
movq (%rbx), %r12
movq %r12, %rdi
callq 0x1b8d04d
movq %rax, %rdi
movq %r13, %rsi
callq 0x1b8cf6a
movq %rax, (%rbx)
testq %r12, %r12
je 0x1a3b578
movq %r12, %rdi
callq 0x1b8cd9e
testb $0x10, %bpl
je 0x1a3b5b0
movq 0x20(%r15), %rdi
callq 0x1b8d04d
movq %rax, %r12
movq (%rbx), %r15
movq %r15, %rdi
callq 0x1b8d04d
movq %rax, %rdi
movq %r12, %rsi
callq 0x1b8cf6a
movq %rax, (%rbx)
testq %r15, %r15
je 0x1a3b5b0
movq %r15, %rdi
callq 0x1b8cd9e
movq (%rbx), %r12
movq %r12, %rdi
callq 0x1b8d04d
movq %rax, %rdi
callq 0x1b8ea17
movq %rax, %r15
movq %rax, (%rbx)
testq %r12, %r12
je 0x1a3b5d6
movq %r12, %rdi
callq 0x1b8cd9e
movq %r15, %rdi
callq 0x1b8d04d
movq %rax, %rdi
callq 0x1b8ea77
movq %rax, (%rbx)
testq %r15, %r15
je 0x1a3b5f6
movq %r15, %rdi
callq 0x1b8cd9e
testq %r14, %r14
je 0x1a3b603
movq %r14, %rdi
callq 0x1b6fe0a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/Analysis/DependenceInfo.cpp
|
polly::DependenceInfo::printScop(llvm::raw_ostream&, polly::Scop&) const
|
void polly::DependenceInfo::printScop(raw_ostream &OS, Scop &S) const {
if (auto d = D[OptAnalysisLevel].get()) {
d->print(OS);
return;
}
// Otherwise create the dependences on-the-fly and print it
Dependences D(S.getSharedIslCtx(), OptAnalysisLevel);
D.calculateDependences(S);
D.print(OS);
}
|
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movl 0x3f058e8(%rip), %eax # 0x59416f0
movq 0x30(%rdi,%rax,8), %rdi
testq %rdi, %rdi
je 0x1a3be21
movq %rbx, %rsi
addq $0x58, %rsp
popq %rbx
popq %r14
jmp 0x1a3b7b0
movl 0x3f058c9(%rip), %eax # 0x59416f0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movups %xmm0, 0x2c(%rsp)
movq (%rdx), %rcx
movq %rcx, 0x40(%rsp)
movq 0x8(%rdx), %rcx
movq %rcx, 0x48(%rsp)
testq %rcx, %rcx
je 0x1a3be68
movq 0x3ebfc7e(%rip), %rsi # 0x58fbad8
cmpb $0x0, (%rsi)
je 0x1a3be64
incl 0x8(%rcx)
jmp 0x1a3be68
lock
incl 0x8(%rcx)
movq %rsp, %r14
movl %eax, 0x50(%r14)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x1a3a25e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a3b7b0
movq %r14, %rdi
callq 0x1a026b8
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
|
/Analysis/DependenceInfo.cpp
|
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [23], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::cat>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [23], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::cat const&)
|
void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x7802c0
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2b1f336
movups (%r15), %xmm0
movups %xmm0, 0x20(%r13)
movl (%r14), %eax
movzwl 0xa(%r13), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
movw %cx, 0xa(%r13)
movq (%rbx), %rsi
movq %r13, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b1f3c8
|
/llvm/Support/CommandLine.h
|
void llvm::cl::apply<llvm::cl::opt<AnalysisType, false, llvm::cl::parser<AnalysisType>>, char [32], llvm::cl::desc, llvm::cl::ValuesClass, llvm::cl::OptionHidden, llvm::cl::initializer<AnalysisType>, llvm::cl::cat>(llvm::cl::opt<AnalysisType, false, llvm::cl::parser<AnalysisType>>*, char const (&) [32], llvm::cl::desc const&, llvm::cl::ValuesClass const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<AnalysisType> const&, llvm::cl::cat const&)
|
void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x40(%rsp), %rbx
movq %rsi, %rdi
callq 0x7802c0
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2b1f336
movups (%r12), %xmm0
movups %xmm0, 0x20(%rbp)
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq (%rsp), %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a3d6af
|
/llvm/Support/CommandLine.h
|
isl::noexceptions::isl_iterator<isl::set_list>::isl_iterator(isl::set_list const&)
|
explicit isl_iterator(const ListT &List)
: List(&List), Position(std::max(List.size().release(), 0)) {}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
movq (%rsi), %rdi
callq 0x1b6d4f6
movl %eax, %ebp
movl $0x18, %edi
callq 0x7808d0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x3e3d339(%rip), %rcx # 0x587aff8
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x1, 0x10(%rax)
xorl %r14d, %r14d
testl %ebp, %ebp
cmovgl %ebp, %r14d
movq %rax, %rdi
callq 0xa775b8
movl %r14d, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
|
/polly/Support/ISLTools.h
|
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [31], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<bool>, llvm::cl::cat>(char const (&) [31], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> const&, llvm::cl::cat const&)
|
explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x7fca88
movb %bl, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb %bl, 0x91(%r14)
leaq 0x3d07da5(%rip), %rax # 0x5747988
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x3eb8213(%rip), %rax # 0x58f7e08
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x3eb7e25(%rip), %rax # 0x58f7a28
addq $0x10, %rax
movq %rax, 0x98(%r14)
movups %xmm0, 0xa0(%r14)
leaq -0x124302f(%rip), %rax # 0x7fcbee
movq %rax, 0xb8(%r14)
leaq -0x124303b(%rip), %rax # 0x7fcbf0
movq %rax, 0xb0(%r14)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq (%rsp), %r9
callq 0x1a48cb2
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b1e814
|
/llvm/Support/CommandLine.h
|
polly::ScopDetection::findScops(llvm::Region&)
|
void ScopDetection::findScops(Region &R) {
std::unique_ptr<DetectionContext> &Entry =
DetectionContextMap[getBBPairForRegion(&R)];
Entry = std::make_unique<DetectionContext>(R, AA, /*Verifying=*/false);
DetectionContext &Context = *Entry.get();
bool DidBailout = true;
if (!PollyProcessUnprofitable && regionWithoutLoops(R, LI))
invalid<ReportUnprofitable>(Context, /*Assert=*/true, &R);
else
DidBailout = !isValidRegion(Context);
(void)DidBailout;
if (KeepGoing) {
assert((!DidBailout || Context.IsInvalid) &&
"With -polly-detect-keep-going, it is sufficient that if "
"isValidRegion short-circuited, that SCoP is invalid");
} else {
assert(DidBailout == Context.IsInvalid &&
"isValidRegion must short-circuit iff the ScoP is invalid");
}
if (Context.IsInvalid) {
removeCachedResults(R);
} else {
ValidRegions.insert(&R);
return;
}
for (auto &SubRegion : R)
findScops(*SubRegion);
// Try to expand regions.
//
// As the region tree normally only contains canonical regions, non canonical
// regions that form a Scop are not found. Therefore, those non canonical
// regions are checked by expanding the canonical ones.
std::vector<Region *> ToExpand;
for (auto &SubRegion : R)
ToExpand.push_back(SubRegion.get());
for (Region *CurrentRegion : ToExpand) {
// Skip invalid regions. Regions may become invalid, if they are element of
// an already expanded region.
if (!ValidRegions.count(CurrentRegion))
continue;
// Skip regions that had errors.
bool HadErrors = lookupRejectionLog(CurrentRegion)->hasErrors();
if (HadErrors)
continue;
Region *ExpandedR = expandRegion(*CurrentRegion);
if (!ExpandedR)
continue;
R.addSubRegion(ExpandedR, true);
ValidRegions.insert(ExpandedR);
removeCachedResults(*CurrentRegion);
removeCachedResultsRecursively(*ExpandedR);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
movq %rsi, %rdi
callq 0x1a4c6bc
leaq 0xa0(%rsp), %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a4ba68
movq %rax, %r14
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rbx), %r13
movl $0x440, %edi # imm = 0x440
callq 0x7808d0
movq %rax, %rbp
movq %rax, %rdi
movq %r12, 0x8(%rsp)
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x1a46b06
movq $0x0, (%r15)
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x1a47532
leaq 0xa0(%rsp), %rdi
callq 0x1a01190
movq 0x10(%r14), %r12
leaq 0x3f01585(%rip), %rax # 0x5941b40
cmpb $0x0, (%rax)
jne 0x1a40809
movq %r12, 0x10(%rsp)
movq 0x40(%rbx), %r12
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x26834fc
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x2b4e852
leaq 0x88(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x137f090
leaq 0x118(%rsp), %rdx
leaq 0x1b0(%rsp), %rsi
leaq 0x190(%rsp), %r14
movq %r14, %rdi
callq 0x2b4e852
leaq 0x1f0(%rsp), %rdi
leaq 0x178(%rsp), %rsi
callq 0x137f090
movq %r15, %rdi
movq %r14, %rsi
callq 0xb31afc
movl %eax, %ebp
testb %al, %al
jne 0x1a406bd
leaq 0x18(%rsp), %r15
leaq 0x28(%rsp), %r14
leaq 0x190(%rsp), %r13
movq 0x90(%rsp), %rax
movq -0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movq %r12, %rdi
leaq 0x20(%rsp), %rsi
movq %r15, %rdx
callq 0xb31c52
testb %al, %al
je 0x1a40694
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
jmp 0x1a40696
xorl %esi, %esi
movq 0x8(%rsp), %rdi
callq 0x2682bfc
testb %al, %al
jne 0x1a406bd
movq %r14, %rdi
callq 0xb31f34
movq %r14, %rdi
movq %r13, %rsi
callq 0xb31afc
movl %eax, %ebp
testb %al, %al
je 0x1a40664
movq 0x1f0(%rsp), %rdi
testq %rdi, %rdi
je 0x1a406da
movq 0x200(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq 0x198(%rsp), %rdi
cmpq 0x190(%rsp), %rdi
movq 0x10(%rsp), %r12
je 0x1a406f6
callq 0x780910
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1a40713
movq 0x98(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq 0x30(%rsp), %rdi
cmpq 0x28(%rsp), %rdi
je 0x1a40724
callq 0x780910
movq 0x178(%rsp), %rdi
testq %rdi, %rdi
je 0x1a40741
movq 0x188(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq 0x120(%rsp), %rdi
cmpq 0x118(%rsp), %rdi
je 0x1a40758
callq 0x780910
movq 0x100(%rsp), %rdi
testq %rdi, %rdi
je 0x1a40775
movq 0x110(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq 0xa8(%rsp), %rdi
cmpq 0xa0(%rsp), %rdi
je 0x1a4078c
callq 0x780910
testb $0x1, %bpl
je 0x1a40809
cmpb $0x0, 0x2d8(%r12)
jne 0x1a40814
movl $0x28, %edi
callq 0x7808d0
movq %rax, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x3e3bdc9(%rip), %rax # 0x587c588
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x10(%r14), %r15
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x1a4ee10
movb $0x1, 0x2d9(%r12)
movq %r15, 0xa0(%rsp)
movq %r14, 0xa8(%rsp)
movq 0x3ebb2e1(%rip), %rax # 0x58fbad8
cmpb $0x0, (%rax)
je 0x1a409b6
incl 0x8(%r14)
jmp 0x1a409bb
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1a40fb4
cmpb $0x1, 0x2d9(%r12)
jne 0x1a40855
leaq 0xa0(%rsp), %rsi
movq 0x8(%rsp), %r15
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x1a40c54
movq 0x28(%r15), %r14
movq 0x30(%r15), %r15
cmpq %r15, %r14
je 0x1a40872
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1a40520
addq $0x8, %r14
jmp 0x1a4083f
leaq 0xa0(%rsp), %rsi
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1a416b6
jmp 0x1a409a4
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
movq $0x0, 0xb0(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %r12
movq 0x30(%rax), %r13
cmpq %r13, %r12
je 0x1a408c5
leaq 0xa0(%rsp), %r14
leaq 0x28(%rsp), %r15
movq (%r12), %rax
movq %rax, 0x28(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a4bafc
addq $0x8, %r12
cmpq %r13, %r12
jne 0x1a408a8
movq 0xa0(%rsp), %r13
movq 0xa8(%rsp), %rbp
cmpq %rbp, %r13
je 0x1a40987
leaq 0x28(%rsp), %r15
leaq 0x190(%rsp), %r12
movq (%r13), %r14
movq %r14, 0x28(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1a3152e
testb %al, %al
je 0x1a4097a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a46a34
leaq 0x2e0(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
cmpl $0x0, 0x10(%rcx)
jne 0x1a4097a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a456d4
movq %rax, 0x190(%rsp)
testq %rax, %rax
je 0x1a4097a
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x2682e9e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1a416b6
movq %r14, 0x28(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a40c54
movq 0x190(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a45fa4
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x1a408eb
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x1a409a4
movq 0xb0(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
addq $0x208, %rsp # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
lock
incl 0x8(%r14)
leaq 0x2e8(%r12), %rdi
leaq 0xa0(%rsp), %r15
movq %r15, %rsi
callq 0x1a49c1c
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x1a409e1
callq 0xa775b8
movq %r14, %rdi
callq 0xa775b8
jmp 0x1a40814
|
/Analysis/ScopDetection.cpp
|
polly::ScopDetection::addOverApproximatedRegion(llvm::Region*, polly::ScopDetection::DetectionContext&) const
|
bool ScopDetection::addOverApproximatedRegion(Region *AR,
DetectionContext &Context) const {
// If we already know about Ar we can exit.
if (!Context.NonAffineSubRegionSet.insert(AR))
return true;
// All loops in the region have to be overapproximated too if there
// are accesses that depend on the iteration count.
for (BasicBlock *BB : AR->blocks()) {
Loop *L = LI.getLoopFor(BB);
if (AR->contains(L))
Context.BoxedLoopsSet.insert(L);
}
return (AllowNonAffineSubLoops || Context.BoxedLoopsSet.empty());
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdi, %r14
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rsp)
leaq 0x398(%rdx), %rdi
movq %rax, %rsi
callq 0x1a416b6
movb $0x1, %cl
testb %al, %al
je 0x1a416a2
movq 0x10(%rsp), %rsi
leaq 0x118(%rsp), %rbx
movq %rbx, %rdi
callq 0x26834fc
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x2b4e852
leaq 0x88(%rsp), %rdi
leaq 0x178(%rsp), %rsi
callq 0x137f090
leaq 0x190(%rsp), %rdx
leaq 0xc0(%rsp), %rsi
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0x2b4e852
leaq 0x100(%rsp), %rdi
leaq 0x1f0(%rsp), %rsi
callq 0x137f090
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb31afc
testb %al, %al
jne 0x1a415be
movq 0x8(%rsp), %rax
leaq 0x3c0(%rax), %r15
leaq 0x18(%rsp), %r12
leaq 0x20(%rsp), %r13
leaq 0x28(%rsp), %rbp
leaq 0xa0(%rsp), %rbx
movq 0x90(%rsp), %rax
movq -0x20(%rax), %rax
movq 0x40(%r14), %rdi
movq %rax, 0x18(%rsp)
movq %r12, %rsi
movq %r13, %rdx
callq 0xb31c52
testb %al, %al
je 0x1a41587
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
jmp 0x1a41589
xorl %esi, %esi
movq %rsi, 0x18(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2682bfc
testb %al, %al
je 0x1a415a7
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a41704
movq %rbp, %rdi
callq 0xb31f34
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xb31afc
testb %al, %al
je 0x1a41558
movq 0x100(%rsp), %rdi
testq %rdi, %rdi
je 0x1a415db
movq 0x110(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq 0xa8(%rsp), %rdi
cmpq 0xa0(%rsp), %rdi
je 0x1a415f2
callq 0x780910
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1a4160f
movq 0x98(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq 0x30(%rsp), %rdi
cmpq 0x28(%rsp), %rdi
je 0x1a41620
callq 0x780910
movq 0x1f0(%rsp), %rdi
testq %rdi, %rdi
je 0x1a4163d
movq 0x200(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq 0x198(%rsp), %rdi
cmpq 0x190(%rsp), %rdi
je 0x1a41654
callq 0x780910
movq 0x178(%rsp), %rdi
testq %rdi, %rdi
je 0x1a41671
movq 0x188(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq 0x120(%rsp), %rdi
cmpq 0x118(%rsp), %rdi
je 0x1a41688
callq 0x780910
cmpb $0x0, 0x3f00fb9(%rip) # 0x5942648
movb $0x1, %cl
jne 0x1a416a2
movq 0x8(%rsp), %rax
cmpl $0x0, 0x3e0(%rax)
sete %cl
movl %ecx, %eax
addq $0x208, %rsp # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Analysis/ScopDetection.cpp
|
llvm::SetVector<llvm::Region const*, llvm::SmallVector<llvm::Region const*, 0u>, llvm::DenseSet<llvm::Region const*, llvm::DenseMapInfo<llvm::Region const*, void>>, 0u>::insert(llvm::Region const* const&)
|
bool insert(const value_type &X) {
if constexpr (canBeSmall())
if (isSmall()) {
if (!llvm::is_contained(vector_, X)) {
vector_.push_back(X);
if (vector_.size() > N)
makeBig();
return true;
}
return false;
}
bool result = set_.insert(X).second;
if (result)
vector_.push_back(X);
return result;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1a493f4
movb 0x10(%r15), %bpl
cmpb $0x1, %bpl
jne 0x1a416f7
addq $0x18, %rbx
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1a493b6
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/ADT/SetVector.h
|
polly::MemAccInst::getPointerOperand() const
|
llvm::Value *getPointerOperand() const {
if (isLoad())
return asLoad()->getPointerOperand();
if (isStore())
return asStore()->getPointerOperand();
if (isMemIntrinsic())
return asMemIntrinsic()->getRawDest();
if (isCallInst())
return nullptr;
llvm_unreachable("Operation not supported on nullptr");
}
|
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1a448ff
cmpb $0x3d, (%rax)
je 0x1a448f9
testq %rax, %rax
je 0x1a448ff
cmpb $0x3e, (%rax)
jne 0x1a448ff
movq -0x20(%rax), %rax
jmp 0x1a4491e
movq %rbx, %rdi
callq 0x1a483ec
testb %al, %al
je 0x1a4491c
movq (%rbx), %rax
movl 0x4(%rax), %ecx
shll $0x5, %ecx
subq %rcx, %rax
movq (%rax), %rax
jmp 0x1a4491e
xorl %eax, %eax
popq %rbx
retq
|
/polly/Support/ScopHelper.h
|
bool polly::ScopDetection::invalid<polly::ReportUnknownInst, llvm::Instruction*>(polly::ScopDetection::DetectionContext&, bool, llvm::Instruction*&&) const
|
inline bool ScopDetection::invalid(DetectionContext &Context, bool Assert,
Args &&...Arguments) const {
if (!Context.Verifying) {
RejectLog &Log = Context.Log;
std::shared_ptr<RR> RejectReason = std::make_shared<RR>(Arguments...);
Context.IsInvalid = true;
// Log even if PollyTrackFailures is false, the log entries are also used in
// canUseISLTripCount().
Log.report(RejectReason);
POLLY_DEBUG(dbgs() << RejectReason->getMessage());
POLLY_DEBUG(dbgs() << "\n");
} else {
assert(!Assert && "Verification of detected scop failed");
}
return false;
}
|
cmpb $0x0, 0x2d8(%rsi)
jne 0x1a450f1
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rsi, %r14
movl $0x28, %edi
callq 0x7808d0
movq %rax, %rbx
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%rbx)
leaq 0x3e3742c(%rip), %rax # 0x587c4a8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x10(%rbx), %r12
movq (%r15), %rsi
movq %r12, %rdi
callq 0x1a4ecb0
movb $0x1, 0x2d9(%r14)
movq %r12, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq 0x3eb6a2d(%rip), %rax # 0x58fbad8
cmpb $0x0, (%rax)
je 0x1a450b5
incl 0x8(%rbx)
jmp 0x1a450b9
lock
incl 0x8(%rbx)
addq $0x2e8, %r14 # imm = 0x2E8
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a49c1c
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x1a450de
callq 0xa775b8
movq %rbx, %rdi
callq 0xa775b8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
xorl %eax, %eax
retq
|
/Analysis/ScopDetection.cpp
|
polly::ScopDetection::getDetectionContext(llvm::Region const*) const
|
ScopDetection::DetectionContext *
ScopDetection::getDetectionContext(const Region *R) const {
auto DCMIt = DetectionContextMap.find(getBBPairForRegion(R));
if (DCMIt == DetectionContextMap.end())
return nullptr;
return DCMIt->second.get();
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
movq %rsi, %rdi
callq 0x1a4c6bc
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r14, %rdi
callq 0x1a46a82
movl 0x68(%rbx), %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x58(%rbx), %rcx
cmpq %rcx, %rax
je 0x1a46a78
movq 0x10(%rax), %rax
jmp 0x1a46a7a
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/Analysis/ScopDetection.cpp
|
bool llvm::DenseMapBase<llvm::SmallDenseMap<llvm::SCEV const*, llvm::SCEV const*, 4u, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::SCEV const*>>, llvm::SCEV const*, llvm::SCEV const*, llvm::DenseMapInfo<llvm::SCEV const*, void>, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::SCEV const*>>::LookupBucketFor<llvm::SCEV const*>(llvm::SCEV const* const&, llvm::detail::DenseMapPair<llvm::SCEV const*, llvm::SCEV const*> const*&) const
|
const BucketT *getBuckets() const {
return Small ? getInlineBuckets() : getLargeRep()->Buckets;
}
|
leaq 0x8(%rdi), %rcx
testb $0x1, (%rdi)
cmoveq 0x8(%rdi), %rcx
movl $0x4, %r8d
cmovel 0x10(%rdi), %r8d
testl %r8d, %r8d
je 0x1a47e65
pushq %rbx
movl (%rsi), %edi
movl %edi, %eax
shrl $0x4, %eax
shrl $0x9, %edi
xorl %eax, %edi
decl %r8d
andl %r8d, %edi
movl $0x1, %r10d
xorl %r9d, %r9d
movl %edi, %ebx
shlq $0x4, %rbx
leaq (%rcx,%rbx), %r11
movq (%rcx,%rbx), %rbx
cmpq %rbx, (%rsi)
jne 0x1a47e2c
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0x1a47e0a
jmp 0x1a47e62
cmpq $-0x1000, %rbx # imm = 0xF000
jne 0x1a47e46
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x1a47e25
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %edi
incl %r10d
andl %r8d, %edi
movb $0x1, %r11b
jmp 0x1a47e25
popq %rbx
jmp 0x1a47e6e
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
nop
|
/llvm/ADT/DenseMap.h
|
void llvm::cl::apply<llvm::cl::opt<bool, true, llvm::cl::parser<bool>>, char [31], llvm::cl::desc, llvm::cl::LocationClass<bool>, llvm::cl::OptionHidden, llvm::cl::initializer<bool>, llvm::cl::cat>(llvm::cl::opt<bool, true, llvm::cl::parser<bool>>*, char const (&) [31], llvm::cl::desc const&, llvm::cl::LocationClass<bool> const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> const&, llvm::cl::cat const&)
|
void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x40(%rsp), %rbx
movq %rsi, %rdi
callq 0x7802c0
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2b1f336
movups (%r12), %xmm0
movups %xmm0, 0x20(%rbp)
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq (%rsp), %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a48b36
|
/llvm/Support/CommandLine.h
|
void llvm::cl::apply<llvm::cl::opt<bool, true, llvm::cl::parser<bool>>, char [28], llvm::cl::desc, llvm::cl::LocationClass<bool>, llvm::cl::OptionHidden, llvm::cl::initializer<bool>, llvm::cl::cat>(llvm::cl::opt<bool, true, llvm::cl::parser<bool>>*, char const (&) [28], llvm::cl::desc const&, llvm::cl::LocationClass<bool> const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> const&, llvm::cl::cat const&)
|
void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x40(%rsp), %rbx
movq %rsi, %rdi
callq 0x7802c0
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2b1f336
movups (%r12), %xmm0
movups %xmm0, 0x20(%rbp)
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq (%rsp), %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a48b36
|
/llvm/Support/CommandLine.h
|
llvm::DenseMap<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>, std::unique_ptr<polly::ScopDetection::DetectionContext, std::default_delete<polly::ScopDetection::DetectionContext>>, llvm::DenseMapInfo<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>, std::unique_ptr<polly::ScopDetection::DetectionContext, std::default_delete<polly::ScopDetection::DetectionContext>>>>::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, %rbx
movl 0x10(%rdi), %r15d
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %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 %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %eax
cmpl $0x41, %eax
movl $0x40, %ecx
cmovael %eax, %ecx
movq (%rdi), %r14
movl %ecx, 0x10(%rdi)
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%rbx)
testq %r14, %r14
je 0x1a4929d
shlq $0x3, %r15
leaq (%r15,%r15,2), %r15
leaq (%r14,%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a492d2
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2b410f1
movq $0x0, 0x8(%rbx)
movl 0x10(%rbx), %ecx
testq %rcx, %rcx
je 0x1a492cc
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rcx
movq $-0x1000, %rdx # imm = 0xF000
movq %rdx, (%rax)
movq %rdx, 0x8(%rax)
addq $0x18, %rax
cmpq %rcx, %rax
jne 0x1a492bc
popq %rbx
popq %r14
popq %r15
retq
|
/llvm/ADT/DenseMap.h
|
llvm::DenseMap<llvm::Loop const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Loop const*, void>, llvm::detail::DenseSetPair<llvm::Loop const*>>::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 $0x3, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%r15)
testq %r14, %r14
je 0x1a4996a
leaq (%r14,%rbx,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a49a2c
shlq $0x3, %rbx
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 0x1a49a25
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
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]
xorl %edx, %edx
movdqa 0x116b670(%rip), %xmm1 # 0x2bb5020
movdqa 0x116b678(%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 0x1a49a04
movq $-0x1000, (%rax,%rdx,8) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1a49a1c
movq $-0x1000, 0x8(%rax,%rdx,8) # imm = 0xF000
addq $0x2, %rdx
cmpq %rdx, %rcx
jne 0x1a499c0
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
bool llvm::DenseMapBase<llvm::DenseMap<llvm::AssertingVH<llvm::LoadInst>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::AssertingVH<llvm::LoadInst>, void>, llvm::detail::DenseSetPair<llvm::AssertingVH<llvm::LoadInst>>>, llvm::AssertingVH<llvm::LoadInst>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::AssertingVH<llvm::LoadInst>, void>, llvm::detail::DenseSetPair<llvm::AssertingVH<llvm::LoadInst>>>::LookupBucketFor<llvm::AssertingVH<llvm::LoadInst>>(llvm::AssertingVH<llvm::LoadInst> const&, llvm::detail::DenseSetPair<llvm::AssertingVH<llvm::LoadInst>> const*&) const
|
unsigned getNumBuckets() const {
return NumBuckets;
}
|
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1a49bd2
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %r11d
leaq (%rdi,%r11,8), %r11
movq (%r11), %rbx
cmpq %rbx, (%rsi)
jne 0x1a49b99
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0x1a49b7b
jmp 0x1a49bcf
cmpq $-0x1000, %rbx # imm = 0xF000
jne 0x1a49bb3
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x1a49b92
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
andl %ecx, %r8d
movb $0x1, %r11b
jmp 0x1a49b92
popq %rbx
jmp 0x1a49bdb
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
|
/llvm/ADT/DenseMap.h
|
llvm::SmallVectorTemplateBase<llvm::AssertingVH<llvm::LoadInst>, true>::push_back(llvm::AssertingVH<llvm::LoadInst>)
|
void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x1a49dc5
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x2b4ed86
jmp 0x1a49db0
nop
|
/llvm/ADT/SmallVector.h
|
llvm::detail::DenseSetPair<llvm::AssertingVH<llvm::LoadInst>>* llvm::DenseMapBase<llvm::DenseMap<llvm::AssertingVH<llvm::LoadInst>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::AssertingVH<llvm::LoadInst>, void>, llvm::detail::DenseSetPair<llvm::AssertingVH<llvm::LoadInst>>>, llvm::AssertingVH<llvm::LoadInst>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::AssertingVH<llvm::LoadInst>, void>, llvm::detail::DenseSetPair<llvm::AssertingVH<llvm::LoadInst>>>::InsertIntoBucketImpl<llvm::AssertingVH<llvm::LoadInst>>(llvm::AssertingVH<llvm::LoadInst> const&, llvm::AssertingVH<llvm::LoadInst> const&, llvm::detail::DenseSetPair<llvm::AssertingVH<llvm::LoadInst>>*)
|
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 the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
}
|
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 0x1a49e99
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x1a49e9b
incl 0x8(%rbx)
cmpq $-0x1000, (%rax) # imm = 0xF000
je 0x1a49e8f
decl 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
addl %esi, %esi
movq %rbx, %rdi
callq 0x1a49ebc
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1a49b52
movq (%r15), %rax
jmp 0x1a49e80
nop
|
/llvm/ADT/DenseMap.h
|
void llvm::SmallVectorImpl<llvm::SCEV const*>::append<__gnu_cxx::__normal_iterator<llvm::SCEV const**, std::vector<llvm::SCEV const*, std::allocator<llvm::SCEV const*>>>, void>(__gnu_cxx::__normal_iterator<llvm::SCEV const**, std::vector<llvm::SCEV const*, std::allocator<llvm::SCEV const*>>>, __gnu_cxx::__normal_iterator<llvm::SCEV const**, std::vector<llvm::SCEV const*, std::allocator<llvm::SCEV const*>>>)
|
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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq $0x3, %r13
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %r13, %rdx
cmpq %rax, %rdx
jbe 0x1a4a4e6
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x2b4ed86
cmpq %r14, %r12
je 0x1a4a500
movl 0x8(%rbx), %edi
shlq $0x3, %rdi
addq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x780120
addl %r13d, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/llvm/ADT/SmallVector.h
|
llvm::SmallVectorTemplateBase<std::pair<llvm::SCEVUnknown const*, llvm::Loop*>, true>::push_back(std::pair<llvm::SCEVUnknown const*, llvm::Loop*>)
|
void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x1a4aeca
movq (%r14), %rax
movl 0x8(%r14), %ecx
shlq $0x4, %rcx
movq %r15, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x10(%r14), %rsi
movl $0x10, %ecx
movq %r14, %rdi
callq 0x2b4ed86
jmp 0x1a4aeac
|
/llvm/ADT/SmallVector.h
|
polly::ReportLoopHasNoExit::getMessage[abi:cxx11]() const
|
std::string ReportLoopHasNoExit::getMessage() const {
return "Loop " + L->getHeader()->getName() + " has no exit.";
}
|
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x2a9f76a
movw $0x503, 0x48(%rsp) # imm = 0x503
leaq 0x353644c(%rip), %rcx # 0x4f8449a
movq %rcx, 0x28(%rsp)
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x34b9ced(%rip), %rsi # 0x4f07d6e
movq %rbx, %rdi
callq 0x1a4e092
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
|
/Analysis/ScopDetectionDiagnostic.cpp
|
polly::ReportLoopOnlySomeLatches::getMessage[abi:cxx11]() const
|
std::string ReportLoopOnlySomeLatches::getMessage() const {
return "Not all latches of loop " + L->getHeader()->getName() +
" part of scop.";
}
|
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x2a9f76a
movw $0x503, 0x48(%rsp) # imm = 0x503
leaq 0x34b998b(%rip), %rcx # 0x4f07dcd
movq %rcx, 0x28(%rsp)
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x34b9971(%rip), %rsi # 0x4f07de6
movq %rbx, %rdi
callq 0x1a4e486
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
|
/Analysis/ScopDetectionDiagnostic.cpp
|
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction const*, std::forward_list<polly::MemoryAccess*, std::allocator<polly::MemoryAccess*>>, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, std::forward_list<polly::MemoryAccess*, std::allocator<polly::MemoryAccess*>>>>, llvm::Instruction const*, std::forward_list<polly::MemoryAccess*, std::allocator<polly::MemoryAccess*>>, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, std::forward_list<polly::MemoryAccess*, std::allocator<polly::MemoryAccess*>>>>::erase(llvm::Instruction const* const&)
|
bool erase(const KeyT &Val) {
BucketT *TheBucket;
if (!LookupBucketFor(Val, TheBucket))
return false; // not in map.
TheBucket->getSecond().~ValueT();
TheBucket->getFirst() = getTombstoneKey();
decrementNumEntries();
incrementNumTombstones();
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdx
callq 0x1a1e41e
movl %eax, %ebp
testb %al, %al
je 0x1a55cdf
movq (%rsp), %r14
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1a55cbe
movq (%rdi), %r15
movl $0x10, %esi
callq 0x7800d0
movq %r15, %rdi
testq %r15, %r15
jne 0x1a55ca9
movq $0x0, 0x8(%r14)
movq $-0x2000, (%r14) # imm = 0xE000
movq 0x8(%rbx), %xmm0
paddd 0x194d976(%rip), %xmm0 # 0x33a3650
movq %xmm0, 0x8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/ADT/DenseMap.h
|
polly::Scop::addAccessData(polly::MemoryAccess*)
|
void Scop::addAccessData(MemoryAccess *Access) {
const ScopArrayInfo *SAI = Access->getOriginalScopArrayInfo();
assert(SAI && "can only use after access relations have been constructed");
if (Access->isOriginalValueKind() && Access->isRead())
ValueUseAccs[SAI].push_back(Access);
else if (Access->isOriginalAnyPHIKind() && Access->isWrite())
PHIIncomingAccs[SAI].push_back(Access);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1a51a6a
movq %rax, (%rsp)
movl 0x8(%rbx), %eax
cmpl $0x1, %eax
jne 0x1a560cf
movl $0x620, %ecx # imm = 0x620
cmpl $0x1, 0xc(%rbx)
je 0x1a560e7
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x1a56101
movl 0xc(%rbx), %eax
andl $-0x2, %eax
movl $0x638, %ecx # imm = 0x638
cmpl $0x2, %eax
jne 0x1a56101
addq %rcx, %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x1a5feb0
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x1a25128
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/Analysis/ScopInfo.cpp
|
polly::Scop::getParamSpace() const
|
isl::space Scop::getParamSpace() const { return getContext().get_space(); }
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x128(%rsi), %rdi
callq 0x1b10b72
movq %rax, %r14
movq %rax, %rdi
callq 0x1b0fb8c
movq %rax, (%rbx)
testq %r14, %r14
je 0x1a56ede
movq %r14, %rdi
callq 0x1b139c2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/Analysis/ScopInfo.cpp
|
polly::Scop::getDomainConditions(llvm::BasicBlock*) const
|
isl::set Scop::getDomainConditions(BasicBlock *BB) const {
auto DIt = DomainMap.find(BB);
if (DIt != DomainMap.end())
return DIt->getSecond();
auto &RI = *R.getRegionInfo();
auto *BBR = RI.getRegionFor(BB);
while (BBR->getEntry() == BB)
BBR = BBR->getParent();
return getDomainConditions(BBR->getEntry());
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x110(%rsi), %r15
movq %rdx, %r12
movq %r15, %rdi
movq %rdx, %rsi
callq 0x1a56f96
movl 0x120(%r14), %ecx
shlq $0x4, %rcx
addq 0x110(%r14), %rcx
cmpq %rcx, %rax
jne 0x1a56f74
movq 0x20(%r14), %rax
movq 0x10(%rax), %rdi
movq %r12, %rsi
callq 0x2681e84
movq (%rax), %rdx
andq $-0x8, %rdx
cmpq %r12, %rdx
jne 0x1a56f2d
movq 0x8(%rax), %rax
jmp 0x1a56f62
movq $0x0, (%rbx)
movq 0x8(%rax), %rdi
callq 0x1b10b72
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/Analysis/ScopInfo.cpp
|
polly::Scop::Scop(llvm::Region&, llvm::ScalarEvolution&, llvm::LoopInfo&, llvm::DominatorTree&, polly::ScopDetection::DetectionContext&, llvm::OptimizationRemarkEmitter&, int)
|
Scop::Scop(Region &R, ScalarEvolution &ScalarEvolution, LoopInfo &LI,
DominatorTree &DT, ScopDetection::DetectionContext &DC,
OptimizationRemarkEmitter &ORE, int ID)
: IslCtx(isl_ctx_alloc(), isl_ctx_free), SE(&ScalarEvolution), DT(&DT),
R(R), name(std::nullopt), HasSingleExitEdge(R.getExitingBlock()), DC(DC),
ORE(ORE), Affinator(this, LI), ID(ID) {
// Options defaults that are different from ISL's.
isl_options_set_schedule_serialize_sccs(IslCtx.get(), true);
SmallVector<char *, 8> IslArgv;
IslArgv.reserve(1 + IslArgs.size());
// Substitute for program name.
IslArgv.push_back(const_cast<char *>("-polly-isl-arg"));
for (std::string &Arg : IslArgs)
IslArgv.push_back(const_cast<char *>(Arg.c_str()));
// Abort if unknown argument is passed.
// Note that "-V" (print isl version) will always call exit(0), so we cannot
// avoid ISL aborting the program at this point.
unsigned IslParseFlags = ISL_ARG_ALL;
isl_ctx_parse_options(IslCtx.get(), IslArgv.size(), IslArgv.data(),
IslParseFlags);
if (IslOnErrorAbort)
isl_options_set_on_error(getIslCtx().get(), ISL_ON_ERROR_ABORT);
buildContext();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r13
movq %rcx, 0x10(%rsp)
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %rbx
callq 0x1af85ae
movq %rax, %r14
movq %rax, (%rbx)
xorl %r15d, %r15d
movq %r15, 0x8(%rbx)
movl $0x20, %edi
callq 0x7808d0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x3e26173(%rip), %rcx # 0x587d1a0
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0xa15b5(%rip), %rcx # 0x1af85f0
movq %rcx, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rax, 0x8(%rbx)
movq %rbp, 0x10(%rbx)
movq %r13, 0x18(%rbx)
movq %r12, 0x20(%rbx)
movb %r15b, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x59(%rbx)
movq %r12, %rdi
callq 0x2681fde
testq %rax, %rax
setne 0x69(%rbx)
movb %r15b, 0x6a(%rbx)
movq %r15, 0x6c(%rbx)
leaq 0x78(%rbx), %rax
movq %rax, 0x80(%rbx)
movq %rax, 0x78(%rbx)
leaq 0xb8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x94(%rbx)
movq %rax, 0xa8(%rbx)
movups %xmm0, 0xb0(%rbx)
movups %xmm0, 0xbc(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0xd0(%rbx)
movq 0xa0(%rsp), %rax
movq %rax, 0xd8(%rbx)
movq %r15, 0x128(%rbx)
leaq 0x130(%rbx), %rdi
movups %xmm0, 0xe0(%rbx)
movl %r15d, 0xf0(%rbx)
movups %xmm0, 0xf8(%rbx)
movl %r15d, 0x108(%rbx)
movl %r15d, 0x120(%rbx)
movups %xmm0, 0x110(%rbx)
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
callq 0x1a8751a
leaq 0x190(%rbx), %rax
movl %r15d, 0x190(%rbx)
movq %r15, 0x198(%rbx)
movq %rax, 0x1a0(%rbx)
movq %rax, 0x1a8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1b0(%rbx)
movups %xmm0, 0x1bc(%rbx)
movl $0x10, 0x1cc(%rbx)
movups %xmm0, 0x1d0(%rbx)
movl %r15d, 0x1e0(%rbx)
leaq 0x1f8(%rbx), %rax
movq %rax, 0x1e8(%rbx)
leaq 0x230(%rbx), %rax
movups %xmm0, 0x1f0(%rbx)
movups %xmm0, 0x200(%rbx)
movups %xmm0, 0x20a(%rbx)
movq %rax, 0x220(%rbx)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, 0x228(%rbx)
leaq 0x4d8(%rbx), %rax
movups %xmm0, 0x4b0(%rbx)
movl %r15d, 0x4c0(%rbx)
movq %rax, 0x4c8(%rbx)
movabsq $0x800000000, %r12 # imm = 0x800000000
movq %r12, 0x4d0(%rbx)
movups %xmm0, 0x5d8(%rbx)
movl 0xa8(%rsp), %eax
movl %eax, 0x5e8(%rbx)
movl %r15d, 0x600(%rbx)
movups %xmm0, 0x5f0(%rbx)
movups %xmm0, 0x608(%rbx)
movl %r15d, 0x618(%rbx)
movups %xmm0, 0x620(%rbx)
movl %r15d, 0x630(%rbx)
movups %xmm0, 0x638(%rbx)
movl %r15d, 0x648(%rbx)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x1b38ec2
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x3eebedf(%rip), %rdx # 0x5943118
subq 0x3eebed0(%rip), %rdx # 0x5943110
movq %r12, -0x8(%r14)
sarq $0x5, %rdx
incq %rdx
cmpq $0x9, %rdx
jb 0x1a57263
leaq 0x18(%rsp), %rdi
movl $0x8, %ecx
movq %r14, %rsi
callq 0x2b4ed86
leaq 0x34b1223(%rip), %rsi # 0x4f0848d
leaq 0x18(%rsp), %rdi
callq 0x1a572f4
movq 0x3eebe95(%rip), %r12 # 0x5943110
movq 0x3eebe96(%rip), %r13 # 0x5943118
cmpq %r13, %r12
je 0x1a572a1
leaq 0x18(%rsp), %r15
movq (%r12), %rsi
movq %r15, %rdi
callq 0x1a572f4
addq $0x20, %r12
cmpq %r13, %r12
jne 0x1a5728c
movq (%rbx), %rdi
movl 0x20(%rsp), %esi
movq 0x18(%rsp), %rdx
movl $0x1, %ecx
callq 0x1af8750
cmpb $0x0, 0x3eeb9ca(%rip) # 0x5942c88
je 0x1a572cd
movq (%rbx), %rdi
movl $0x2, %esi
callq 0x1b385d2
movq %rbx, %rdi
callq 0x1a567ac
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a572e4
callq 0x780910
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/Analysis/ScopInfo.cpp
|
polly::Scop::createScopArrayInfo(llvm::Type*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned int, std::allocator<unsigned int>> const&)
|
ScopArrayInfo *Scop::createScopArrayInfo(Type *ElementType,
const std::string &BaseName,
const std::vector<unsigned> &Sizes) {
auto *DimSizeType = Type::getInt64Ty(getSE()->getContext());
std::vector<const SCEV *> SCEVSizes;
for (auto size : Sizes)
if (size)
SCEVSizes.push_back(getSE()->getConstant(DimSizeType, size, false));
else
SCEVSizes.push_back(nullptr);
auto *SAI = getOrCreateScopArrayInfo(nullptr, ElementType, SCEVSizes,
MemoryKind::Array, BaseName.c_str());
return SAI;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r13
movq %rdx, 0x28(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq (%rax), %rdi
callq 0x2a3b1a0
movq %rax, %rdi
callq 0x2a9aade
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq (%r13), %rbx
movq 0x8(%r13), %r15
cmpq %r15, %rbx
je 0x1a57f0e
movq %rax, %r12
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %rbp
movl (%rbx), %edx
testq %rdx, %rdx
je 0x1a57ef1
movq 0x10(%r14), %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x268c660
movq %rax, 0x8(%rsp)
jmp 0x1a57efa
movq $0x0, 0x8(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1a5f1de
addq $0x4, %rbx
cmpq %r15, %rbx
jne 0x1a57ed5
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
subq %rcx, %r8
sarq $0x3, %r8
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
movq 0x30(%rsp), %rdx
xorl %r9d, %r9d
callq 0x1a55f0c
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a57f57
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/Analysis/ScopInfo.cpp
|
polly::Scop::getEntryExitStr[abi:cxx11]() const
|
std::pair<std::string, std::string> Scop::getEntryExitStr() const {
std::string ExitName, EntryName;
raw_string_ostream ExitStr(ExitName);
raw_string_ostream EntryStr(EntryName);
R.getEntry()->printAsOperand(EntryStr, false);
EntryStr.str();
if (R.getExit()) {
R.getExit()->printAsOperand(ExitStr, false);
ExitStr.str();
} else
ExitName = "FunctionExit";
return std::make_pair(EntryName, ExitName);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
xorl %ebp, %ebp
movq %rbp, -0x8(%rax)
movb %bpl, (%rax)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rbp, -0x8(%rax)
movb %bpl, (%rax)
leaq 0x48(%rsp), %rdi
movl %ebp, 0x8(%rdi)
movb %bpl, 0x28(%rdi)
movl $0x1, %r12d
movl %r12d, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rbp, 0x20(%rdi)
leaq 0x3ea1bff(%rip), %r13 # 0x58f9f80
addq $0x10, %r13
movq %r13, (%rdi)
leaq 0x8(%rsp), %rax
movq %rax, 0x30(%rdi)
callq 0x7fa22e
leaq 0x80(%rsp), %r15
movl %ebp, 0x8(%r15)
movb %bpl, 0x28(%r15)
movl %r12d, 0x2c(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rbp, 0x20(%r15)
movq %r13, (%r15)
leaq 0x28(%rsp), %rax
movq %rax, 0x30(%r15)
movq %r15, %rdi
callq 0x7fa22e
movq 0x20(%r14), %rax
movq (%rax), %rdi
andq $-0x8, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2998ac2
movq 0x20(%r14), %rax
movq 0x20(%rax), %rdi
testq %rdi, %rdi
je 0x1a583fe
leaq 0x48(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2998ac2
jmp 0x1a5841b
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x20e9095(%rip), %rcx # 0x3b414a3
movl $0xc, %r8d
xorl %esi, %esi
callq 0x780bb0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x7fc9f8
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
callq 0x7fc9f8
leaq 0x80(%rsp), %rdi
callq 0x2b7e98e
leaq 0x48(%rsp), %rdi
callq 0x2b7e98e
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1a58488
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7800d0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1a584a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7800d0
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/Analysis/ScopInfo.cpp
|
polly::Scop::getMayWrites()
|
isl::union_map Scop::getMayWrites() {
return getAccessesOfType([](MemoryAccess &MA) { return MA.isMayWrite(); });
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x550d(%rip), %rax # 0x1a5f304
movq %rax, 0x18(%r14)
leaq 0x550a(%rip), %rax # 0x1a5f30c
movq %rax, 0x10(%r14)
movq %r14, %rdx
callq 0x1a59bf4
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x1a59e24
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
|
/Analysis/ScopInfo.cpp
|
std::__tuple_compare<std::tuple<llvm::RegionNode*, llvm::RNSuccIterator<llvm::RegionNode*, llvm::BasicBlock, llvm::Region>, llvm::RNSuccIterator<llvm::RegionNode*, llvm::BasicBlock, llvm::Region>>, std::tuple<llvm::RegionNode*, llvm::RNSuccIterator<llvm::RegionNode*, llvm::BasicBlock, llvm::Region>, llvm::RNSuccIterator<llvm::RegionNode*, llvm::BasicBlock, llvm::Region>>, 1ul, 3ul>::__eq(std::tuple<llvm::RegionNode*, llvm::RNSuccIterator<llvm::RegionNode*, llvm::BasicBlock, llvm::Region>, llvm::RNSuccIterator<llvm::RegionNode*, llvm::BasicBlock, llvm::Region>> const&, std::tuple<llvm::RegionNode*, llvm::RNSuccIterator<llvm::RegionNode*, llvm::BasicBlock, llvm::Region>, llvm::RNSuccIterator<llvm::RegionNode*, llvm::BasicBlock, llvm::Region>> const&)
|
constexpr intptr_t asInt() const {
intptr_t R = 0;
std::memcpy(&R, Data, sizeof(R));
return R;
}
|
movq 0x18(%rdi), %rax
testb $0x6, %al
je 0x1a71e4d
xorl 0x18(%rsi), %eax
testb $0x6, %al
jmp 0x1a71e53
movl 0x28(%rdi), %eax
cmpl 0x28(%rsi), %eax
sete %al
testb %al, %al
je 0x1a71e67
movq (%rdi), %rax
testb $0x6, %al
je 0x1a71e6a
xorl (%rsi), %eax
testb $0x6, %al
jmp 0x1a71e70
xorl %eax, %eax
retq
movl 0x10(%rdi), %eax
cmpl 0x10(%rsi), %eax
sete %al
retq
|
/llvm/ADT/PointerIntPair.h
|
llvm::SmallVectorTemplateBase<std::pair<polly::ScopStmt*, llvm::Instruction*>, true>::push_back(std::pair<polly::ScopStmt*, llvm::Instruction*>)
|
void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x1a731de
movq (%r14), %rax
movl 0x8(%r14), %ecx
shlq $0x4, %rcx
movq %r15, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x10(%r14), %rsi
movl $0x10, %ecx
movq %r14, %rdi
callq 0x2b4ed86
jmp 0x1a731c0
|
/llvm/ADT/SmallVector.h
|
llvm::DOTGraphTraits<polly::ScopDetection*>::getEdgeAttributes[abi:cxx11](llvm::RegionNode*, llvm::RNSuccIterator<llvm::FlatIt<llvm::RegionNode*>, llvm::BasicBlock, llvm::Region>, polly::ScopDetection*)
|
std::string DOTGraphTraits<ScopDetection *>::getEdgeAttributes(
RegionNode *srcNode, GraphTraits<RegionInfo *>::ChildIteratorType CI,
ScopDetection *SD) {
RegionNode *destNode = *CI;
if (srcNode->isSubRegion() || destNode->isSubRegion())
return "";
// In case of a backedge, do not use it to define the layout of the nodes.
BasicBlock *srcBB = srcNode->getNodeAs<BasicBlock>();
BasicBlock *destBB = destNode->getNodeAs<BasicBlock>();
RegionInfo *RI = SD->getRI();
Region *R = RI->getRegionFor(destBB);
while (R && R->getParent())
if (R->getParent()->getEntry() == destBB)
R = R->getParent();
else
break;
if (R && R->getEntry() == destBB && R->contains(srcBB))
return "constraint=false";
return "";
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
movq 0x38(%rsp), %rdi
movl 0x40(%rsp), %esi
callq 0x2a5329a
movq 0x30(%rsp), %rcx
movq 0x8(%rcx), %rdi
movq %rax, %rsi
callq 0x2682df6
movq (%r14), %r14
testb $0x4, %r14b
jne 0x1a74698
movq (%rax), %r15
testb $0x4, %r15b
jne 0x1a74698
andq $-0x8, %r14
andq $-0x8, %r15
movq 0x48(%r12), %rdi
movq %r15, %rsi
callq 0x2681e84
testq %rax, %rax
je 0x1a74698
movq %rax, %rdi
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x1a74666
movq (%rax), %rcx
andq $-0x8, %rcx
cmpq %r15, %rcx
je 0x1a74649
movq (%rdi), %rax
andq $-0x8, %rax
cmpq %r15, %rax
jne 0x1a74698
movq %r14, %rsi
callq 0x268177a
testb %al, %al
je 0x1a74698
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3494909(%rip), %rsi # 0x4f08f95
leaq 0x3494912(%rip), %rdx # 0x4f08fa5
movq %rbx, %rdi
jmp 0x1a746ac
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x24e6e12(%rip), %rdx # 0x3f5b4b8
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x7fa87c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/Analysis/ScopGraphPrinter.cpp
|
llvm::DOTGraphTraitsPrinterWrapperPass<polly::ScopDetectionWrapperPass, true, polly::ScopDetection*, ScopDetectionAnalysisGraphTraits>::~DOTGraphTraitsPrinterWrapperPass()
|
DOTGraphTraitsPrinterWrapperPass(StringRef GraphName, char &ID)
: FunctionPass(ID), Name(GraphName) {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x3e07fab(%rip), %rax # 0x587d6d8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x1a7574c
movq (%rax), %rsi
incq %rsi
callq 0x7800d0
movq %rbx, %rdi
callq 0x2a8b596
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x7800d0
|
/llvm/Analysis/DOTGraphTraitsPass.h
|
polly::ScopPass::runOnRegion(llvm::Region*, llvm::RGPassManager&)
|
bool ScopPass::runOnRegion(Region *R, RGPassManager &RGM) {
S = nullptr;
if (skipRegion(*R))
return false;
if ((S = getAnalysis<ScopInfoRegionPass>().getScop()))
return runOnScop(*S);
return false;
}
|
pushq %rbx
movq %rdi, %rbx
movq $0x0, 0x20(%rdi)
callq 0x2687b62
testb %al, %al
jne 0x1a75d5a
movq 0x8(%rbx), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq 0x3ecd58f(%rip), %rcx # 0x59432a8
leaq 0x10(%rdx), %rsi
cmpq %rcx, (%rdx)
jne 0x1a75d26
movq 0x8(%rdx), %rdi
je 0x1a75d30
movq %rsi, %rdx
cmpq %rax, %rsi
jne 0x1a75d19
movq (%rdi), %rax
leaq 0x3ecd56e(%rip), %rsi # 0x59432a8
callq *0x60(%rax)
movq 0x20(%rax), %rsi
movq %rsi, 0x20(%rbx)
testq %rsi, %rsi
je 0x1a75d5a
movq (%rbx), %rax
movq 0xa0(%rax), %rax
movq %rbx, %rdi
popq %rbx
jmpq *%rax
xorl %eax, %eax
popq %rbx
retq
|
/Analysis/ScopPass.cpp
|
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [15], llvm::cl::desc, llvm::cl::cat>(char const (&) [15], llvm::cl::desc const&, llvm::cl::cat const&)
|
explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x7fca88
movb %bpl, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movb %bpl, 0x91(%rbx)
leaq 0x3cd057e(%rip), %rax # 0x5747988
addq $0x10, %rax
movq %rax, 0x88(%rbx)
leaq 0x3e809ec(%rip), %rax # 0x58f7e08
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x3e805fe(%rip), %rax # 0x58f7a28
addq $0x10, %rax
movq %rax, 0x98(%rbx)
movups %xmm0, 0xa0(%rbx)
leaq -0x127a855(%rip), %rax # 0x7fcbee
movq %rax, 0xb8(%rbx)
leaq -0x127a861(%rip), %rax # 0x7fcbf0
movq %rax, 0xb0(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1a7a644
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2b1e814
nop
|
/llvm/Support/CommandLine.h
|
runIslAst(polly::Scop&, llvm::function_ref<polly::Dependences const& (polly::Dependences::AnalysisLevel)>)
|
static std::unique_ptr<IslAstInfo> runIslAst(
Scop &Scop,
function_ref<const Dependences &(Dependences::AnalysisLevel)> GetDeps) {
ScopsProcessed++;
const Dependences &D = GetDeps(Dependences::AL_Statement);
if (D.getSharedIslCtx() != Scop.getSharedIslCtx()) {
POLLY_DEBUG(
dbgs() << "Got dependence analysis for different SCoP/isl_ctx\n");
return {};
}
std::unique_ptr<IslAstInfo> Ast = std::make_unique<IslAstInfo>(Scop, D);
POLLY_DEBUG({
if (Ast)
Ast->print(dbgs());
});
return Ast;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, %rdi
xorl %esi, %esi
callq *%rdx
movq %rax, %r15
movq 0x40(%rax), %rax
cmpq (%r14), %rax
je 0x1a78dff
movq $0x0, (%rbx)
xorl %r12d, %r12d
jmp 0x1a78e29
movl $0x30, %edi
callq 0x7808d0
movq %rax, %r12
movq %r14, (%rax)
leaq 0x8(%rax), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x1a7829a
movq %r13, %rdi
movq %r15, %rsi
callq 0x1a78334
movq %r12, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/CodeGen/IslAst.cpp
|
polly::IslAstInfoWrapperPass::runOnScop(polly::Scop&)
|
bool IslAstInfoWrapperPass::runOnScop(Scop &Scop) {
auto GetDeps = [this](Dependences::AnalysisLevel Lvl) -> const Dependences & {
return getAnalysis<DependenceInfo>().getDependences(Lvl);
};
Ast = runIslAst(Scop, GetDeps);
return false;
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rcx
movq %rdi, (%rcx)
leaq 0xbe3(%rip), %rdx # 0x1a7a7b0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1a78dd1
movq (%r14), %rax
movq $0x0, (%r14)
movq 0x28(%rbx), %rsi
movq %rax, 0x28(%rbx)
testq %rsi, %rsi
je 0x1a79bfd
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x1a7a416
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x1a79c11
leaq 0x8(%rsp), %rdi
callq 0x1a7a416
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
/CodeGen/IslAst.cpp
|
polly::createIslAstInfoWrapperPassPass()
|
Pass *polly::createIslAstInfoWrapperPassPass() {
return new IslAstInfoWrapperPass();
}
|
pushq %rax
movl $0x30, %edi
callq 0x7808d0
movq $0x0, 0x8(%rax)
leaq 0x3eca791(%rip), %rcx # 0x59444b8
movq %rcx, 0x10(%rax)
movl $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
leaq 0x3e03bc0(%rip), %rcx # 0x587d900
addq $0x10, %rcx
movq %rcx, (%rax)
popq %rcx
retq
|
/CodeGen/IslAst.cpp
|
llvm::Pass* llvm::callDefaultCtor<(anonymous namespace)::IslAstInfoPrinterLegacyPass, true>()
|
Pass *callDefaultCtor() {
return new PassName();
}
|
pushq %rbx
movl $0x30, %edi
callq 0x7808d0
movq %rax, %rbx
callq 0x2b7e507
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
leaq 0x3ec9ea2(%rip), %rdx # 0x59444c4
movq %rdx, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
leaq 0x3e03398(%rip), %rcx # 0x587d9d0
movq %rcx, (%rbx)
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
|
/llvm/PassSupport.h
|
replace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, llvm::StringRef, llvm::StringRef)
|
static void replace(std::string &str, StringRef find, StringRef replace) {
size_t pos = 0;
while ((pos = str.find(find, pos)) != std::string::npos) {
str.replace(pos, find.size(), replace);
pos += replace.size();
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %edx, %edx
movq %r15, %rcx
callq 0x780380
cmpq $-0x1, %rax
je 0x1a8744a
movq %rax, %rbp
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x7801d0
addq %rbx, %rbp
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x780380
movq %rax, %rbp
cmpq $-0x1, %rax
jne 0x1a87419
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
|
/Support/GICHelper.cpp
|
ScopExpander::visitAddExpr(llvm::SCEVAddExpr const*)
|
const SCEV *visitAddExpr(const SCEVAddExpr *E) {
SmallVector<const SCEV *, 4> NewOps;
for (const SCEV *Op : E->operands())
NewOps.push_back(visit(Op));
return SE.getAddExpr(NewOps);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, -0x8(%r15)
movq 0x28(%rsi), %r12
testq %r12, %r12
je 0x1a8e063
movq 0x20(%rsi), %r13
shlq $0x3, %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
movq (%r13,%rbp), %rsi
movq %rbx, %rdi
callq 0x1a8da9c
movq %r14, %rdi
movq %rax, %rsi
callq 0x1a1e8f8
addq $0x8, %rbp
cmpq %rbp, %r12
jne 0x1a8e042
movq 0x330(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x268d8dc
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x1a8e08b
callq 0x780910
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/Support/ScopHelper.cpp
|
llvm::DenseMap<llvm::BasicBlock*, llvm::DenseMap<llvm::AssertingVH<llvm::Value>, llvm::AssertingVH<llvm::Value>, llvm::DenseMapInfo<llvm::AssertingVH<llvm::Value>, void>, llvm::detail::DenseMapPair<llvm::AssertingVH<llvm::Value>, llvm::AssertingVH<llvm::Value>>>, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::DenseMap<llvm::AssertingVH<llvm::Value>, llvm::AssertingVH<llvm::Value>, llvm::DenseMapInfo<llvm::AssertingVH<llvm::Value>, void>, llvm::detail::DenseMapPair<llvm::AssertingVH<llvm::Value>, llvm::AssertingVH<llvm::Value>>>>>::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 $0x5, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%r15)
testq %r14, %r14
je 0x1a9b700
shlq $0x5, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a9b7c8
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 0x1a9b7c1
movabsq $0x7ffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFF
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 $0x20, %rax
xorl %edx, %edx
movdqa 0x11198d6(%rip), %xmm1 # 0x2bb5020
movdqa 0x11198de(%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 0x1a9b79e
movq $-0x1000, -0x20(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1a9b7b4
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x40, %rax
cmpq %rdx, %rcx
jne 0x1a9b75a
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, llvm::BasicBlock*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::BasicBlock*>>, llvm::BasicBlock*, llvm::BasicBlock*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::BasicBlock*>>::FindAndConstruct(llvm::BasicBlock*&&)
|
value_type& FindAndConstruct(KeyT &&Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, std::move(Key));
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a9b99a
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x1a9b990
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1a9ba2c
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/llvm/ADT/DenseMap.h
|
isl_aff_list_drop
|
__isl_give LIST(EL) *FN(LIST(EL),drop)(__isl_take LIST(EL) *list,
unsigned first, unsigned n)
{
int i;
if (!list)
return NULL;
if (first + n > list->n || first + n < first)
isl_die(list->ctx, isl_error_invalid,
"index out of bounds", return FN(LIST(EL),free)(list));
if (n == 0)
return list;
list = FN(LIST(EL),cow)(list);
if (!list)
return NULL;
for (i = 0; i < n; ++i)
FN(EL,free)(list->p[first + i]);
for (i = first; i + n < list->n; ++i)
list->p[i] = list->p[i + n];
list->n -= n;
return list;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1aace36
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl %edx, %r15d
addl %esi, %r15d
jb 0x1aace0c
cmpl 0x10(%rbx), %r15d
ja 0x1aace0c
testl %ebp, %ebp
je 0x1aace38
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x1aacdb5
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1aacb4f
movq %rax, %rbx
testq %rbx, %rbx
je 0x1aace36
cmpl $0x1, %ebp
movl %ebp, %r12d
adcl $0x0, %r12d
movl %r14d, %r13d
movl %r13d, %eax
movq 0x20(%rbx,%rax,8), %rdi
callq 0x1aacce8
incl %r13d
decq %r12
jne 0x1aacdc7
movl 0x10(%rbx), %eax
cmpl %eax, %r15d
jae 0x1aace05
movl %r15d, %ecx
movslq %r14d, %rdx
leaq (%rbx,%rdx,8), %rdx
addq $0x20, %rdx
movq 0x20(%rbx,%rcx,8), %rsi
movq %rsi, (%rdx)
incq %rcx
addq $0x8, %rdx
cmpl %ecx, %eax
ja 0x1aacdf2
subl %ebp, %eax
movl %eax, 0x10(%rbx)
jmp 0x1aace38
movq 0x8(%rbx), %rdi
leaq 0x35e9e78(%rip), %rdx # 0x5096c8f
leaq 0x345e3a8(%rip), %rcx # 0x4f0b1c6
movl $0x5, %esi
movl $0xa7, %r8d
callq 0x1af81bb
movq %rbx, %rdi
callq 0x1aacd1b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_list_templ.c
|
isl_pw_aff_list_drop
|
__isl_give LIST(EL) *FN(LIST(EL),drop)(__isl_take LIST(EL) *list,
unsigned first, unsigned n)
{
int i;
if (!list)
return NULL;
if (first + n > list->n || first + n < first)
isl_die(list->ctx, isl_error_invalid,
"index out of bounds", return FN(LIST(EL),free)(list));
if (n == 0)
return list;
list = FN(LIST(EL),cow)(list);
if (!list)
return NULL;
for (i = 0; i < n; ++i)
FN(EL,free)(list->p[first + i]);
for (i = first; i + n < list->n; ++i)
list->p[i] = list->p[i + n];
list->n -= n;
return list;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1aadc8c
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl %edx, %r15d
addl %esi, %r15d
jb 0x1aadc62
cmpl 0x10(%rbx), %r15d
ja 0x1aadc62
testl %ebp, %ebp
je 0x1aadc8e
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x1aadc0b
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1aad978
movq %rax, %rbx
testq %rbx, %rbx
je 0x1aadc8c
cmpl $0x1, %ebp
movl %ebp, %r12d
adcl $0x0, %r12d
movl %r14d, %r13d
movl %r13d, %eax
movq 0x20(%rbx,%rax,8), %rdi
callq 0x1aadb11
incl %r13d
decq %r12
jne 0x1aadc1d
movl 0x10(%rbx), %eax
cmpl %eax, %r15d
jae 0x1aadc5b
movl %r15d, %ecx
movslq %r14d, %rdx
leaq (%rbx,%rdx,8), %rdx
addq $0x20, %rdx
movq 0x20(%rbx,%rcx,8), %rsi
movq %rsi, (%rdx)
incq %rcx
addq $0x8, %rdx
cmpl %ecx, %eax
ja 0x1aadc48
subl %ebp, %eax
movl %eax, 0x10(%rbx)
jmp 0x1aadc8e
movq 0x8(%rbx), %rdi
leaq 0x35e9022(%rip), %rdx # 0x5096c8f
leaq 0x345d552(%rip), %rcx # 0x4f0b1c6
movl $0x5, %esi
movl $0xa7, %r8d
callq 0x1af81bb
movq %rbx, %rdi
callq 0x1aadb71
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_list_templ.c
|
isl_pw_aff_list_swap
|
__isl_give LIST(EL) *FN(LIST(EL),swap)(__isl_take LIST(EL) *list,
unsigned pos1, unsigned pos2)
{
EL *el1, *el2;
if (pos1 == pos2)
return list;
el1 = FN(FN(LIST(EL),take),EL_BASE)(list, pos1);
el2 = FN(FN(LIST(EL),take),EL_BASE)(list, pos2);
list = FN(FN(LIST(EL),restore),EL_BASE)(list, pos1, el2);
list = FN(FN(LIST(EL),restore),EL_BASE)(list, pos2, el1);
return list;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl %edx, %esi
jne 0x1aadf7a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %edx, %ebx
movl %esi, %ebp
movq %r14, %rdi
callq 0x1aadfb7
movq %rax, %r15
movq %r14, %rdi
movl %ebx, %esi
callq 0x1aadfb7
movq %r14, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x1aadeb4
movq %rax, %rdi
movl %ebx, %esi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1aadeb4
|
/External/isl/isl_list_templ.c
|
isl_pw_multi_aff_list_add
|
__isl_give LIST(EL) *FN(LIST(EL),add)(__isl_take LIST(EL) *list,
__isl_take struct EL *el)
{
list = FN(LIST(EL),grow)(list, 1);
if (!list || !el)
goto error;
list->p[list->n] = el;
list->n++;
return list;
error:
FN(EL,free)(el);
FN(LIST(EL),free)(list);
return NULL;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdi, %rdi
je 0x1aae901
movq %rdi, %rbx
movl (%rdi), %ecx
cmpl $0x1, %ecx
jne 0x1aae856
movslq 0x10(%rbx), %rax
incq %rax
cmpq %rax, 0x18(%rbx)
jae 0x1aae903
movslq 0x10(%rbx), %rax
leal (%rax,%rax,2), %edx
leal (%rax,%rax,2), %esi
addl $0x6, %esi
shrl $0x1f, %esi
addl %esi, %edx
addl $0x6, %edx
sarl %edx
movq 0x8(%rbx), %rdi
cmpl $0x1, %ecx
jne 0x1aae897
movslq %edx, %r15
leaq 0x20(,%r15,8), %rdx
movq %rbx, %rsi
callq 0x1af82fa
testq %rax, %rax
je 0x1aae8f9
movq %r15, 0x18(%rax)
movq %rax, %rbx
jmp 0x1aae903
incq %rax
movq 0x18(%rbx), %rcx
movslq %edx, %rsi
cmpq %rsi, %rcx
movl %ecx, %esi
cmovael %edx, %esi
cmpq %rax, %rcx
cmovbl %edx, %esi
callq 0x1aae74c
testq %rax, %rax
je 0x1aae8f9
movq %rax, %r15
cmpl $0x0, 0x10(%rbx)
jle 0x1aae8ec
xorl %r12d, %r12d
movq 0x20(%rbx,%r12,8), %rsi
testq %rsi, %rsi
je 0x1aae8d3
incl (%rsi)
jmp 0x1aae8d5
xorl %esi, %esi
movq %r15, %rdi
callq 0x1aae827
movq %rax, %r15
incq %r12
movslq 0x10(%rbx), %rax
cmpq %rax, %r12
jl 0x1aae8c5
movq %rbx, %rdi
callq 0x1aae9c7
movq %r15, %rbx
jmp 0x1aae903
movq %rbx, %rdi
callq 0x1aae9c7
xorl %ebx, %ebx
testq %r14, %r14
je 0x1aae91d
testq %rbx, %rbx
je 0x1aae91d
movslq 0x10(%rbx), %rax
movq %r14, 0x20(%rbx,%rax,8)
incl %eax
movl %eax, 0x10(%rbx)
jmp 0x1aae92f
movq %r14, %rdi
callq 0x1aae967
movq %rbx, %rdi
callq 0x1aae9c7
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/External/isl/isl_list_templ.c
|
isl_pw_multi_aff_list_from_pw_multi_aff
|
__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 0x1aaf284
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1b6f814
movq %rax, %rdi
movl $0x1, %esi
callq 0x1aae74c
testq %rax, %rax
je 0x1aaf27c
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1aae827
movq %rbx, %rdi
callq 0x1aae967
xorl %eax, %eax
popq %rbx
retq
|
/External/isl/isl_list_templ.c
|
isl_union_pw_multi_aff_list_foreach
|
isl_stat FN(LIST(EL),foreach)(__isl_keep LIST(EL) *list,
isl_stat (*fn)(__isl_take EL *el, void *user), void *user)
{
int i;
if (!list)
return isl_stat_error;
for (i = 0; i < list->n; ++i) {
EL *el = FN(EL,copy)(list->p[i]);
if (!el)
return isl_stat_error;
if (fn(el, user) < 0)
return isl_stat_error;
}
return isl_stat_ok;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x1ab0b93
movq %rdi, %r12
cmpl $0x0, 0x10(%rdi)
jle 0x1ab0b91
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
movq 0x20(%r12,%r13,8), %rdi
testq %rdi, %rdi
je 0x1ab0b73
incl (%rdi)
jmp 0x1ab0b75
xorl %edi, %edi
testq %rdi, %rdi
je 0x1ab0b93
movq %r14, %rsi
callq *%r15
testl %eax, %eax
js 0x1ab0b93
incq %r13
movslq 0x10(%r12), %rax
cmpq %rax, %r13
jl 0x1ab0b65
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/External/isl/isl_list_templ.c
|
isl_aff_var_on_domain
|
__isl_give isl_aff *isl_aff_var_on_domain(__isl_take isl_local_space *ls,
enum isl_dim_type type, unsigned pos)
{
isl_space *space;
isl_aff *aff;
if (!ls)
return NULL;
space = isl_local_space_get_space(ls);
if (!space)
goto error;
if (isl_space_is_map(space))
isl_die(isl_space_get_ctx(space), isl_error_invalid,
"expecting (parameter) set space", goto error);
if (isl_local_space_check_range(ls, type, pos, 1) < 0)
goto error;
isl_space_free(space);
aff = isl_aff_alloc(ls);
if (!aff)
return NULL;
pos += isl_local_space_offset(aff->ls, type);
isl_int_set_si(aff->v->el[0], 1);
isl_seq_clr(aff->v->el + 1, aff->v->size - 1);
isl_int_set_si(aff->v->el[1 + pos], 1);
return aff;
error:
isl_local_space_free(ls);
isl_space_free(space);
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1ab1623
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x1b0c327
movq %rax, %r15
testq %rax, %rax
je 0x1ab1613
movq %r15, %rdi
callq 0x1b6f928
testl %eax, %eax
je 0x1ab1638
movq %r15, %rdi
callq 0x1b6f814
leaq 0x3459cbd(%rip), %rdx # 0x4f0b2b6
leaq 0x3459c31(%rip), %rcx # 0x4f0b231
movq %rax, %rdi
movl $0x5, %esi
movl $0x145, %r8d # imm = 0x145
callq 0x1af81bb
movq %r14, %rdi
callq 0x1b0bd46
movq %r15, %rdi
callq 0x1b6fe0a
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x1b0bfd6
testl %eax, %eax
js 0x1ab1613
movq %r15, %rdi
callq 0x1b6fe0a
movq %r14, %rdi
callq 0x1ab124e
testq %rax, %rax
je 0x1ab1623
movq %rax, %r14
movq 0x8(%rax), %rdi
movl %ebp, %esi
callq 0x1b0c0a4
movl %eax, %r15d
movq 0x10(%r14), %rax
movq 0x18(%rax), %r13
movq (%r13), %rdi
testb $0x1, %dil
jne 0x1ab168a
callq 0x1b9b0de
movabsq $0x100000001, %r12 # imm = 0x100000001
movq %r12, (%r13)
movq 0x10(%r14), %rax
movq 0x18(%rax), %rdi
addq $0x8, %rdi
movl 0x10(%rax), %esi
decl %esi
callq 0x1b6aef8
movq 0x10(%r14), %rax
movq 0x18(%rax), %r13
addl %r15d, %ebx
incl %ebx
movq (%r13,%rbx,8), %rdi
testb $0x1, %dil
jne 0x1ab16cb
callq 0x1b9b0de
movq %r12, (%r13,%rbx,8)
jmp 0x1ab1626
|
/External/isl/isl_aff.c
|
isl_aff_neg
|
__isl_give isl_aff *isl_aff_neg(__isl_take isl_aff *aff)
{
if (!aff)
return NULL;
if (isl_aff_is_nan(aff))
return aff;
aff = isl_aff_cow(aff);
if (!aff)
return NULL;
aff->v = isl_vec_cow(aff->v);
if (!aff->v)
return isl_aff_free(aff);
isl_seq_neg(aff->v->el + 1, aff->v->el + 1, aff->v->size - 1);
return aff;
}
|
pushq %rbx
testq %rdi, %rdi
je 0x1ab34b4
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x1b6bab8
shrl $0x1f, %eax
movl %eax, %edi
callq 0x1af811d
testl %eax, %eax
jne 0x1ab34b6
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x1ab347e
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1ab12a4
movq %rax, %rbx
testq %rbx, %rbx
je 0x1ab34b4
movq 0x10(%rbx), %rdi
callq 0x1b97ed8
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1ab34ac
movq 0x18(%rax), %rdi
addq $0x8, %rdi
movl 0x10(%rax), %edx
decl %edx
movq %rdi, %rsi
callq 0x1b6b024
jmp 0x1ab34b6
movq %rbx, %rdi
callq 0x1aacce8
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
|
/External/isl/isl_aff.c
|
isl_pw_aff_check_equal_space
|
isl_stat FN(TYPE_PAIR,check_equal_space)(__isl_keep TYPE1 *obj1,
__isl_keep TYPE2 *obj2)
{
isl_bool equal;
equal = FN(TYPE_PAIR,has_equal_space)(obj1, obj2);
if (equal < 0)
return isl_stat_error;
if (!equal)
isl_die(FN(TYPE1,get_ctx)(obj1), isl_error_invalid,
"spaces don't match", return isl_stat_error);
return isl_stat_ok;
}
|
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1ab6001
movq 0x8(%rbx), %rdi
jmp 0x1ab6003
xorl %edi, %edi
testq %rsi, %rsi
je 0x1ab600e
movq 0x8(%rsi), %rsi
jmp 0x1ab6010
xorl %esi, %esi
callq 0x1b73356
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
js 0x1ab605e
xorl %eax, %eax
testl %ecx, %ecx
jne 0x1ab605e
testq %rbx, %rbx
je 0x1ab6039
movq 0x8(%rbx), %rdi
callq 0x1b6f814
movq %rax, %rdi
jmp 0x1ab603b
xorl %edi, %edi
leaq 0x3456240(%rip), %rdx # 0x4f0c282
leaq 0x3455552(%rip), %rcx # 0x4f0b59b
movl $0x5, %esi
movl $0x16, %r8d
callq 0x1af81bb
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbx
retq
|
/External/isl/isl_type_check_equal_space_templ.c
|
isl_pw_aff_reset_space_and_domain
|
static __isl_give PW *FN(PW,reset_space_and_domain)(__isl_take PW *pw,
__isl_take isl_space *space, __isl_take isl_space *domain)
{
int i;
isl_size n;
n = FN(PW,n_piece)(pw);
if (n < 0 || !space || !domain)
goto error;
for (i = 0; i < n; ++i) {
isl_set *set;
EL *el;
set = FN(PW,take_domain_at)(pw, i);
set = isl_set_reset_space(set, isl_space_copy(domain));
pw = FN(PW,restore_domain_at)(pw, i, set);
el = FN(PW,take_base_at)(pw, i);
el = FN(EL,reset_space_and_domain)(el,
isl_space_copy(space), isl_space_copy(domain));
pw = FN(PW,restore_base_at)(pw, i, el);
}
isl_space_free(domain);
pw = FN(PW,restore_space)(pw, space);
return pw;
error:
isl_space_free(domain);
isl_space_free(space);
FN(PW,free)(pw);
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
je 0x1ab719b
movl 0x10(%r15), %eax
jmp 0x1ab71a0
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x1ab727d
testq %rbx, %rbx
je 0x1ab727d
testl %eax, %eax
js 0x1ab727d
jle 0x1ab725c
xorl %ebp, %ebp
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movl %ebp, %esi
callq 0x1ab6db2
movq %rax, %r12
movq %r14, %rdi
callq 0x1b6fd4e
movq %r12, %rdi
movq %rax, %rsi
callq 0x1b183b4
movq %r15, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x1ab6e02
movq %rax, %r15
movq %rax, %rdi
movl %ebp, %esi
callq 0x1ab6d54
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x1b6fd4e
movq %rax, %r13
movq %r14, %rdi
callq 0x1b6fd4e
movq %r14, %r12
movq %rbx, %r14
movq %rax, %rbx
movq %r13, %rdi
callq 0x1b6fe0a
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rbx
movq %r12, %r14
callq 0x1ab19ea
movq %r15, %rdi
movl %ebp, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x1ad0734
movq %rax, %r15
movl 0xc(%rsp), %eax
incl %ebp
cmpl %ebp, %eax
jne 0x1ab71c6
movq %r14, %rdi
callq 0x1b6fe0a
movq %r15, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ab6ce1
movq %r14, %rdi
callq 0x1b6fe0a
movq %rbx, %rdi
callq 0x1b6fe0a
movq %r15, %rdi
callq 0x1aadb11
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_pw_templ.c
|
isl_pw_aff_scale_val
|
__isl_give PW *FN(PW,scale_val)(__isl_take PW *pw, __isl_take isl_val *v)
{
int i;
isl_size n;
if (!pw || !v)
goto error;
if (isl_val_is_one(v)) {
isl_val_free(v);
return pw;
}
if (pw && DEFAULT_IS_ZERO && isl_val_is_zero(v)) {
PW *zero;
isl_space *space = FN(PW,get_space)(pw);
zero = FN(PW,ZERO)(space OPT_TYPE_ARG(pw->));
FN(PW,free)(pw);
isl_val_free(v);
return zero;
}
if (isl_val_is_neg(v))
pw = FN(PW,negate_type)(pw);
n = FN(PW,n_piece)(pw);
if (n < 0)
goto error;
for (i = 0; i < n; ++i) {
EL *el;
el = FN(PW,take_base_at)(pw, i);
el = FN(EL,scale_val)(el, isl_val_copy(v));
pw = FN(PW,restore_base_at)(pw, i, el);
}
isl_val_free(v);
return pw;
error:
isl_val_free(v);
FN(PW,free)(pw);
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x1ab765d
movq %r14, %rdi
callq 0x1b94e09
testl %eax, %eax
je 0x1ab760d
movq %r14, %rdi
callq 0x1b91ce4
jmp 0x1ab766f
movq %r14, %rdi
callq 0x1b93bf6
movl 0x10(%rbx), %r12d
testl %r12d, %r12d
js 0x1ab765d
je 0x1ab7603
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1ab6d54
movq %rax, %r15
movq %r14, %rdi
callq 0x1b91cbb
movq %r15, %rdi
movq %rax, %rsi
callq 0x1ab3f81
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x1ad0734
movq %rax, %rbx
incl %ebp
cmpl %ebp, %r12d
jne 0x1ab7622
jmp 0x1ab7603
movq %r14, %rdi
callq 0x1b91ce4
movq %rbx, %rdi
callq 0x1aadb11
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_pw_templ.c
|
isl_union_pw_aff_transform
|
static __isl_give UNION *FN(UNION,transform)(__isl_take UNION *u,
S(UNION,transform_control) *control)
{
S(UNION,transform_data) data = { control };
isl_space *space;
if (control->inplace) {
data.res = u;
} else {
if (control->space)
space = isl_space_copy(control->space);
else
space = FN(UNION,get_space)(u);
data.res = FN(UNION,alloc_same_size_on_space)(u, space);
}
if (FN(UNION,foreach_inplace)(u, &FN(UNION,transform_entry), &data) < 0)
data.res = FN(UNION,free)(data.res);
if (!control->inplace)
FN(UNION,free)(u);
return data.res;
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, (%rsi)
movq %rdi, %rax
jne 0x1ab963c
movq 0x8(%r14), %rdi
testq %rdi, %rdi
jne 0x1ab962c
testq %rbx, %rbx
je 0x1ab962a
movq 0x8(%rbx), %rdi
jmp 0x1ab962c
xorl %edi, %edi
callq 0x1b6fd4e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1ad09cc
movq %rax, 0x10(%rsp)
testq %rbx, %rbx
je 0x1ab9667
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x10(%rbx), %rsi
leaq 0x17393(%rip), %rdx # 0x1ad09ec
leaq 0x8(%rsp), %rcx
callq 0x1afdf5a
testl %eax, %eax
jns 0x1ab967a
movq 0x10(%rsp), %rdi
callq 0x1aaf7bd
movq $0x0, 0x10(%rsp)
cmpl $0x0, (%r14)
jne 0x1ab9688
movq %rbx, %rdi
callq 0x1aaf7bd
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/External/isl/isl_union_templ.c
|
isl_union_pw_aff_align_params
|
__isl_give UNION *FN(UNION,align_params)(__isl_take UNION *u,
__isl_take isl_space *model)
{
isl_space *space;
isl_bool equal_params;
isl_reordering *r;
space = FN(UNION,peek_space)(u);
equal_params = isl_space_has_equal_params(space, model);
if (equal_params < 0)
goto error;
if (equal_params) {
isl_space_free(model);
return u;
}
r = isl_parameter_alignment_reordering(space, model);
isl_space_free(model);
return FN(UNION,realign_domain)(u, r);
error:
isl_space_free(model);
FN(UNION,free)(u);
return NULL;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1ab9705
movq 0x8(%rbx), %r15
jmp 0x1ab9708
xorl %r15d, %r15d
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b70e21
testl %eax, %eax
js 0x1ab9723
je 0x1ab973e
movq %r14, %rdi
callq 0x1b6fe0a
jmp 0x1ab9735
movq %r14, %rdi
callq 0x1b6fe0a
movq %rbx, %rdi
callq 0x1aaf7bd
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b5251a
movq %rax, %r15
movq %r14, %rdi
callq 0x1b6fe0a
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1ab9764
|
/External/isl/isl_union_templ.c
|
isl_multi_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->space);
multi->space = space;
return multi;
error:
FN(MULTI(BASE),free)(multi);
isl_space_free(space);
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 0x1abc5a6
cmpq %r14, 0x8(%rbx)
je 0x1abc59a
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x1abc586
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1abc4ad
movq %rax, %rbx
testq %rbx, %rbx
je 0x1abc5a4
movq 0x8(%rbx), %rdi
callq 0x1b6fe0a
movq %r14, 0x8(%rbx)
jmp 0x1abc5b8
movq %r14, %rdi
callq 0x1b6fe0a
jmp 0x1abc5b8
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0x1ab8e88
movq %r14, %rdi
callq 0x1b6fe0a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/External/isl/isl_multi_templ.c
|
isl_multi_aff_range_factor_domain
|
__isl_give MULTI(BASE) *FN(MULTI(BASE),range_factor_domain)(
__isl_take MULTI(BASE) *multi)
{
isl_space *space;
isl_size total, keep;
total = FN(MULTI(BASE),dim)(multi, isl_dim_out);
if (total < 0)
return FN(MULTI(BASE),free)(multi);
if (!isl_space_range_is_wrapping(multi->space))
isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
"range is not a product",
return FN(MULTI(BASE),free)(multi));
space = FN(MULTI(BASE),get_space)(multi);
space = isl_space_range_factor_domain(space);
keep = isl_space_dim(space, isl_dim_out);
if (keep < 0)
multi = FN(MULTI(BASE),free)(multi);
multi = FN(MULTI(BASE),drop_dims)(multi,
isl_dim_out, keep, total - keep);
multi = FN(MULTI(BASE),reset_space)(multi, space);
return multi;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1abd0e8
movq 0x8(%rbx), %rdi
jmp 0x1abd0ea
xorl %edi, %edi
movl $0x3, %esi
callq 0x1b6fb4e
testl %eax, %eax
js 0x1abd1a3
movl %eax, %ebp
movq 0x8(%rbx), %rdi
callq 0x1b6fa2e
testl %eax, %eax
je 0x1abd116
testq %rbx, %rbx
je 0x1abd129
movq 0x8(%rbx), %rdi
jmp 0x1abd12b
testq %rbx, %rbx
je 0x1abd183
movq 0x8(%rbx), %rdi
callq 0x1b6f814
movq %rax, %rdi
jmp 0x1abd185
xorl %edi, %edi
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1b72543
movq %rax, %r14
movq %rax, %rdi
movl $0x3, %esi
callq 0x1b6fb4e
movl %eax, %r15d
testl %eax, %eax
jns 0x1abd159
movq %rbx, %rdi
callq 0x1ab8e88
xorl %ebx, %ebx
subl %r15d, %ebp
movq %rbx, %rdi
movl $0x3, %esi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x1abccdb
movq %rax, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1abca94
xorl %edi, %edi
leaq 0x344e776(%rip), %rdx # 0x4f0b902
leaq 0x344e6ee(%rip), %rcx # 0x4f0b881
movl $0x5, %esi
movl $0x2ce, %r8d # imm = 0x2CE
callq 0x1af81bb
movq %rbx, %rdi
callq 0x1ab8e88
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_multi_templ.c
|
isl_multi_aff_from_aff_mat
|
__isl_give isl_multi_aff *isl_multi_aff_from_aff_mat(
__isl_take isl_space *space, __isl_take isl_mat *mat)
{
isl_ctx *ctx;
isl_local_space *ls = NULL;
isl_multi_aff *ma = NULL;
isl_size n_row, n_col, n_out, total;
int i;
if (!space || !mat)
goto error;
ctx = isl_mat_get_ctx(mat);
n_row = isl_mat_rows(mat);
n_col = isl_mat_cols(mat);
n_out = isl_space_dim(space, isl_dim_out);
total = isl_space_dim(space, isl_dim_all);
if (n_row < 0 || n_col < 0 || n_out < 0 || total < 0)
goto error;
if (n_row < 1)
isl_die(ctx, isl_error_invalid,
"insufficient number of rows", goto error);
if (n_col < 1)
isl_die(ctx, isl_error_invalid,
"insufficient number of columns", goto error);
if (1 + n_out != n_row || 2 + total != n_row + n_col)
isl_die(ctx, isl_error_invalid,
"dimension mismatch", goto error);
ma = isl_multi_aff_zero(isl_space_copy(space));
space = isl_space_domain(space);
ls = isl_local_space_from_space(isl_space_copy(space));
for (i = 0; i < n_row - 1; ++i) {
isl_vec *v;
isl_aff *aff;
v = isl_vec_alloc(ctx, 1 + n_col);
if (!v)
goto error;
isl_int_set(v->el[0], mat->row[0][0]);
isl_seq_cpy(v->el + 1, mat->row[1 + i], n_col);
v = isl_vec_normalize(v);
aff = isl_aff_alloc_vec_validated(isl_local_space_copy(ls), v);
ma = isl_multi_aff_set_aff(ma, i, aff);
}
isl_space_free(space);
isl_local_space_free(ls);
isl_mat_free(mat);
return ma;
error:
isl_space_free(space);
isl_local_space_free(ls);
isl_mat_free(mat);
isl_multi_aff_free(ma);
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x1abf08e
movq %rbx, %rdi
callq 0x1b32714
movq %rax, %r13
movq %rbx, %rdi
callq 0x1b32cc4
movl %eax, %r15d
movq %rbx, %rdi
callq 0x1b32cd3
movl %eax, %r12d
movq %r14, %rdi
movl $0x3, %esi
callq 0x1b6fb4e
movl %eax, %ebp
movq %r14, %rdi
movl $0x5, %esi
callq 0x1b6fb4e
movl %r15d, %ecx
orl %r12d, %ecx
orl %ebp, %ecx
orl %eax, %ecx
js 0x1abf08e
testl %r15d, %r15d
jle 0x1abf031
testl %r12d, %r12d
jle 0x1abf06d
incl %ebp
cmpl %r15d, %ebp
jne 0x1abf04f
addl $0x2, %eax
leal (%r12,%r15), %ecx
cmpl %ecx, %eax
jne 0x1abf04f
movq %r12, 0x20(%rsp)
movq %r14, %rdi
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1abeadf
movq %rax, %r12
movq %r14, %rdi
callq 0x1b71eaa
movq %rax, %r14
movq %rax, %rdi
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1b0bddf
movq %r15, %rcx
movq %rax, %r15
cmpl $0x1, %ecx
je 0x1abf014
decl %ecx
movq %rcx, 0x30(%rsp)
movq 0x20(%rsp), %rax
incl %eax
movl %eax, 0x1c(%rsp)
xorl %ebp, %ebp
movq %r13, 0x28(%rsp)
movq %r13, %rdi
movl 0x1c(%rsp), %esi
callq 0x1b97dfc
movq %rax, %rcx
testq %rax, %rax
je 0x1abeffd
movq 0x18(%rcx), %rdx
movq 0x20(%rbx), %rax
movq (%rax), %rax
movq (%rax), %r13
testb $0x1, %r13b
jne 0x1abef73
movq %rcx, 0x8(%rsp)
testb $0x1, (%rdx)
je 0x1abef61
movq %rdx, 0x10(%rsp)
callq 0x1b9ade4
movq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq (%rdx), %rsi
movq %r13, %rdi
callq 0x1b9b015
movq 0x8(%rsp), %rcx
jmp 0x1abefa5
movq (%rdx), %rdi
testb $0x1, %dil
jne 0x1abef95
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
callq 0x1b9b0de
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movabsq $-0xffffffff, %rax # imm = 0xFFFFFFFF00000001
andq %rax, %r13
movq %r13, (%rdx)
movq 0x18(%rcx), %rdi
addq $0x8, %rdi
movq 0x20(%rbx), %rax
movq 0x8(%rax,%rbp,8), %rsi
movq 0x20(%rsp), %rdx
movq %rcx, %r13
callq 0x1b6b0a5
movq %r13, %rdi
callq 0x1b98867
movq %rax, 0x8(%rsp)
movq %r15, %rdi
callq 0x1b0bde6
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x1ab11f2
movq %r12, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x1abc627
movq %r13, %rcx
movq %rax, %r12
movq 0x28(%rsp), %r13
testq %rcx, %rcx
je 0x1abf094
incq %rbp
cmpq %rbp, 0x30(%rsp)
jne 0x1abef19
movq %r14, %rdi
callq 0x1b6fe0a
movq %r15, %rdi
callq 0x1b0bd46
movq %rbx, %rdi
callq 0x1b32a2f
jmp 0x1abf0b7
leaq 0x344ca4c(%rip), %rdx # 0x4f0ba84
leaq 0x344c1f2(%rip), %rcx # 0x4f0b231
movq %r13, %rdi
movl $0x5, %esi
movl $0xfbf, %r8d # imm = 0xFBF
jmp 0x1abf089
leaq 0x344ca69(%rip), %rdx # 0x4f0babf
leaq 0x344c1d4(%rip), %rcx # 0x4f0b231
movq %r13, %rdi
movl $0x5, %esi
movl $0xfc5, %r8d # imm = 0xFC5
jmp 0x1abf089
leaq 0x344ca2c(%rip), %rdx # 0x4f0baa0
leaq 0x344c1b6(%rip), %rcx # 0x4f0b231
movq %r13, %rdi
movl $0x5, %esi
movl $0xfc2, %r8d # imm = 0xFC2
callq 0x1af81bb
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x1b6fe0a
movq %r15, %rdi
callq 0x1b0bd46
movq %rbx, %rdi
callq 0x1b32a2f
movq %r12, %rdi
callq 0x1ab8e88
xorl %r12d, %r12d
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_aff.c
|
isl_pw_multi_aff_cow
|
__isl_give PW *FN(PW,cow)(__isl_take PW *pw)
{
if (!pw)
return NULL;
if (pw->ref == 1)
return pw;
pw->ref--;
return FN(PW,dup)(pw);
}
|
testq %rdi, %rdi
je 0x1abfc53
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1abfc55
decl %eax
movl %eax, (%rdi)
jmp 0x1abfbbc
xorl %edi, %edi
movq %rdi, %rax
retq
|
/External/isl/isl_pw_templ.c
|
isl_pw_multi_aff_restore_space
|
static __isl_give PW *FN(PW,restore_space)(__isl_take PW *pw,
__isl_take isl_space *space)
{
if (!pw || !space)
goto error;
if (pw->dim == space) {
isl_space_free(space);
return pw;
}
pw = FN(PW,cow)(pw);
if (!pw)
goto error;
isl_space_free(pw->dim);
pw->dim = space;
return pw;
error:
FN(PW,free)(pw);
isl_space_free(space);
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 0x1ac0cc9
cmpq %r14, 0x8(%rbx)
je 0x1ac0cbd
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x1ac0ca9
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1abfbbc
movq %rax, %rbx
testq %rbx, %rbx
je 0x1ac0cc7
movq 0x8(%rbx), %rdi
callq 0x1b6fe0a
movq %r14, 0x8(%rbx)
jmp 0x1ac0cdb
movq %r14, %rdi
callq 0x1b6fe0a
jmp 0x1ac0cdb
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0x1aae967
movq %r14, %rdi
callq 0x1b6fe0a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/External/isl/isl_pw_templ.c
|
isl_pw_multi_aff_scale_val
|
__isl_give PW *FN(PW,scale_val)(__isl_take PW *pw, __isl_take isl_val *v)
{
int i;
isl_size n;
if (!pw || !v)
goto error;
if (isl_val_is_one(v)) {
isl_val_free(v);
return pw;
}
if (pw && DEFAULT_IS_ZERO && isl_val_is_zero(v)) {
PW *zero;
isl_space *space = FN(PW,get_space)(pw);
zero = FN(PW,ZERO)(space OPT_TYPE_ARG(pw->));
FN(PW,free)(pw);
isl_val_free(v);
return zero;
}
if (isl_val_is_neg(v))
pw = FN(PW,negate_type)(pw);
n = FN(PW,n_piece)(pw);
if (n < 0)
goto error;
for (i = 0; i < n; ++i) {
EL *el;
el = FN(PW,take_base_at)(pw, i);
el = FN(EL,scale_val)(el, isl_val_copy(v));
pw = FN(PW,restore_base_at)(pw, i, el);
}
isl_val_free(v);
return pw;
error:
isl_val_free(v);
FN(PW,free)(pw);
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x1ac15d9
movq %r14, %rdi
callq 0x1b94e09
testl %eax, %eax
je 0x1ac157f
movq %r14, %rdi
callq 0x1b91ce4
jmp 0x1ac15eb
movq %r14, %rdi
callq 0x1b93bf6
movl 0x10(%rbx), %r13d
testl %r13d, %r13d
js 0x1ac15d9
je 0x1ac1575
xorl %ebp, %ebp
leaq -0xd61a(%rip), %r15 # 0x1ab3f81
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1ac0ce6
movq %rax, %r12
movq %r14, %rdi
callq 0x1b91cbb
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1abd94e
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x1ad14aa
movq %rax, %rbx
incl %ebp
cmpl %ebp, %r13d
jne 0x1ac159b
jmp 0x1ac1575
movq %r14, %rdi
callq 0x1b91ce4
movq %rbx, %rdi
callq 0x1aae967
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_pw_templ.c
|
isl_pw_multi_aff_add_disjoint
|
__isl_give PW *FN(PW,add_disjoint)(__isl_take PW *pw1, __isl_take PW *pw2)
{
int i;
isl_ctx *ctx;
if (FN(PW,align_params_bin)(&pw1, &pw2) < 0)
goto error;
if (pw1->size < pw1->n + pw2->n && pw1->n < pw2->n)
return FN(PW,add_disjoint)(pw2, pw1);
ctx = isl_space_get_ctx(pw1->dim);
if (!OPT_EQUAL_TYPES(pw1->, pw2->))
isl_die(ctx, isl_error_invalid,
"fold types don't match", goto error);
if (FN(PW,check_equal_space)(pw1, pw2) < 0)
goto error;
if (FN(PW,IS_ZERO)(pw1)) {
FN(PW,free)(pw1);
return pw2;
}
if (FN(PW,IS_ZERO)(pw2)) {
FN(PW,free)(pw2);
return pw1;
}
pw1 = FN(PW,grow)(pw1, pw2->n);
if (!pw1)
goto error;
for (i = 0; i < pw2->n; ++i)
pw1 = FN(PW,add_piece)(pw1,
isl_set_copy(pw2->p[i].set),
FN(EL,copy)(pw2->p[i].FIELD));
FN(PW,free)(pw2);
return pw1;
error:
FN(PW,free)(pw1);
FN(PW,free)(pw2);
return NULL;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
leaq 0x8(%rsp), %r12
movq %rbx, (%rsp)
movq %r14, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1ac1c67
testl %eax, %eax
js 0x1ac1c41
movq (%rsp), %r14
movl 0x10(%r14), %eax
movq 0x8(%rsp), %rbx
movl 0x10(%rbx), %ecx
cmpl %ecx, %eax
jge 0x1ac1aab
addl %eax, %ecx
movslq %ecx, %rax
cmpq %rax, 0x18(%r14)
jb 0x1ac1a70
movq 0x8(%r14), %rdi
callq 0x1b6f814
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1abff97
testl %eax, %eax
js 0x1ac1c41
testq %r14, %r14
je 0x1ac1ae0
xorl %edi, %edi
cmpl $0x0, 0x10(%r14)
sete %dil
callq 0x1af811d
testl %eax, %eax
je 0x1ac1aed
movq %r14, %rdi
callq 0x1aae967
jmp 0x1ac1c56
testq %rbx, %rbx
je 0x1ac1c34
xorl %edi, %edi
cmpl $0x0, 0x10(%rbx)
sete %dil
callq 0x1af811d
testl %eax, %eax
jne 0x1ac1c34
testq %r14, %r14
je 0x1ac1bde
movslq 0x10(%rbx), %r12
movslq 0x10(%r14), %rax
addq %r12, %rax
cmpq %rax, 0x18(%r14)
jae 0x1ac1be1
movq 0x8(%r14), %rdi
callq 0x1b6f814
movslq 0x10(%r14), %r15
addq %r12, %r15
cmpl $0x1, (%r14)
jne 0x1ac1b68
movq %r15, %rdx
shlq $0x4, %rdx
addq $0x20, %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1af82fa
testq %rax, %rax
je 0x1ac1bd6
movslq %r15d, %rcx
movq %rcx, 0x18(%rax)
movq %rax, %r14
jmp 0x1ac1be1
movq 0x8(%r14), %rdi
callq 0x1b6fd4e
movq %rax, %rdi
movl %r15d, %esi
callq 0x1abf908
testq %rax, %rax
je 0x1ac1bd6
movq %rax, %r15
cmpl $0x0, 0x10(%r14)
jle 0x1ac1bc9
leaq 0x28(%r14), %r12
xorl %r13d, %r13d
movq -0x8(%r12), %rdi
callq 0x1b10b72
movq (%r12), %rdx
testq %rdx, %rdx
je 0x1ac1ba9
incl (%rdx)
jmp 0x1ac1bab
xorl %edx, %edx
movq %r15, %rdi
movq %rax, %rsi
callq 0x1abf98b
movq %rax, %r15
incq %r13
movslq 0x10(%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x1ac1b92
movq %r14, %rdi
callq 0x1aae967
movq %r15, %r14
jmp 0x1ac1be1
movq %r14, %rdi
callq 0x1aae967
xorl %r14d, %r14d
movq %r14, (%rsp)
testq %r14, %r14
je 0x1ac1c41
movq (%rsp), %r14
cmpl $0x0, 0x10(%rbx)
jle 0x1ac1c30
leaq 0x28(%rbx), %r15
xorl %r12d, %r12d
movq -0x8(%r15), %rdi
callq 0x1b10b72
movq (%r15), %rdx
testq %rdx, %rdx
je 0x1ac1c10
incl (%rdx)
jmp 0x1ac1c12
xorl %edx, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1abf98b
movq %rax, %r14
incq %r12
movslq 0x10(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x1ac1bfb
movq %r14, (%rsp)
movq %rbx, %rdi
callq 0x1aae967
movq %r14, %rbx
jmp 0x1ac1c56
movq (%rsp), %rdi
callq 0x1aae967
movq 0x8(%rsp), %rdi
callq 0x1aae967
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/External/isl/isl_pw_add_disjoint_templ.c
|
isl_pw_multi_aff_from_range
|
__isl_give TYPE *FN(TYPE,from_range)(__isl_take TYPE *obj)
{
isl_space *space;
if (!obj)
return NULL;
if (!isl_space_is_set(FN(TYPE,peek_space)(obj)))
isl_die(FN(TYPE,get_ctx)(obj), isl_error_invalid,
"not living in a set space",
return FN(TYPE,free)(obj));
space = FN(TYPE,get_space)(obj);
space = isl_space_from_range(space);
obj = FN(TYPE,reset_space)(obj, space);
return obj;
}
|
pushq %rbx
testq %rdi, %rdi
je 0x1ac223c
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1b6f88d
movq 0x8(%rbx), %rdi
testl %eax, %eax
je 0x1ac220e
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1b72b9b
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x1ac0b11
callq 0x1b6f814
leaq 0x34494ba(%rip), %rdx # 0x4f0b6d4
leaq 0x34494cd(%rip), %rcx # 0x4f0b6ee
movq %rax, %rdi
movl $0x5, %esi
movl $0x16, %r8d
callq 0x1af81bb
movq %rbx, %rdi
callq 0x1aae967
xorl %eax, %eax
popq %rbx
retq
|
/External/isl/isl_from_range_templ.c
|
isl_union_pw_multi_aff_extract_part
|
static isl_stat FN(UNION,extract_part)(void **entry, void *user)
{
PART **part_p = user;
PART *part = *entry;
if (*part_p)
isl_die(FN(PART,get_ctx)(part), isl_error_internal,
"more than one part", return isl_stat_error);
*part_p = FN(PART,copy)(part);
if (!*part_p)
return isl_stat_error;
return isl_stat_ok;
}
|
movq (%rdi), %rcx
cmpq $0x0, (%rsi)
je 0x1ac2e04
pushq %rax
testq %rcx, %rcx
je 0x1ac2e0f
movq 0x8(%rcx), %rdi
callq 0x1b6f814
movq %rax, %rdi
jmp 0x1ac2e11
xorl %eax, %eax
testq %rcx, %rcx
je 0x1ac2e39
incl (%rcx)
jmp 0x1ac2e3b
xorl %edi, %edi
leaq 0x34492b6(%rip), %rdx # 0x4f0c0ce
leaq 0x3448d28(%rip), %rcx # 0x4f0bb47
movl $0x4, %esi
movl $0x207, %r8d # imm = 0x207
callq 0x1af81bb
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
retq
xorl %ecx, %ecx
movq %rcx, (%rsi)
cmpq $0x1, %rcx
sbbl %eax, %eax
retq
|
/External/isl/isl_union_multi.c
|
isl_union_pw_multi_aff_from_union_map
|
__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_union_map(
__isl_take isl_union_map *umap)
{
isl_space *space;
isl_union_pw_multi_aff *upma;
space = isl_union_map_get_space(umap);
upma = isl_union_pw_multi_aff_empty(space);
if (isl_union_map_foreach_map(umap, &pw_multi_aff_from_map, &upma) < 0)
upma = isl_union_pw_multi_aff_free(upma);
isl_union_map_free(umap);
return upma;
}
|
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x1b8cc91
movq %rax, %rdi
movl $0x10, %esi
callq 0x1ac2ed1
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x32(%rip), %rsi # 0x1ac584f
movq %rbx, %rdi
callq 0x1b8cd46
testl %eax, %eax
jns 0x1ac583c
movq 0x8(%rsp), %rdi
callq 0x1ab0607
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x1b8cd9e
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
retq
|
/External/isl/isl_aff.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 *space = isl_multi_aff_get_domain_space(maff);
*ls = isl_local_space_from_space(space);
if (!*ls)
return isl_multi_aff_free(maff);
}
return maff;
}
maff = isl_multi_aff_align_divs(maff);
aff = isl_multi_aff_peek_at(maff, 0);
n_div = isl_aff_dim(aff, isl_dim_div);
if (n_div < 0)
return isl_multi_aff_free(maff);
space = isl_multi_aff_get_space(maff);
space = isl_space_lift(isl_space_domain(space), n_div);
space = isl_space_extend_domain_with_range(space,
isl_multi_aff_get_space(maff));
maff = isl_multi_aff_restore_space(maff, space);
if (ls) {
aff = isl_multi_aff_peek_at(maff, 0);
*ls = isl_aff_get_domain_local_space(aff);
if (!*ls)
return isl_multi_aff_free(maff);
}
for (i = 0; i < n; ++i) {
aff = isl_multi_aff_take_at(maff, i);
aff = isl_aff_lift(aff);
maff = isl_multi_aff_restore_at(maff, i, aff);
}
return maff;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1ac61f2
movq $0x0, (%r14)
testq %rbx, %rbx
je 0x1ac61fd
movl 0x10(%rbx), %r12d
jmp 0x1ac6203
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
testl %r12d, %r12d
js 0x1ac6351
je 0x1ac624f
movq %rbx, %rdi
callq 0x1ab8bce
movq %rax, %rbx
xorl %r15d, %r15d
movq %rax, %rdi
movl $0x3, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x1abce2b
testl %eax, %eax
js 0x1ac6238
movq 0x18(%rbx), %r15
testq %r15, %r15
je 0x1ac6279
movq 0x8(%r15), %rdi
movl $0x4, %esi
callq 0x1b0bf7d
movl %eax, %ebp
jmp 0x1ac627e
testq %r14, %r14
je 0x1ac635b
movq %rbx, %rdi
callq 0x1abc42c
movq %rax, %rdi
callq 0x1b0bddf
movq %rax, (%r14)
testq %rax, %rax
jne 0x1ac635b
jmp 0x1ac6351
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testl %ebp, %ebp
js 0x1ac6351
testq %rbx, %rbx
je 0x1ac6291
movq 0x8(%rbx), %rdi
jmp 0x1ac6293
xorl %edi, %edi
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1b71eaa
movq %rax, %rdi
movl %ebp, %esi
callq 0x1b73960
movq %rax, %r15
testq %rbx, %rbx
je 0x1ac62b8
movq 0x8(%rbx), %rdi
jmp 0x1ac62ba
xorl %edi, %edi
callq 0x1b6fd4e
movq %r15, %rdi
movq %rax, %rsi
callq 0x1b73f08
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1abc550
movq %rax, %rbx
testq %r14, %r14
je 0x1ac6316
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x1abce2b
testl %eax, %eax
js 0x1ac62fc
movq 0x18(%rbx), %r15
testq %r15, %r15
je 0x1ac6307
movq 0x8(%r15), %rdi
jmp 0x1ac6309
xorl %edi, %edi
callq 0x1b0bde6
movq %rax, (%r14)
testq %rax, %rax
je 0x1ac6351
cmpl $0x2, %r12d
movl $0x1, %r14d
cmovgel %r12d, %r14d
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1abc964
movq %rax, %rdi
callq 0x1ac618f
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x1abc9ba
movq %rax, %rbx
incl %ebp
cmpl %ebp, %r14d
jne 0x1ac6326
jmp 0x1ac635b
movq %rbx, %rdi
callq 0x1ab8e88
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_aff.c
|
isl_map_intersect_multi_pw_aff_explicit_domain
|
__isl_give isl_map *isl_map_intersect_multi_pw_aff_explicit_domain(
__isl_take isl_map *map, __isl_keep isl_multi_pw_aff *mpa)
{
isl_set *dom;
if (!isl_multi_pw_aff_has_explicit_domain(mpa))
return map;
dom = isl_multi_pw_aff_domain(isl_multi_pw_aff_copy(mpa));
map = isl_map_intersect_domain(map, dom);
return map;
}
|
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1aca269
cmpl $0x0, 0x10(%rsi)
je 0x1aca26e
movq %rbx, %rax
popq %rbx
retq
testq %rsi, %rsi
je 0x1aca277
incl (%rsi)
jmp 0x1aca279
xorl %esi, %esi
movq %rsi, %rdi
callq 0x1ac8a29
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x1b1761a
|
/External/isl/isl_aff.c
|
isl_multi_pw_aff_is_cst
|
isl_bool isl_multi_pw_aff_is_cst(__isl_keep isl_multi_pw_aff *mpa)
{
return isl_multi_pw_aff_every(mpa, &isl_pw_aff_is_cst);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x1aca2ab
movl 0x10(%r14), %eax
testl %eax, %eax
js 0x1aca2d9
movl $0x1, %ebx
je 0x1aca2d9
movl %eax, %r15d
xorl %r12d, %r12d
movq 0x20(%r14,%r12,8), %rdi
callq 0x1abb527
testl %eax, %eax
cmovlel %eax, %ebp
jle 0x1aca2d7
incq %r12
cmpq %r12, %r15
jne 0x1aca2bc
jmp 0x1aca2d9
movl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_aff.c
|
isl_union_pw_multi_aff_scale_multi_val
|
__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_scale_multi_val(
__isl_take isl_union_pw_multi_aff *upma, __isl_take isl_multi_val *mv)
{
struct isl_union_pw_multi_aff_transform_control control = {
.fn = &union_pw_multi_aff_scale_multi_val_entry,
.fn_user = mv,
};
upma = isl_union_pw_multi_aff_align_params(upma,
isl_multi_val_get_space(mv));
mv = isl_multi_val_align_params(mv,
isl_union_pw_multi_aff_get_space(upma));
if (!upma || !mv)
goto error;
return isl_union_pw_multi_aff_transform(upma, &control);
isl_multi_val_free(mv);
return upma;
error:
isl_multi_val_free(mv);
isl_union_pw_multi_aff_free(upma);
return NULL;
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x70(%rip), %rax # 0x1aca5ec
movq %rax, 0x28(%rsp)
movq %rsi, 0x30(%rsp)
movq %rsi, %rdi
callq 0x1b95c45
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1ac33cf
movq %rax, %rbx
testq %rax, %rax
je 0x1aca5a7
movq 0x8(%rbx), %rdi
jmp 0x1aca5a9
xorl %edi, %edi
callq 0x1b6fd4e
movq %r14, %rdi
movq %rax, %rsi
callq 0x1b95f27
testq %rbx, %rbx
je 0x1aca5d2
testq %rax, %rax
je 0x1aca5d2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ac32e2
jmp 0x1aca5e4
movq %rax, %rdi
callq 0x1b95d6a
movq %rbx, %rdi
callq 0x1ab0607
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
|
/External/isl/isl_aff.c
|
isl_multi_pw_aff_from_pw_multi_aff
|
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_multi_aff(
__isl_take isl_pw_multi_aff *pma)
{
int i;
isl_size n;
isl_space *space;
isl_multi_pw_aff *mpa;
n = isl_pw_multi_aff_dim(pma, isl_dim_out);
if (n < 0)
pma = isl_pw_multi_aff_free(pma);
space = isl_pw_multi_aff_get_space(pma);
mpa = isl_multi_pw_aff_alloc(space);
for (i = 0; i < n; ++i) {
isl_pw_aff *pa;
pa = isl_pw_multi_aff_get_pw_aff(pma, i);
mpa = isl_multi_pw_aff_set_pw_aff(mpa, i, pa);
}
if (isl_multi_pw_aff_has_explicit_domain(mpa)) {
isl_set *dom;
dom = isl_pw_multi_aff_domain(isl_pw_multi_aff_copy(pma));
mpa = isl_multi_pw_aff_intersect_domain(mpa, dom);
}
isl_pw_multi_aff_free(pma);
return mpa;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1aca881
movq 0x8(%rbx), %rdi
jmp 0x1aca883
xorl %edi, %edi
movl $0x3, %esi
callq 0x1b6fb4e
movl %eax, %ebp
testl %eax, %eax
jns 0x1aca89d
movq %rbx, %rdi
callq 0x1aae967
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x1aca8a8
movq 0x8(%rbx), %rdi
jmp 0x1aca8aa
xorl %edi, %edi
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1ac6e66
movq %rax, %r14
testl %ebp, %ebp
jle 0x1aca8e5
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1ac6367
movq %r14, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x1ac7126
movq %rax, %r14
incl %r15d
cmpl %r15d, %ebp
jne 0x1aca8c1
testq %r14, %r14
je 0x1aca912
cmpl $0x0, 0x10(%r14)
jne 0x1aca912
testq %rbx, %rbx
je 0x1aca8fd
incl (%rbx)
movq %rbx, %rdi
jmp 0x1aca8ff
xorl %edi, %edi
callq 0x1ac02e4
movq %r14, %rdi
movq %rax, %rsi
callq 0x1ac9447
movq %rax, %r14
movq %rbx, %rdi
callq 0x1aae967
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_aff.c
|
isl_union_pw_aff_mod_val
|
__isl_give isl_union_pw_aff *isl_union_pw_aff_mod_val(
__isl_take isl_union_pw_aff *upa, __isl_take isl_val *m)
{
isl_union_pw_aff *res;
if (!upa || !m)
goto error;
if (!isl_val_is_int(m))
isl_die(isl_val_get_ctx(m), isl_error_invalid,
"expecting integer modulo", goto error);
if (!isl_val_is_pos(m))
isl_die(isl_val_get_ctx(m), isl_error_invalid,
"expecting positive modulo", goto error);
res = isl_union_pw_aff_copy(upa);
upa = isl_union_pw_aff_scale_down_val(upa, isl_val_copy(m));
upa = isl_union_pw_aff_floor(upa);
upa = isl_union_pw_aff_scale_val(upa, m);
res = isl_union_pw_aff_sub(res, upa);
return res;
error:
isl_val_free(m);
isl_union_pw_aff_free(upa);
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 0x1acbec6
movq %r14, %rdi
callq 0x1b92e52
movq %r14, %rdi
testl %eax, %eax
je 0x1acbe7a
callq 0x1b95553
testl %eax, %eax
je 0x1acbe9d
incl (%rbx)
movq %r14, %rdi
callq 0x1b91cbb
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1aba0df
leaq -0x5e(%rip), %rsi # 0x1acbdee
movq %rax, %rdi
xorl %edx, %edx
callq 0x1aba066
movq %rax, %rdi
movq %r14, %rsi
callq 0x1ab9fc7
leaq -0x17c0e(%rip), %rdx # 0x1ab425a
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ab9944
callq 0x1b925e5
leaq 0x343f547(%rip), %rdx # 0x4f0b3cd
leaq 0x343f3a4(%rip), %rcx # 0x4f0b231
movq %rax, %rdi
movl $0x5, %esi
movl $0x1fd2, %r8d # imm = 0x1FD2
jmp 0x1acbec1
movq %r14, %rdi
callq 0x1b925e5
leaq 0x343fd80(%rip), %rdx # 0x4f0bc2c
leaq 0x343f37e(%rip), %rcx # 0x4f0b231
movq %rax, %rdi
movl $0x5, %esi
movl $0x1fd5, %r8d # imm = 0x1FD5
callq 0x1af81bb
movq %r14, %rdi
callq 0x1b91ce4
movq %rbx, %rdi
callq 0x1aaf7bd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/External/isl/isl_aff.c
|
pw_aff_val_on_domain
|
static isl_stat pw_aff_val_on_domain(__isl_take isl_set *domain, void *user)
{
struct isl_union_pw_aff_val_on_domain_data *data = user;
isl_pw_aff *pa;
isl_val *v;
v = isl_val_copy(data->v);
pa = isl_pw_aff_val_on_domain(domain, v);
data->res = isl_union_pw_aff_add_pw_aff(data->res, pa);
return data->res ? isl_stat_ok : isl_stat_error;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x1b91cbb
movq %r14, %rdi
movq %rax, %rsi
callq 0x1acb8c1
movq 0x8(%rbx), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x1ab945d
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_aff.c
|
isl_multi_union_pw_aff_from_union_pw_aff_list
|
__isl_give MULTI(BASE) *FN(FN(MULTI(BASE),from),LIST(BASE))(
__isl_take isl_space *space, __isl_take LIST(EL) *list)
{
int i;
isl_size n, dim;
isl_ctx *ctx;
MULTI(BASE) *multi;
dim = isl_space_dim(space, isl_dim_out);
n = FN(FN(LIST(EL),n),BASE)(list);
if (dim < 0 || n < 0)
goto error;
ctx = isl_space_get_ctx(space);
if (n != dim)
isl_die(ctx, isl_error_invalid,
"invalid number of elements in list", goto error);
for (i = 0; i < n; ++i) {
EL *el = FN(LIST(EL),peek)(list, i);
space = isl_space_align_params(space, FN(EL,get_space)(el));
}
multi = FN(MULTI(BASE),alloc)(isl_space_copy(space));
for (i = 0; i < n; ++i) {
EL *el = FN(FN(LIST(EL),get),BASE)(list, i);
el = FN(EL,align_params)(el, isl_space_copy(space));
multi = FN(MULTI(BASE),restore_check_space)(multi, i, el);
}
isl_space_free(space);
FN(LIST(EL),free)(list);
return multi;
error:
isl_space_free(space);
FN(LIST(EL),free)(list);
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x3, %esi
callq 0x1b6fb4e
movl %eax, %ebp
testq %rbx, %rbx
je 0x1acd12e
movl 0x10(%rbx), %r12d
jmp 0x1acd134
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movl %ebp, %eax
orl %r12d, %eax
js 0x1acd22c
movq %r14, %rdi
callq 0x1b6f814
cmpl %ebp, %r12d
jne 0x1acd20b
movl %r12d, %ebp
testl %r12d, %r12d
jle 0x1acd19b
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1aafab8
testl %eax, %eax
js 0x1acd171
movq 0x20(%rbx,%r15,8), %rax
jmp 0x1acd173
xorl %eax, %eax
testq %rax, %rax
je 0x1acd17e
movq 0x8(%rax), %rdi
jmp 0x1acd180
xorl %edi, %edi
callq 0x1b6fd4e
movq %r14, %rdi
movq %rax, %rsi
callq 0x1b73e9a
movq %rax, %r14
incq %r15
cmpq %r15, %rbp
jne 0x1acd15b
movq %r14, %rdi
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1acc681
movq %rax, %r15
testl %r12d, %r12d
jle 0x1acd22f
xorl %r12d, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1aafab8
testl %eax, %eax
js 0x1acd1cc
movq 0x20(%rbx,%r12,8), %r13
jmp 0x1acd1cf
xorl %r13d, %r13d
testq %r13, %r13
je 0x1acd1da
incl (%r13)
jmp 0x1acd1dd
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x1b6fd4e
movq %r13, %rdi
movq %rax, %rsi
callq 0x1ab96ef
movq %r15, %rdi
movl %r12d, %esi
movq %rax, %rdx
callq 0x1accbb9
movq %rax, %r15
incq %r12
cmpq %r12, %rbp
jne 0x1acd1b6
jmp 0x1acd22f
leaq 0x343e6cd(%rip), %rdx # 0x4f0b8df
leaq 0x343e668(%rip), %rcx # 0x4f0b881
movq %rax, %rdi
movl $0x5, %esi
movl $0x225, %r8d # imm = 0x225
callq 0x1af81bb
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x1b6fe0a
movq %rbx, %rdi
callq 0x1aaf815
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_multi_templ.c
|
isl_multi_union_pw_aff_apply_aligned_union_set
|
__isl_give MULTI(BASE) *FN(FN(MULTI(BASE),apply_aligned),APPLY_DOMBASE)(
__isl_take MULTI(BASE) *multi, __isl_take APPLY_DOM *set,
__isl_give EL *(*fn)(EL *el, __isl_take APPLY_DOM *set))
{
isl_size n;
int i;
n = FN(MULTI(BASE),size)(multi);
if (n < 0 || !set)
goto error;
for (i = 0; i < n; ++i) {
EL *el;
el = FN(MULTI(BASE),take_at)(multi, i);
el = fn(el, FN(APPLY_DOM,copy)(set));
multi = FN(MULTI(BASE),restore_at)(multi, i, el);
}
FN(APPLY_DOM,free)(set);
return multi;
error:
FN(APPLY_DOM,free)(set);
FN(MULTI(BASE),free)(multi);
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1acdd9e
movl 0x10(%rbx), %r13d
jmp 0x1acdda4
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
testl %r13d, %r13d
sets %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x1acddfa
testl %r13d, %r13d
jle 0x1acddf0
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1acced2
movq %rax, %r12
movq %r14, %rdi
callq 0x1b8d04d
movq %r12, %rdi
movq %rax, %rsi
callq *%r15
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x1accf28
movq %rax, %rbx
incl %ebp
cmpl %ebp, %r13d
jne 0x1acddbb
movq %r14, %rdi
callq 0x1b8cd9e
jmp 0x1acde0c
movq %r14, %rdi
callq 0x1b8cd9e
movq %rbx, %rdi
callq 0x1acc7f6
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_multi_apply_templ.c
|
isl_multi_union_pw_aff_multi_val_on_domain
|
__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_multi_val_on_domain(
__isl_take isl_union_set *domain, __isl_take isl_multi_val *mv)
{
isl_bool equal_params;
if (!domain || !mv)
goto error;
equal_params = isl_space_has_equal_params(domain->dim, mv->space);
if (equal_params < 0)
goto error;
if (equal_params)
return isl_multi_union_pw_aff_multi_val_on_domain_aligned(
domain, mv);
domain = isl_union_set_align_params(domain,
isl_multi_val_get_space(mv));
mv = isl_multi_val_align_params(mv, isl_union_set_get_space(domain));
return isl_multi_union_pw_aff_multi_val_on_domain_aligned(domain, mv);
error:
isl_union_set_free(domain);
isl_multi_val_free(mv);
return NULL;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x1acf259
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x1b70e21
testl %eax, %eax
js 0x1acf259
je 0x1acf273
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x1acf2a2
movq %r14, %rdi
callq 0x1b8d068
movq %rbx, %rdi
callq 0x1b95d6a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x1b95c45
movq %r14, %rdi
movq %rax, %rsi
callq 0x1b8cf65
movq %rax, %r14
movq %rax, %rdi
callq 0x1b8ccba
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1b95f27
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1acf2ae
|
/External/isl/isl_aff.c
|
isl_pw_multi_aff_union_opt_cmp_pair
|
static isl_stat FN(PW,union_opt_cmp_pair)(S(PW,union_opt_cmp_data) *data_i,
int i, S(PW,union_opt_cmp_data) *data_j, int j,
__isl_give isl_set *(*cmp)(__isl_take EL *el1, __isl_take EL *el2))
{
isl_set *better;
EL *el_i, *el_j;
el_i = FN(PW,peek_base_at)(data_i->pw, i);
el_j = FN(PW,peek_base_at)(data_j->pw, j);
better = FN(PW,better)(el_j, el_i, cmp);
return FN(PW,union_opt_cmp_split)(data_i, i, data_j, j, better);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
movq (%rdi), %r13
movq %r13, %rdi
callq 0x1abfca3
testl %eax, %eax
js 0x1ad1e8b
movslq %ebp, %rax
shlq $0x4, %rax
movq 0x28(%r13,%rax), %r13
jmp 0x1ad1e8e
xorl %r13d, %r13d
movq (%r14), %r15
movq %r15, %rdi
movl %ebx, %esi
callq 0x1abfca3
testl %eax, %eax
js 0x1ad1ead
movslq %ebx, %rax
shlq $0x4, %rax
movq 0x28(%r15,%rax), %rdi
jmp 0x1ad1eaf
xorl %edi, %edi
testq %rdi, %rdi
je 0x1ad1eb8
incl (%rdi)
jmp 0x1ad1eba
xorl %edi, %edi
testq %r13, %r13
je 0x1ad1ec5
incl (%r13)
jmp 0x1ad1ec8
xorl %r13d, %r13d
movq %r13, %rsi
callq *(%rsp)
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ad1eee
|
/External/isl/isl_pw_union_opt.c
|
pw_multi_aff_from_map_check_div
|
static __isl_give isl_pw_multi_aff *pw_multi_aff_from_map_check_div(
__isl_take isl_map *map)
{
int d;
isl_size dim;
int i, j, n;
int offset;
isl_size total;
isl_int sum;
isl_basic_map *hull;
hull = isl_map_unshifted_simple_hull(isl_map_copy(map));
dim = isl_map_dim(map, isl_dim_out);
total = isl_basic_map_dim(hull, isl_dim_all);
if (dim < 0 || total < 0)
goto error;
isl_int_init(sum);
offset = isl_basic_map_offset(hull, isl_dim_out);
n = hull->n_ineq;
for (d = 0; d < dim; ++d) {
for (i = 0; i < n; ++i) {
if (!is_potential_div_constraint(hull->ineq[i],
offset, d, 1 + total))
continue;
for (j = i + 1; j < n; ++j) {
if (!isl_seq_is_neg(hull->ineq[i] + 1,
hull->ineq[j] + 1, total))
continue;
isl_int_add(sum, hull->ineq[i][0],
hull->ineq[j][0]);
if (isl_int_abs_lt(sum,
hull->ineq[i][offset + d]))
break;
}
if (j >= n)
continue;
isl_int_clear(sum);
if (isl_int_is_pos(hull->ineq[j][offset + d]))
j = i;
return pw_multi_aff_from_map_div(map, hull, d, j);
}
}
isl_int_clear(sum);
isl_basic_map_free(hull);
return pw_multi_aff_from_map_base(map);
error:
isl_map_free(map);
isl_basic_map_free(hull);
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
callq 0x1b10b80
movq %rax, %rdi
callq 0x1af31ec
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1b0f278
movl %eax, %r14d
movq %r15, %rdi
movl $0x5, %esi
callq 0x1b0f1c0
movl %r14d, %ecx
movl %eax, 0x4(%rsp)
orl %eax, %ecx
jns 0x1ad21d2
movq %rbx, %rdi
callq 0x1b0fdb2
movq %r15, %rdi
callq 0x1b0fb02
jmp 0x1ad25bb
movq %rbx, 0x10(%rsp)
movq $0x1, 0x30(%rsp)
movq %r15, %rdi
movl $0x3, %esi
callq 0x1b0f370
testl %r14d, %r14d
jle 0x1ad24f2
movslq 0x20(%r15), %rcx
movl %ecx, %r13d
cltq
movq %rax, 0x20(%rsp)
leaq 0x3440b51(%rip), %rax # 0x4f12d5c
movb (%rax), %al
movb %al, 0x2(%rsp)
leaq 0x3440b45(%rip), %rax # 0x4f12d5d
movb (%rax), %al
movb %al, 0x3(%rsp)
movl %r14d, %eax
movq %rax, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
decq %rcx
movq %rcx, 0x40(%rsp)
movq $0x0, 0x8(%rsp)
movq %r15, 0x28(%rsp)
movq %r13, 0x18(%rsp)
cmpl $0x0, 0x50(%rsp)
jle 0x1ad24da
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
leaq (%rax,%rcx), %rbp
movl 0x4(%rsp), %eax
subl %ebp, %eax
movl %eax, 0x38(%rsp)
movl $0x1, %r14d
xorl %r12d, %r12d
movq 0x38(%r15), %rax
movq (%rax,%r12,8), %rbx
movq (%rbx,%rbp,8), %rdi
testb $0x1, %dil
jne 0x1ad228b
callq 0x1b9b8ab
jmp 0x1ad229e
shrq $0x20, %rdi
movl %edi, %ecx
sarl $0x1f, %ecx
xorl %eax, %eax
testq %rdi, %rdi
setne %al
orl %ecx, %eax
testl %eax, %eax
je 0x1ad24c6
movq (%rbx,%rbp,8), %rdi
testb $0x1, %dil
jne 0x1ad22bc
movl $0x1, %esi
callq 0x1b9d181
jmp 0x1ad22d3
sarq $0x20, %rdi
xorl %eax, %eax
cmpq $0x2, %rdi
setge %al
xorl %ecx, %ecx
testq %rdi, %rdi
setle %cl
subl %ecx, %eax
testl %eax, %eax
je 0x1ad24c6
movq (%rbx,%rbp,8), %rdi
testb $0x1, %dil
jne 0x1ad22f3
movq $-0x1, %rsi
callq 0x1b9d181
jmp 0x1ad2307
xorl %eax, %eax
sarq $0x20, %rdi
setns %al
xorl %ecx, %ecx
cmpq $-0x1, %rdi
setl %cl
subl %ecx, %eax
testl %eax, %eax
je 0x1ad24c6
movq 0x20(%rsp), %rax
leaq (%rbx,%rax,8), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x1b6bab8
cmpl $-0x1, %eax
jne 0x1ad24c6
movq 0x8(%rsp), %rax
leaq (%rbx,%rax,8), %rdi
addq $0x8, %rdi
movl 0x38(%rsp), %esi
callq 0x1b6bab8
cmpl $-0x1, %eax
jne 0x1ad24c6
cmpq 0x40(%rsp), %r12
setl %r15b
jge 0x1ad24c6
movq %r14, %rbx
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax,%r12,8), %rdi
addq $0x8, %rdi
movq (%rax,%rbx,8), %rsi
addq $0x8, %rsi
movl 0x4(%rsp), %edx
callq 0x1b6b8bf
testl %eax, %eax
je 0x1ad24a7
movq 0x28(%rsp), %r13
movq 0x38(%r13), %rax
movq (%rax,%r12,8), %rcx
movq (%rcx), %rsi
movq (%rax,%rbx,8), %rax
movq (%rax), %rdx
leaq 0x30(%rsp), %rdi
callq 0x1b09b36
movq 0x30(%rsp), %rdi
movq 0x38(%r13), %rax
movq (%rax,%r12,8), %rax
movq (%rax,%rbp,8), %rsi
movq %rdi, %rax
shrq $0x20, %rax
movl %edi, %ecx
andl %esi, %ecx
testb $0x1, %cl
je 0x1ad23f6
shrq $0x20, %rsi
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movl %esi, %edx
negl %edx
cmovsl %esi, %edx
xorl %eax, %eax
xorl %esi, %esi
cmpl %edx, %ecx
setg %al
setl %sil
subl %esi, %eax
movq 0x18(%rsp), %r13
jmp 0x1ad24a3
testb $0x1, %dil
movq 0x18(%rsp), %r13
je 0x1ad2455
leaq 0xa0(%rsp), %rcx
movq %rcx, 0x88(%rsp)
movl $0x2, 0x90(%rsp)
testq %rdi, %rdi
js 0x1ad242e
movb 0x3(%rsp), %cl
movb %cl, 0x98(%rsp)
jmp 0x1ad243b
movb 0x2(%rsp), %cl
movb %cl, 0x98(%rsp)
negl %eax
movl %eax, 0xa0(%rsp)
movl $0x1, 0x94(%rsp)
leaq 0x80(%rsp), %rdi
testb $0x1, %sil
je 0x1ad249e
movq %rsi, %rax
shrq $0x20, %rax
leaq 0x78(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movl $0x2, 0x68(%rsp)
testq %rsi, %rsi
js 0x1ad2483
movb 0x3(%rsp), %cl
movb %cl, 0x70(%rsp)
jmp 0x1ad248d
movb 0x2(%rsp), %cl
movb %cl, 0x70(%rsp)
negl %eax
movl %eax, 0x78(%rsp)
movl $0x1, 0x6c(%rsp)
leaq 0x58(%rsp), %rsi
callq 0x1b9d17c
testl %eax, %eax
js 0x1ad24bc
incq %rbx
cmpl %ebx, %r13d
setg %r15b
cmpq %rbx, %r13
jne 0x1ad235f
jmp 0x1ad24c6
testb $0x1, %r15b
jne 0x1ad25d2
incq %r12
incq %r14
cmpq %r13, %r12
movq 0x28(%rsp), %r15
jne 0x1ad2272
movq 0x8(%rsp), %rcx
incq %rcx
movq %rcx, 0x8(%rsp)
cmpq 0x48(%rsp), %rcx
jne 0x1ad2246
movq 0x30(%rsp), %rdi
testb $0x1, %dil
jne 0x1ad2502
callq 0x1b9b0de
movq %r15, %rdi
callq 0x1b0fb02
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x1b20781
testl %eax, %eax
js 0x1ad25b3
je 0x1ad258a
movq %rbx, %rdi
callq 0x1b312bc
testq %rax, %rax
je 0x1ad25bb
movq %rax, %r14
movq %rax, %rdi
callq 0x1b0fb77
movq %rax, %rdi
xorl %esi, %esi
callq 0x1abf908
movq %rax, %rbx
cmpl $0x0, 0x28(%r14)
jle 0x1ad2580
xorl %r15d, %r15d
movq 0x38(%r14,%r15,8), %rdi
callq 0x1b10877
movq %rax, %rdi
callq 0x1b19cf9
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1ac1a55
movq %rax, %rbx
incq %r15
movslq 0x28(%r14), %rax
cmpq %rax, %r15
jl 0x1ad2554
movq %r14, %rdi
callq 0x1b0fdb2
jmp 0x1ad25bd
movq %rbx, %rdi
callq 0x1b0f5f9
leaq 0x3439bc7(%rip), %rdx # 0x4f0c160
leaq 0x3438c91(%rip), %rcx # 0x4f0b231
movq %rax, %rdi
movl $0x5, %esi
movl $0x13d8, %r8d # imm = 0x13D8
callq 0x1af81bb
movq %rbx, %rdi
callq 0x1b0fdb2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%rsp), %rdi
testb $0x1, %dil
jne 0x1ad25e2
callq 0x1b9b0de
movq 0x28(%rsp), %r15
movq 0x38(%r15), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %rax
movq (%rax,%rbp,8), %rdi
testb $0x1, %dil
jne 0x1ad2602
callq 0x1b9b8ab
jmp 0x1ad2615
shrq $0x20, %rdi
movl %edi, %ecx
sarl $0x1f, %ecx
xorl %eax, %eax
testq %rdi, %rdi
setne %al
orl %ecx, %eax
movq 0x10(%rsp), %r14
testl %eax, %eax
cmovgq %r12, %rbx
movq %r14, %rdi
callq 0x1b18946
testl %eax, %eax
js 0x1ad268c
movl %eax, 0x4(%rsp)
movq %r15, %rdi
movl $0x3, %esi
callq 0x1b0f370
movl %eax, 0x20(%rsp)
movq %r14, %rdi
callq 0x1b0f5f9
movq %rax, %r12
movq %r14, %rdi
callq 0x1b0fb77
movq %rax, %rdi
callq 0x1b71eaa
movq %rax, %r13
movq %rax, %rdi
movl $0x3, %esi
callq 0x1b6fb4e
movl %eax, %r14d
movq %r13, %rdi
movl $0x5, %esi
callq 0x1b6fb4e
movl %eax, %ebp
movl %r14d, %eax
orl %ebp, %eax
jns 0x1ad269f
movq 0x10(%rsp), %r14
jmp 0x1ad268f
xorl %r13d, %r13d
movq %r13, %rdi
callq 0x1b6fe0a
movq %r14, %rdi
jmp 0x1ad21c0
leal 0x2(%rbp), %esi
movq %r12, %rdi
callq 0x1b97dfc
movq %rax, %r12
testq %rax, %rax
je 0x1ad2749
movl %r14d, 0x18(%rsp)
movq %r12, 0x38(%rsp)
movq 0x18(%r12), %r14
movq 0x38(%r15), %rax
movl %ebx, %ebx
movq (%rax,%rbx,8), %rax
movl 0x20(%rsp), %ecx
addl 0x8(%rsp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %r12
movq (%r14), %rdi
testb $0x1, %r12b
jne 0x1ad2702
testb $0x1, %dil
je 0x1ad26f5
callq 0x1b9ade4
movq %rax, (%r14)
movq (%r14), %rsi
movq %r12, %rdi
callq 0x1b9b1dd
jmp 0x1ad2725
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %rax, %r12
testb $0x1, %dil
jne 0x1ad271a
callq 0x1b9b0de
movl $0x1, %eax
subq %r12, %rax
movq %rax, (%r14)
movq 0x38(%rsp), %r12
movq 0x18(%r12), %rdi
addq $0x8, %rdi
movq 0x38(%r15), %rax
movq (%rax,%rbx,8), %rsi
incl %ebp
movl %ebp, %edx
callq 0x1b6b0a5
movl 0x18(%rsp), %r14d
movq %r15, %rdi
callq 0x1b0fb02
movq %r13, %rdi
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1b0bddf
movq %rax, %rdi
movq %r12, %rsi
callq 0x1ab11f2
movq %rax, %rdi
callq 0x1ab3aa4
movq %rax, %r15
cmpl $0x0, 0x4(%rsp)
je 0x1ad2790
movq %r13, %rdi
callq 0x1b6fe0a
movq %r15, %rdi
callq 0x1abe097
jmp 0x1ad27b6
movq %r13, %rdi
callq 0x1b7279b
movq %rax, %rdi
callq 0x1abe0eb
movq %rax, %rbx
movq %r15, %rdi
callq 0x1abe097
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1abceb9
movq %rax, %r15
movq 0x10(%rsp), %rbx
testq %rax, %rax
je 0x1ad27cb
incl (%r15)
movq %r15, %rdi
jmp 0x1ad27cd
xorl %edi, %edi
callq 0x1ad3569
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1b178ca
movq %rax, %rdi
movl $0x2, %esi
movl %r14d, %edx
movl $0x3, %ecx
movq 0x8(%rsp), %r8
callq 0x1b15bd7
movq %rax, %rdi
callq 0x1ac50ff
movq %rax, %rdi
movq %r15, %rsi
callq 0x1ac266f
movq %rax, %rbx
jmp 0x1ad25bd
|
/External/isl/isl_aff.c
|
gen_range_product_entry
|
static isl_stat gen_range_product_entry(__isl_take isl_pw_multi_aff *pma2,
__isl_give isl_pw_multi_aff *(*range_product)(
__isl_take isl_pw_multi_aff *pma1,
__isl_take isl_pw_multi_aff *pma2),
void *user)
{
struct isl_union_pw_multi_aff_bin_data *data = user;
isl_bool match;
isl_space *space1, *space2;
space1 = isl_pw_multi_aff_peek_space(data->pma);
space2 = isl_pw_multi_aff_peek_space(pma2);
match = isl_space_tuple_is_equal(space1, isl_dim_in,
space2, isl_dim_in);
if (match < 0 || !match) {
isl_pw_multi_aff_free(pma2);
return match < 0 ? isl_stat_error : isl_stat_ok;
}
pma2 = range_product(isl_pw_multi_aff_copy(data->pma), pma2);
data->res = isl_union_pw_multi_aff_add_pw_multi_aff(data->res, pma2);
return isl_stat_ok;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0x1ad285e
movq 0x8(%rax), %rdi
jmp 0x1ad2860
xorl %edi, %edi
testq %r14, %r14
je 0x1ad286b
movq 0x8(%r14), %rdx
jmp 0x1ad286d
xorl %edx, %edx
movl $0x2, %esi
movl $0x2, %ecx
callq 0x1b70be9
testl %eax, %eax
jle 0x1ad2890
movq 0x10(%rbx), %rdi
xorl %r12d, %r12d
testq %rdi, %rdi
je 0x1ad28a4
incl (%rdi)
jmp 0x1ad28a6
movl %eax, %ebp
movq %r14, %rdi
callq 0x1aae967
xorl %r12d, %r12d
negl %ebp
sbbl %r12d, %r12d
jmp 0x1ad28c1
xorl %edi, %edi
movq %r14, %rsi
callq *%r15
movq 0x8(%rbx), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x1ac30ef
movq %rax, 0x8(%rbx)
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_aff.c
|
isl_map_local_affine_hull
|
static __isl_give isl_map *isl_map_local_affine_hull(__isl_take isl_map *map)
{
int i;
map = isl_map_cow(map);
if (!map)
return NULL;
for (i = 0; i < map->n; ++i) {
map->p[i] = isl_basic_map_affine_hull(map->p[i]);
map->p[i] = isl_basic_map_gauss(map->p[i], NULL);
map->p[i] = isl_basic_map_make_strides_explicit(map->p[i]);
if (!map->p[i])
return isl_map_free(map);
}
return map;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
callq 0x1b0fd0b
testq %rax, %rax
je 0x1ad5295
movq %rax, %rbx
cmpl $0x0, 0x28(%rax)
jle 0x1ad52a4
xorl %r14d, %r14d
movq %rbx, 0x8(%rsp)
movq 0x38(%rbx,%r14,8), %rdi
callq 0x1ad4827
movq %rax, %rdi
callq 0x1ad4ce4
movq %rax, 0x38(%rbx,%r14,8)
movq %rax, %rdi
xorl %esi, %esi
callq 0x1b27ec7
movq %rax, %r13
movq %rax, 0x38(%rbx,%r14,8)
movq %rax, %rdi
callq 0x1b1a515
testl %eax, %eax
js 0x1ad4f06
jne 0x1ad4f11
movq %r13, %rdi
callq 0x1b0c93c
movq %rax, %rdi
xorl %esi, %esi
callq 0x1b27ec7
movl $0x0, %r13d
testq %rax, %rax
je 0x1ad4f11
movq %rax, %r15
cmpl $0x0, 0x40(%rax)
je 0x1ad4f34
xorl %ebp, %ebp
movq 0x48(%r15), %rax
movq (%rax,%rbp,8), %rax
movq (%rax), %rdi
testb $0x1, %dil
jne 0x1ad4ee1
callq 0x1b9b8ab
jmp 0x1ad4ef4
shrq $0x20, %rdi
movl %edi, %ecx
sarl $0x1f, %ecx
xorl %eax, %eax
testq %rdi, %rdi
setne %al
orl %ecx, %eax
testl %eax, %eax
je 0x1ad4f36
incq %rbp
movl 0x40(%r15), %eax
cmpq %rax, %rbp
jb 0x1ad4ec9
jmp 0x1ad4f36
movq %r13, %rdi
callq 0x1b0fb02
movq %rax, %r13
movq %r13, 0x38(%rbx,%r14,8)
testq %r13, %r13
je 0x1ad5299
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x1ad4e6a
jmp 0x1ad52a4
xorl %ebp, %ebp
movq %r15, %rdi
movl $0x4, %esi
callq 0x1b0f2e7
testl %eax, %eax
js 0x1ad4f96
movl %eax, %r13d
cmpl $0x0, 0x1c(%r15)
je 0x1ad4f9e
movq %r13, (%rsp)
movl %r13d, %r13d
movl %ebp, %ebx
shlq $0x3, %r13
xorl %r12d, %r12d
movq 0x30(%r15), %rax
movq (%rax,%r12,8), %rax
addq %r13, %rax
leaq (%rax,%rbx,8), %rdi
addq $0x8, %rdi
movl 0x40(%r15), %esi
subl %ebp, %esi
callq 0x1b6bab8
cmpl $-0x1, %eax
je 0x1ad4f90
incq %r12
movl 0x1c(%r15), %eax
cmpq %rax, %r12
jb 0x1ad4f61
movq (%rsp), %r13
jmp 0x1ad4fa1
movq %r15, %rdi
jmp 0x1ad4f09
xorl %r12d, %r12d
testl %r12d, %r12d
je 0x1ad507e
movq %r15, %rdi
callq 0x1b0f35e
movq %rax, 0x10(%rsp)
movq 0x30(%r15), %rsi
leal 0x1(%rbp,%r13), %ebx
movq %rax, %rdi
xorl %edx, %edx
movl %r12d, %ecx
xorl %r8d, %r8d
movl %ebx, %r9d
callq 0x1b32ab5
movq %rax, (%rsp)
movl 0x40(%r15), %r13d
subl %ebp, %r13d
movq 0x30(%r15), %rsi
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %r12d, %ecx
movl %ebx, %r8d
movl %r13d, %r9d
callq 0x1b32ab5
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1b34184
subl %r12d, %r13d
movq %rax, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x1b360b7
movq %rax, %rdi
callq 0x1b34e7e
movq %rax, %rdi
callq 0x1b35251
movq %rax, %r12
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x1b363de
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x1b32ee9
movq %r12, %rdi
movq %rax, %rsi
callq 0x1b35964
testq %rax, %rax
je 0x1ad5083
movq %rax, %r13
movq 0x20(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
testb $0x1, %dil
movq 0x8(%rsp), %rbx
jne 0x1ad5098
movl $0x1, %esi
callq 0x1b9d181
jmp 0x1ad50af
movq %r15, %r13
jmp 0x1ad508e
movq %r15, %rdi
callq 0x1b0fb02
movq %rax, %r13
movq 0x8(%rsp), %rbx
jmp 0x1ad4f11
sarq $0x20, %rdi
xorl %eax, %eax
cmpq $0x2, %rdi
setge %al
xorl %ecx, %ecx
testq %rdi, %rdi
setle %cl
subl %ecx, %eax
testl %eax, %eax
movq %r13, 0x10(%rsp)
je 0x1ad5279
movl 0x14(%r13), %edx
decl %edx
movq %r15, %rdi
movl %edx, %esi
xorl %ecx, %ecx
callq 0x1b11693
movq %rax, %r15
movq $0x1, 0x18(%rsp)
cmpl $0x2, 0x14(%r13)
leaq 0x18(%rsp), %rbx
jb 0x1ad5247
movl $0x1, %r12d
movq 0x20(%r13), %rax
movq (%rax,%r12,8), %rdi
movl 0x18(%r13), %esi
movq %rbx, %rdx
callq 0x1b6be69
movq 0x18(%rsp), %rdi
movq 0x20(%r13), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x1b0b961
testl %eax, %eax
jne 0x1ad5237
movq %r15, %rdi
callq 0x1b0f9b3
testl %eax, %eax
js 0x1ad5259
movl %eax, %r13d
movq 0x48(%r15), %rax
movl %r13d, %ecx
movq (%rax,%rcx,8), %rbx
movq (%rbx), %rdi
testb $0x1, %dil
jne 0x1ad514c
callq 0x1b9b0de
movq $0x1, (%rbx)
movq %r15, %rdi
callq 0x1b10fd2
testl %eax, %eax
js 0x1ad5259
movq 0x30(%r15), %rcx
movl %eax, %eax
movq %rax, (%rsp)
movq (%rcx,%rax,8), %rdi
movq 0x10(%rsp), %rbx
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rsi
movl 0x18(%rbx), %edx
callq 0x1b6b0a5
movq 0x30(%r15), %rax
movl 0x18(%rbx), %edi
shlq $0x3, %rdi
movq (%rsp), %rcx
addq (%rax,%rcx,8), %rdi
movl 0x40(%r15), %esi
subl %ebp, %esi
callq 0x1b6aef8
movq 0x30(%r15), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rcx
subl %ebp, %r13d
addl 0x18(%rbx), %r13d
movq 0x20(%rbx), %rax
movq (%rax), %rax
movq (%rax), %rdx
testb $0x1, %dl
jne 0x1ad51fb
testb $0x1, (%rcx,%r13,8)
leaq 0x18(%rsp), %rbx
je 0x1ad51ed
movq %rcx, (%rsp)
movq %rdx, 0x20(%rsp)
callq 0x1b9ade4
movq 0x20(%rsp), %rdx
movq (%rsp), %rcx
movq %rax, (%rcx,%r13,8)
movq (%rcx,%r13,8), %rsi
movq %rdx, %rdi
callq 0x1b9b015
jmp 0x1ad5232
movq (%rcx,%r13,8), %rdi
testb $0x1, %dil
leaq 0x18(%rsp), %rbx
jne 0x1ad5221
movq %rcx, (%rsp)
movq %rdx, 0x20(%rsp)
callq 0x1b9b0de
movq 0x20(%rsp), %rdx
movq (%rsp), %rcx
movabsq $-0xffffffff, %rax # imm = 0xFFFFFFFF00000001
andq %rax, %rdx
movq %rdx, (%rcx,%r13,8)
movq 0x10(%rsp), %r13
incq %r12
movl 0x14(%r13), %eax
cmpq %rax, %r12
jb 0x1ad50f0
movq 0x18(%rsp), %rdi
testb $0x1, %dil
jne 0x1ad5274
callq 0x1b9b0de
jmp 0x1ad5274
movq 0x18(%rsp), %rdi
testb $0x1, %dil
jne 0x1ad5269
callq 0x1b9b0de
movq %r15, %rdi
callq 0x1b0fb02
xorl %r15d, %r15d
movq 0x8(%rsp), %rbx
movq %r15, %rdi
xorl %esi, %esi
callq 0x1b27ec7
movq %rax, %r13
movq 0x10(%rsp), %rdi
callq 0x1b32a2f
jmp 0x1ad4f11
xorl %ebx, %ebx
jmp 0x1ad52a4
movq %rbx, %rdi
callq 0x1b0fdb2
movq %rax, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_affine_hull.c
|
isl_ast_build_set_after_each_for
|
__isl_give isl_ast_build *isl_ast_build_set_after_each_for(
__isl_take isl_ast_build *build,
__isl_give isl_ast_node *(*fn)(__isl_take isl_ast_node *node,
__isl_keep isl_ast_build *build, void *user), void *user)
{
build = isl_ast_build_cow(build);
if (!build)
return NULL;
build->after_each_for = fn;
build->after_each_for_user = user;
return build;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x1ad6311
movq %rdi, %rax
movl (%rdi), %ecx
cmpl $0x1, %ecx
je 0x1ad6313
decl %ecx
movl %ecx, (%rax)
movq %rax, %rdi
callq 0x1ad5cd3
jmp 0x1ad6313
xorl %eax, %eax
testq %rax, %rax
je 0x1ad6328
movq %r14, 0x88(%rax)
movq %rbx, 0x90(%rax)
jmp 0x1ad632a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/External/isl/isl_ast_build.c
|
isl_ast_build_set_after_each_mark
|
__isl_give isl_ast_build *isl_ast_build_set_after_each_mark(
__isl_take isl_ast_build *build,
__isl_give isl_ast_node *(*fn)(__isl_take isl_ast_node *node,
__isl_keep isl_ast_build *build, void *user), void *user)
{
build = isl_ast_build_cow(build);
if (!build)
return NULL;
build->after_each_mark = fn;
build->after_each_mark_user = user;
return build;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x1ad63a1
movq %rdi, %rax
movl (%rdi), %ecx
cmpl $0x1, %ecx
je 0x1ad63a3
decl %ecx
movl %ecx, (%rax)
movq %rax, %rdi
callq 0x1ad5cd3
jmp 0x1ad63a3
xorl %eax, %eax
testq %rax, %rax
je 0x1ad63b8
movq %r14, 0xa8(%rax)
movq %rbx, 0xb0(%rax)
jmp 0x1ad63ba
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/External/isl/isl_ast_build.c
|
isl_ast_build_has_affine_value
|
isl_bool isl_ast_build_has_affine_value(__isl_keep isl_ast_build *build,
int pos)
{
isl_aff *aff;
isl_bool involves;
if (!build)
return isl_bool_error;
aff = isl_multi_aff_get_aff(build->values, pos);
involves = isl_aff_involves_dims(aff, isl_dim_in, pos, 1);
isl_aff_free(aff);
return isl_bool_not(involves);
}
|
testq %rdi, %rdi
je 0x1ad66fa
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x30(%rdi), %rdi
callq 0x1abc622
movq %rax, %r14
movq %rax, %rdi
movl $0x2, %esi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x1ab5236
movl %eax, %ebx
movq %r14, %rdi
callq 0x1aacce8
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1af810d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
|
/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 = isl_ast_build_get_stride(build, pos);
aff = isl_ast_build_get_offset(build, pos);
aff = isl_aff_add_coefficient_si(aff, isl_dim_in, pos, -1);
aff = isl_aff_mod_val(aff, stride);
set = isl_set_from_basic_set(isl_aff_zero_basic_set(aff));
return set;
}
|
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1ad7079
movq %rdi, %r14
movl 0x8(%rdi), %ebx
movl %ebx, %esi
callq 0x1ad7097
testl %eax, %eax
je 0x1ad7081
movq 0x40(%r14), %rdi
movl %ebx, %esi
callq 0x1b9829f
movq %rax, %r15
movq 0x48(%r14), %rdi
movl %ebx, %esi
callq 0x1abc622
movq %rax, %rdi
movl $0x2, %esi
movl %ebx, %edx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0x1ab33b2
movq %rax, %rdi
movq %r15, %rsi
callq 0x1ab3dfb
movq %rax, %rdi
callq 0x1ab502b
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1b138e3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x18(%r14), %rdi
callq 0x1b0fb8c
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1b18d33
|
/External/isl/isl_ast_build.c
|
isl_ast_build_product
|
__isl_give isl_ast_build *isl_ast_build_product(
__isl_take isl_ast_build *build, __isl_take isl_space *space)
{
isl_ctx *ctx;
isl_vec *strides;
isl_set *set;
isl_multi_aff *embedding;
isl_size dim, space_dim, n_it;
build = isl_ast_build_cow(build);
if (!build)
goto error;
build->outer_pos = build->depth;
ctx = isl_ast_build_get_ctx(build);
dim = isl_ast_build_dim(build, isl_dim_set);
space_dim = isl_space_dim(space, isl_dim_set);
n_it = isl_id_list_n_id(build->iterators);
if (dim < 0 || space_dim < 0 || n_it < 0)
goto error;
dim += space_dim;
if (n_it < dim) {
isl_id_list *l;
l = generate_names(ctx, dim - n_it, n_it, build);
build->iterators = isl_id_list_concat(build->iterators, l);
}
if (isl_set_is_params(build->domain))
return isl_ast_build_init(build, space);
set = isl_set_universe(isl_space_copy(space));
build->domain = isl_set_product(build->domain, isl_set_copy(set));
build->pending = isl_set_product(build->pending, isl_set_copy(set));
build->generated = isl_set_product(build->generated, set);
strides = isl_vec_alloc(ctx, space_dim);
strides = isl_vec_set_si(strides, 1);
build->strides = isl_vec_concat(build->strides, strides);
space = isl_space_map_from_set(space);
build->offsets = isl_multi_aff_align_params(build->offsets,
isl_space_copy(space));
build->offsets = isl_multi_aff_product(build->offsets,
isl_multi_aff_zero(isl_space_copy(space)));
build->values = isl_multi_aff_align_params(build->values,
isl_space_copy(space));
embedding = isl_multi_aff_identity(space);
build->values = isl_multi_aff_product(build->values,
isl_multi_aff_copy(embedding));
if (build->internal2input) {
build->internal2input =
isl_multi_aff_product(build->internal2input, embedding);
build->internal2input =
isl_multi_aff_flatten_range(build->internal2input);
if (!build->internal2input)
return isl_ast_build_free(build);
} else {
isl_multi_aff_free(embedding);
}
space = isl_ast_build_get_space(build, 1);
build->options = embed_options(build->options, space);
if (!build->iterators || !build->domain || !build->generated ||
!build->pending || !build->values ||
!build->strides || !build->offsets || !build->options)
return isl_ast_build_free(build);
return build;
error:
isl_ast_build_free(build);
isl_space_free(space);
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdi, %rdi
je 0x1ad7943
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1ad7945
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1ad5cd3
movq %rax, %rbx
jmp 0x1ad7945
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x1ad7992
movl 0x8(%rbx), %eax
movl %eax, 0x4(%rbx)
movq 0x18(%rbx), %rdi
callq 0x1b0f606
movq %rax, %r15
movq 0x18(%rbx), %rdi
movl $0x3, %esi
callq 0x1b0f2bb
movl %eax, %r12d
movq %r14, %rdi
movl $0x3, %esi
callq 0x1b6fb4e
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x1afe722
movl %eax, %r13d
movl %r12d, %eax
orl %ebp, %eax
orl %r13d, %eax
jns 0x1ad79b6
movq %rbx, %rdi
callq 0x1ad5f22
movq %r14, %rdi
callq 0x1b6fe0a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl %ebp, %r12d
movl %r12d, %esi
subl %r13d, %esi
jle 0x1ad7a0d
movq %r14, (%rsp)
movq %r15, %rdi
callq 0x1afe1b9
movq %rax, %r14
cmpl %r13d, %r12d
jle 0x1ad79f9
movq %r15, %rdi
movl %r13d, %esi
movq %rbx, %rdx
callq 0x1ad5ad0
movq %r14, %rdi
movq %rax, %rsi
callq 0x1afe29c
movq %rax, %r14
incl %r13d
cmpl %r13d, %r12d
jne 0x1ad79d5
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x1afed58
movq %rax, 0x10(%rbx)
movq (%rsp), %r14
movq 0x18(%rbx), %rdi
callq 0x1b108fa
testl %eax, %eax
je 0x1ad7aac
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x1ad7a34
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1ad5cd3
movq %rax, %rbx
testq %rbx, %rbx
je 0x1ad799a
movq %r14, %rdi
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1b18d33
movq %r14, %r15
movq %rax, %r14
movq %rax, %rdi
callq 0x1b10b72
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x1b14576
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x1b10b72
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x1b14576
movq %rax, 0x28(%rbx)
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x1b14576
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ad5b6e
movq %r14, %rdi
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1b18d33
movq %r14, %r13
movq %rax, %r14
movq 0x18(%rbx), %r12
movq %rax, %rdi
callq 0x1b10b72
movq %r12, %rdi
movq %rax, %rsi
callq 0x1b1b0ff
movq %rax, 0x18(%rbx)
movq 0x28(%rbx), %r12
movq %r14, %rdi
callq 0x1b10b72
movq %r12, %rdi
movq %rax, %rsi
callq 0x1b1b0ff
movq %rax, 0x28(%rbx)
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x1b1b0ff
movq %rax, 0x20(%rbx)
movq %r15, %rdi
movl %ebp, %esi
callq 0x1b97dfc
movq %rax, %rdi
movl $0x1, %esi
callq 0x1b98723
movq 0x40(%rbx), %rdi
movq %rax, %rsi
callq 0x1b981ae
movq %rax, 0x40(%rbx)
movq %r13, %rdi
callq 0x1b7279b
movq %rax, %r14
movq 0x48(%rbx), %r15
movq %rax, %rdi
callq 0x1b6fd4e
movq %r15, %rdi
movq %rax, %rsi
callq 0x1abc6e6
movq %rax, %r15
movq %rax, 0x48(%rbx)
movq %r14, %rdi
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1abeadf
movq %r15, %rdi
movq %rax, %rsi
callq 0x1abe5b7
movq %rax, 0x48(%rbx)
movq 0x30(%rbx), %r15
movq %r14, %rdi
callq 0x1b6fd4e
movq %r15, %rdi
movq %rax, %rsi
callq 0x1abc6e6
movq %rax, 0x30(%rbx)
movq %r14, %rdi
callq 0x1abe0eb
movq %rax, %r14
movq 0x30(%rbx), %r15
movq %rax, %rdi
callq 0x1ab8ced
movq %r15, %rdi
movq %rax, %rsi
callq 0x1abe5b7
movq %rax, 0x30(%rbx)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x1ad7be0
movq %r14, %rsi
callq 0x1abe5b7
movq %rax, 0x58(%rbx)
movq %rax, %rdi
callq 0x1abd380
movq %rax, 0x58(%rbx)
testq %rax, %rax
jne 0x1ad7be8
jmp 0x1ad7c5e
movq %r14, %rdi
callq 0x1ab8e88
movq 0x18(%rbx), %rdi
callq 0x1b0fb8c
movq 0x60(%rbx), %r14
movq %rax, %rdi
callq 0x1b73436
movq %rax, %rdi
callq 0x1b131b0
movq %rax, %rdi
callq 0x1b18a6e
movq %rax, %rdi
callq 0x1b8d241
movq %rax, %rdi
movq %r14, %rsi
callq 0x1b8e038
movq %rax, 0x60(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1ad7c5e
cmpq $0x0, 0x18(%rbx)
je 0x1ad7c5e
cmpq $0x0, 0x20(%rbx)
je 0x1ad7c5e
cmpq $0x0, 0x28(%rbx)
je 0x1ad7c5e
cmpq $0x0, 0x30(%rbx)
je 0x1ad7c5e
cmpq $0x0, 0x40(%rbx)
je 0x1ad7c5e
cmpq $0x0, 0x48(%rbx)
je 0x1ad7c5e
testq %rax, %rax
jne 0x1ad79a4
movq %rbx, %rdi
callq 0x1ad5f22
jmp 0x1ad79a2
|
/External/isl/isl_ast_build.c
|
every_non_zero_coefficient
|
static isl_bool every_non_zero_coefficient(__isl_keep isl_aff *aff,
int reverse,
isl_bool (*fn)(enum isl_dim_type type, int pos, __isl_take isl_val *v,
void *user),
void *user)
{
int i, j;
enum isl_dim_type t[] = { isl_dim_param, isl_dim_in, isl_dim_div };
enum isl_dim_type l[] = { isl_dim_param, isl_dim_set, isl_dim_div };
isl_val *v;
for (i = 0; i < 3; ++i) {
isl_size n;
n = isl_aff_dim(aff, t[i]);
if (n < 0)
return isl_bool_error;
for (j = 0; j < n; ++j) {
isl_bool ok;
int pos;
pos = reverse ? n - 1 - j : j;
v = isl_aff_get_coefficient_val(aff, t[i], pos);
ok = isl_val_is_zero(v);
if (ok >= 0 && !ok)
ok = fn(l[i], pos, v, user);
else
isl_val_free(v);
if (ok < 0 || !ok)
return ok;
}
}
return isl_bool_true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %esi, (%rsp)
movq %rdi, 0x10(%rsp)
xorl %ebx, %ebx
leaq 0x3432aad(%rip), %rax # 0x4f0c6a8
movl (%rax,%rbx,4), %esi
movq 0x10(%rsp), %rdi
movl %esi, 0x4(%rsp)
callq 0x1ab182e
testl %eax, %eax
movq %rbx, 0x8(%rsp)
js 0x1ad9c93
je 0x1ad9c9d
movl %eax, %ebp
decl %ebp
xorl %r13d, %r13d
cmpl $0x0, (%rsp)
movl %ebp, %ebx
cmovel %r13d, %ebx
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
movl %ebx, %edx
callq 0x1ab1ed4
movq %rax, %r15
movq %rax, %rdi
callq 0x1b936ce
testl %eax, %eax
je 0x1ad9c58
movl %eax, %r14d
movq %r15, %rdi
callq 0x1b91ce4
jmp 0x1ad9c78
movq 0x8(%rsp), %rax
leaq 0x3432a50(%rip), %rcx # 0x4f0c6b4
movl (%rcx,%rax,4), %edi
movl %ebx, %esi
movq %r15, %rdx
movq 0x20(%rsp), %rcx
callq *0x18(%rsp)
movl %eax, %r14d
addl $-0x1, %ebp
setb %cl
testl %r14d, %r14d
setg %al
cmovlel %r14d, %r12d
jle 0x1ad9c9f
incl %r13d
testb %cl, %cl
jne 0x1ad9c22
jmp 0x1ad9c9f
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
xorl %eax, %eax
jmp 0x1ad9c9f
movb $0x1, %al
testb %al, %al
je 0x1ad9cbb
movq 0x8(%rsp), %rbx
incq %rbx
cmpq $0x3, %rbx
jne 0x1ad9bf4
movl $0x1, %r12d
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_ast_build_expr.c
|
isl_ast_node_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 0x1adcaed
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x3e1ef59(%rip), %rax # 0x58fba18
movq (%rax), %rsi
callq 0x1b5095c
movq %rax, %rdi
xorl %esi, %esi
callq 0x1b50d30
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1adc997
movq %rax, %rdi
callq 0x1b50f6d
movq %rax, %rdi
popq %rbx
jmp 0x1b50a57
retq
|
/External/isl/print_templ.c
|
alloc_op
|
static __isl_give isl_ast_expr *alloc_op(enum isl_ast_expr_op_type op,
__isl_take isl_ast_expr_list *args)
{
isl_ctx *ctx;
isl_ast_expr *expr;
if (!args)
return NULL;
ctx = isl_ast_expr_list_get_ctx(args);
expr = isl_calloc_type(ctx, isl_ast_expr);
if (!expr)
goto error;
expr->ctx = ctx;
isl_ctx_ref(ctx);
expr->ref = 1;
expr->type = isl_ast_expr_op;
expr->u.op.op = op;
expr->u.op.args = args;
return expr;
error:
isl_ast_expr_list_free(args);
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1adccf6
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %r15
movl $0x1, %esi
movl $0x28, %edx
movq %r15, %rdi
callq 0x1af8296
testq %rax, %rax
je 0x1adccee
movq %rax, %r14
movq %r15, 0x8(%rax)
movq %r15, %rdi
callq 0x1af85c4
movl $0x1, (%r14)
movl $0x0, 0x10(%r14)
movl %ebp, 0x18(%r14)
movq %rbx, 0x20(%r14)
jmp 0x1adccf9
movq %rbx, %rdi
callq 0x1adb152
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/External/isl/isl_ast.c
|
isl_ast_node_alloc_mark
|
__isl_give isl_ast_node *isl_ast_node_alloc_mark(__isl_take isl_id *id,
__isl_take isl_ast_node *node)
{
isl_ctx *ctx;
isl_ast_node *mark;
if (!id || !node)
goto error;
ctx = isl_id_get_ctx(id);
mark = isl_ast_node_alloc(ctx, isl_ast_node_mark);
if (!mark)
goto error;
mark->u.m.mark = id;
mark->u.m.node = node;
return mark;
error:
isl_id_free(id);
isl_ast_node_free(node);
return NULL;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x1add764
movq %r14, %rdi
callq 0x1afed46
movq %rax, %rdi
movl $0x4, %esi
callq 0x1add659
testq %rax, %rax
je 0x1add764
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
jmp 0x1add776
movq %r14, %rdi
callq 0x1afe3ec
movq %rbx, %rdi
callq 0x1adbeed
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/External/isl/isl_ast.c
|
isl_ast_node_block_from_children
|
__isl_give isl_ast_node *isl_ast_node_block_from_children(
__isl_take isl_ast_node_list *list)
{
isl_ast_node *node;
isl_ctx *ctx;
if (!list)
return NULL;
ctx = isl_ast_node_list_get_ctx(list);
node = isl_ast_node_alloc(ctx, isl_ast_node_block);
if (!node)
goto error;
node->u.b.children = list;
return node;
error:
isl_ast_node_list_free(list);
return NULL;
}
|
testq %rdi, %rdi
je 0x1add7d6
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl $0x3, %esi
callq 0x1add659
testq %rax, %rax
je 0x1add7d9
movq %rbx, 0x18(%rax)
jmp 0x1add7e3
xorl %eax, %eax
retq
movq %rbx, %rdi
callq 0x1adbfac
xorl %eax, %eax
popq %rbx
retq
|
/External/isl/isl_ast.c
|
isl_ast_node_for_mark_degenerate
|
__isl_give isl_ast_node *isl_ast_node_for_mark_degenerate(
__isl_take isl_ast_node *node)
{
node = isl_ast_node_cow(node);
if (!node)
return NULL;
node->u.f.degenerate = 1;
return node;
}
|
pushq %rax
testq %rdi, %rdi
je 0x1addcb2
movq %rdi, %rax
movl (%rdi), %ecx
cmpl $0x1, %ecx
je 0x1addcb4
decl %ecx
movl %ecx, (%rax)
movq %rax, %rdi
callq 0x1add87b
jmp 0x1addcb4
xorl %eax, %eax
testq %rax, %rax
je 0x1addcbf
orb $0x1, 0x18(%rax)
jmp 0x1addcc1
xorl %eax, %eax
popq %rcx
retq
|
/External/isl/isl_ast.c
|
isl_stream_read_ast_node
|
__isl_give isl_ast_node *isl_stream_read_ast_node(__isl_keep isl_stream *s)
{
enum isl_ast_node_type type;
isl_bool more;
isl_bool seq;
isl_ast_node *node;
seq = next_is_sequence(s);
if (seq < 0)
return NULL;
if (seq)
return read_block(s);
if (isl_stream_yaml_read_start_mapping(s))
return NULL;
more = isl_stream_yaml_next(s);
if (more < 0)
return NULL;
if (!more) {
isl_stream_error(s, NULL, "missing key");
return NULL;
}
type = get_node_type(s);
if (type < 0)
return NULL;
if (isl_stream_yaml_next(s) < 0)
return NULL;
switch (type) {
case isl_ast_node_block:
isl_die(isl_stream_get_ctx(s), isl_error_internal,
"block cannot be detected as mapping",
return NULL);
case isl_ast_node_for:
node = read_for(s);
break;
case isl_ast_node_mark:
node = read_mark(s);
break;
case isl_ast_node_user:
node = read_user(s);
break;
case isl_ast_node_if:
node = read_if(s);
break;
case isl_ast_node_error:
return NULL;
}
if (isl_stream_yaml_read_end_mapping(s) < 0)
return isl_ast_node_free(node);
return node;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1b74e19
testq %rax, %rax
je 0x1adf810
movq %rax, %r14
movq %rax, %rdi
callq 0x1b74a4e
cmpl $0x5b, %eax
sete %cl
cmpl $0x2d, %eax
sete %al
orb %cl, %al
movzbl %al, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b74d81
movl %ebp, %edi
callq 0x1af811d
jmp 0x1adf815
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x1adf89f
movq %rbx, %rdi
je 0x1adf896
callq 0x1b75ac2
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b760f1
testl %eax, %eax
js 0x1adf87d
movq %r14, %rdi
xorl %esi, %esi
callq 0x1adbcd2
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b75b8b
cmpl $0x1, %eax
jne 0x1adf865
movq %rbx, %rdi
callq 0x1adf7c8
movq %r14, %rdi
movq %rax, %rsi
callq 0x1adbdad
jmp 0x1adf840
testl %eax, %eax
js 0x1adf875
movq %rbx, %rdi
callq 0x1b761b5
testl %eax, %eax
jns 0x1adf880
movq %r14, %rdi
callq 0x1adbfac
xorl %r14d, %r14d
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1add7b4
callq 0x1b75ec1
testl %eax, %eax
je 0x1adf8b4
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x1b75b8b
testl %eax, %eax
js 0x1adf89f
je 0x1adf972
movq %rbx, %rdi
callq 0x1b74e19
movq %rax, %r14
movq %rax, %rdi
callq 0x1b74a98
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x1adf9a3
je 0x1adf98b
movq %rbx, %rdi
callq 0x1b75ac2
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1b74ab4
testq %rax, %rax
je 0x1adf9a3
movq %rax, %r12
leaq 0x3d9ec0a(%rip), %rbp # 0x587e520
xorl %r13d, %r13d
testq %r13, %r13
je 0x1adf92e
movq (%rbp), %rsi
movq %r12, %rdi
callq 0x780dc0
testl %eax, %eax
je 0x1adf941
incq %r13
addq $0x8, %rbp
cmpq $0x6, %r13
jne 0x1adf919
movl $0x6, %r13d
movq %r12, %rdi
callq 0x780910
cmpl $0x6, %r13d
jb 0x1adf9a3
leaq 0x342d13c(%rip), %rdx # 0x4f0ca92
leaq 0x342d141(%rip), %rcx # 0x4f0ca9e
movq %r15, %rdi
movl $0x5, %esi
movl $0x2c, %r8d
callq 0x1af81bb
jmp 0x1adf99d
leaq 0x342cf63(%rip), %rdx # 0x4f0c8dc
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1b74b4a
jmp 0x1adf8a2
leaq 0x342d0f2(%rip), %rdx # 0x4f0ca84
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b74b4a
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x1b74af0
testl %r13d, %r13d
js 0x1adf89f
movq %rbx, %rdi
callq 0x1b75b8b
testl %eax, %eax
js 0x1adf89f
decl %r13d
cmpl $0x4, %r13d
ja 0x1adfa55
leaq 0x342ce0c(%rip), %rax # 0x4f0c7e4
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rdi
callq 0x1adfa57
jmp 0x1adfa35
movq %rbx, %rdi
callq 0x1adfc78
jmp 0x1adfa35
movq %rbx, %rdi
callq 0x1b75ac2
leaq 0x342cf0d(%rip), %rdx # 0x4f0c911
leaq 0x342ce17(%rip), %rcx # 0x4f0c822
movq %rax, %rdi
movl $0x4, %esi
movl $0xdd2, %r8d # imm = 0xDD2
callq 0x1af81bb
jmp 0x1adf89f
movq %rbx, %rdi
callq 0x1adfc03
jmp 0x1adfa35
movq %rbx, %rdi
callq 0x1adfcb0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b76020
testl %eax, %eax
jns 0x1adf8a2
movq %r14, %rdi
callq 0x1adbeed
jmp 0x1adf89f
jmp 0x1adfa38
|
/External/isl/isl_ast.c
|
read_for
|
static __isl_give isl_ast_node *read_for(__isl_keep isl_stream *s)
{
isl_id *id;
isl_ast_expr *expr;
isl_ast_node *node;
char *key;
isl_bool more;
int is_value, is_init;
expr = isl_stream_read_ast_expr(s);
id = isl_ast_expr_id_get_id(expr);
isl_ast_expr_free(expr);
if (!id)
return NULL;
if (isl_stream_yaml_next(s) < 0)
id = isl_id_free(id);
node = isl_ast_node_alloc_for(id);
key = next_key(s);
if (!key)
return isl_ast_node_free(node);
is_value = !strcmp(key, "value");
is_init = !strcmp(key, "init");
free(key);
if (!is_value && !is_init)
isl_die(isl_stream_get_ctx(s), isl_error_invalid,
"unexpected key", return isl_ast_node_free(node));
if (isl_stream_yaml_next(s) < 0)
return isl_ast_node_free(node);
node = isl_ast_node_for_set_init(node, isl_stream_read_ast_expr(s));
if ((more = isl_stream_yaml_next(s)) < 0)
return isl_ast_node_free(node);
if (is_value) {
node = isl_ast_node_for_mark_degenerate(node);
if (more)
node = read_body(s, node);
return node;
}
if (eat_key(s, "cond") < 0)
return isl_ast_node_free(node);
node = isl_ast_node_for_set_cond(node, isl_stream_read_ast_expr(s));
if (isl_stream_yaml_next(s) < 0)
return isl_ast_node_free(node);
if (eat_key(s, "inc") < 0)
return isl_ast_node_free(node);
node = isl_ast_node_for_set_inc(node, isl_stream_read_ast_expr(s));
if ((more = isl_stream_yaml_next(s)) < 0)
return isl_ast_node_free(node);
if (more)
node = read_body(s, node);
return node;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1adec3a
movq %rax, %r15
movq %rax, %rdi
callq 0x1adcec8
movq %rax, %r14
movq %r15, %rdi
callq 0x1adb0f8
testq %r14, %r14
je 0x1adfbce
movq %rbx, %rdi
callq 0x1b75b8b
testl %eax, %eax
jns 0x1adfa9d
movq %r14, %rdi
callq 0x1afe3ec
movq %rax, %r14
movq %r14, %rdi
callq 0x1add6d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1ae0745
testq %rax, %rax
je 0x1adfbc6
movq %rax, %r15
leaq 0x35cea3f(%rip), %rsi # 0x50ae502
movq %rax, %rdi
callq 0x780dc0
movl %eax, %ebp
leaq 0x2031ee4(%rip), %rsi # 0x3b119b8
movq %r15, %rdi
callq 0x780dc0
movl %eax, %r12d
movq %r15, %rdi
callq 0x780910
testl %ebp, %ebp
je 0x1adfb1e
testl %r12d, %r12d
je 0x1adfb1e
movq %rbx, %rdi
callq 0x1b75ac2
leaq 0x342d010(%rip), %rdx # 0x4f0cb0f
leaq 0x342cd1c(%rip), %rcx # 0x4f0c822
movq %rax, %rdi
movl $0x5, %esi
movl $0xd41, %r8d # imm = 0xD41
callq 0x1af81bb
jmp 0x1adfbc6
movq %rbx, %rdi
callq 0x1b75b8b
testl %eax, %eax
js 0x1adfbc6
movq %rbx, %rdi
callq 0x1adec3a
movq %r14, %rdi
movq %rax, %rsi
callq 0x1adda4f
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b75b8b
testl %eax, %eax
js 0x1adfbc6
testl %ebp, %ebp
je 0x1adfbdd
leaq 0x344cb0f(%rip), %rsi # 0x4f2c66e
movq %rbx, %rdi
callq 0x1ae06e1
testl %eax, %eax
js 0x1adfbc6
movq %rbx, %rdi
callq 0x1adec3a
movq %r14, %rdi
movq %rax, %rsi
callq 0x1addb08
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b75b8b
testl %eax, %eax
js 0x1adfbc6
leaq 0x3498faf(%rip), %rsi # 0x4f78b43
movq %rbx, %rdi
callq 0x1ae06e1
testl %eax, %eax
js 0x1adfbc6
movq %rbx, %rdi
callq 0x1adec3a
movq %r14, %rdi
movq %rax, %rsi
callq 0x1addb82
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b75b8b
testl %eax, %eax
js 0x1adfbc6
jne 0x1adfbf0
jmp 0x1adfbd1
movq %r14, %rdi
callq 0x1adbeed
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
movq %r14, %rdi
callq 0x1addc94
movq %rax, %r14
testl %r15d, %r15d
je 0x1adfbd1
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1ae099f
|
/External/isl/isl_ast.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.