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();
// Cre... | 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 $0x1000000... | /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 0x2b4... | /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::Num... | 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 (%r... | /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 ... | 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
mov... | /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, 0x1... | /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... | /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 ... | 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 %x... | /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)
... | /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... | /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 && r... | 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
... | /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 ther... | 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(%rs... | /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(... | 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
m... | /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 su... | 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, %ec... | /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 ev... | 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, ... | /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 ... | /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 c... | 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
lea... | /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<bo... | 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 %x... | /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<bo... | 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 %x... | /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::B... | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %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 %ea... | /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->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
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::Ass... | 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 %... | /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... | /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>,... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x1a49e99
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /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_iterat... | 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 0x2b4... | /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), %r... | /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)
movu... | /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)
movu... | /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*>... | 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 $0... | /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->isOriginal... | 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 $-0x... | /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->getEnt... | 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,... | /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.getE... | 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 $0x... | /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 (a... | 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 (%... | /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, fals... | 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), %r... | /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... | /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::RNSuccIterato... | 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), %ea... | /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), %r... | /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 t... | 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, %r... | /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 ... | /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 $0x1... | /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 dep... | 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... | /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... | /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... | /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 %r... | /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, %... | /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::detai... | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::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::B... | 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 $... | /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(LI... | 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... | /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(LI... | 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... | /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(... | 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, %rd... | /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, ... | /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... | 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
... | /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_i... | 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 0x34... | /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);
retu... | 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
... | /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);
... | 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... | /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);
... | 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, %ea... | /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)(sp... | 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... | /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_sp... | 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... | /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_... | 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
mov... | /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->sp... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 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... | /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_... | 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 0x1... | /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... | 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 0x1b32c... | /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)(p... | 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... | /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)(sp... | 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 0x... | /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->,... | 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
m... | /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_... | 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... | /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_o... | 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 # 0x4... | /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)
... | 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,... | /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 *... | 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 0x1... | /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);
retur... | 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 0x... | /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_... | 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 0x1ac33... | /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_p... | 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(%r... | /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... | 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 %rb... | /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... | 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
pop... | /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_... | 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
mov... | /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;
... | 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... | /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 (equa... | 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 0x1b8d0... | /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);... | 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 %r... | /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_... | 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 %e... | /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;
space... | 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
c... | /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_ex... | 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,%r... | /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-... | 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... | /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;
buil... | 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... | /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 0x1... | /External/isl/isl_ast_build.c |
isl_ast_build_get_stride_constraint | __isl_give isl_set *isl_ast_build_get_stride_constraint(
__isl_keep isl_ast_build *build)
{
isl_aff *aff;
isl_set *set;
isl_val *stride;
int pos;
if (!build)
return NULL;
pos = build->depth;
if (!isl_ast_build_has_stride(build, pos))
return isl_set_universe(isl_ast_build_get_space(build, 1));
stride = ... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 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
mo... | /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;
... | 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 0x1ad799... | /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, i... | 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, ... | /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... | /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... | 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)
... | /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... | 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 %r1... | /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 ... | 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 = ... | 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
mov... | /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_yam... | 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, %... | /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.