name string | code string | asm string | file string |
|---|---|---|---|
isl_space_cmp_type | static int isl_space_cmp_type(__isl_keep isl_space *space1,
__isl_keep isl_space *space2, enum isl_dim_type type)
{
int cmp;
isl_size dim1, dim2;
isl_space *nested1, *nested2;
dim1 = isl_space_dim(space1, type);
dim2 = isl_space_dim(space2, type);
if (dim1 < 0 || dim2 < 0)
return 0;
if (dim1 != dim2)
retur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x266a997
movq %r14, %rdi
movl %ebp, %esi
callq 0x26663b7
movl %eax, %r15d
testq %rbx, %rbx
je 0x266a... | /External/isl/isl_space.c |
isl_stream_yaml_read_start_sequence | isl_stat isl_stream_yaml_read_start_sequence(__isl_keep isl_stream *s)
{
struct isl_token *tok;
int indent;
if (push_state(s, isl_yaml_sequence_start) < 0)
return isl_stat_error;
tok = isl_stream_next_token(s);
if (!tok) {
if (s->eof)
isl_stream_error(s, NULL, "unexpected EOF");
return isl_stat_error;
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x7, %esi
callq 0x266c7dc
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x266ca05
movq %r14, %rdi
xorl %esi, %esi
callq 0x266b677
testq %rax, %rax
je 0x266c99f
cmpl $0x5b, (%rax)
jne 0x266c9b9
movq %rax, %rdi
callq 0x266b347
movslq 0xa4(%r14),... | /External/isl/isl_stream.c |
isl_tab_rollback | isl_stat isl_tab_rollback(struct isl_tab *tab, struct isl_tab_undo *snap)
{
struct isl_tab_undo *undo, *next;
if (!tab)
return isl_stat_error;
tab->in_undo = 1;
for (undo = tab->top; undo && undo != &tab->bottom; undo = next) {
next = undo->next;
if (undo == snap)
break;
if (perform_undo(tab, undo) < 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x267110b
movq %rdi, %rbx
orb $0x20, 0xc8(%rdi)
movq 0x78(%rdi), %rdx
leaq 0x60(%rdi), %rbp
testq %rdx, %rdx
setne %al
cmpq %rbp, %rdx
setne %cl
andb %al, %cl
cmpb $0x1,... | /External/isl/isl_tab.c |
isl_tab_insert_div | int isl_tab_insert_div(struct isl_tab *tab, int pos, __isl_keep isl_vec *div,
isl_stat (*add_ineq)(void *user, isl_int *), void *user)
{
int r;
int nonneg;
isl_size n_div;
int o_div;
if (!tab || !div)
return -1;
if (div->size != 1 + 1 + tab->n_var)
isl_die(isl_tab_get_ctx(tab), isl_error_invalid,
"unexp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
orb %al, %cl
jne 0x26712bc
movq %rdx, %r13
movq %rdi, %r12
movl 0x18(%rdi), %eax
addl $0x2, %eax
cmpl %eax, 0x10(%rdx)
jn... | /External/isl/isl_tab.c |
isl_tab_unrestrict | int isl_tab_unrestrict(struct isl_tab *tab, int con)
{
struct isl_tab_var *var;
if (!tab)
return -1;
var = &tab->con[con];
if (!var->is_nonneg)
return 0;
var->is_nonneg = 0;
if (isl_tab_push_var(tab, isl_tab_undo_unrestrict, var) < 0)
return -1;
return 0;
} | testq %rdi, %rdi
je 0x2672a05
movq 0x40(%rdi), %rcx
movslq %esi, %rdx
movb 0x4(%rcx,%rdx,8), %sil
xorl %eax, %eax
testb $0x2, %sil
je 0x2672a04
pushq %rax
movl %esi, %eax
andb $-0x3, %al
movb %al, 0x4(%rcx,%rdx,8)
xorl %eax, %eax
testb $0x1, %sil
sete %al
movslq (%rcx,%rdx,8), %rcx
movq 0x48(%rdi,%rax,8), %rax
movl (%r... | /External/isl/isl_tab.c |
domain_map_upma | static isl_stat domain_map_upma(__isl_take isl_map *map, void *user)
{
isl_union_pw_multi_aff **res = user;
isl_multi_aff *ma;
isl_pw_multi_aff *pma;
ma = isl_multi_aff_domain_map(isl_map_get_space(map));
pma = isl_pw_multi_aff_alloc(isl_map_wrap(map), ma);
*res = isl_union_pw_multi_aff_add_pw_multi_aff(*res, pm... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2606401
movq %rax, %rdi
callq 0x25b5a4f
movq %rax, %r15
movq %r14, %rdi
callq 0x2617520
movq %rax, %rdi
movq %r15, %rsi
callq 0x25b6389
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x25b9988
movq %rax, (%rbx)
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbl %ecx, ... | /External/isl/isl_union_map.c |
identity_upma | static isl_stat identity_upma(__isl_take isl_set *set, void *user)
{
isl_union_pw_multi_aff **res = user;
isl_space *space;
isl_pw_multi_aff *pma;
space = isl_space_map_from_set(isl_set_get_space(set));
pma = isl_pw_multi_aff_identity(space);
pma = isl_pw_multi_aff_intersect_domain(pma, set);
*res = isl_union_p... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2606416
movq %rax, %rdi
callq 0x2668ff5
movq %rax, %rdi
callq 0x25b5e69
movq %rax, %rdi
movq %r14, %rsi
callq 0x25b6c02
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x25b9988
movq %rax, (%rbx)
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbl %ecx, %ecx
movl %ecx, ... | /External/isl/isl_union_map.c |
isl_union_map_domain_factor_range | __isl_give isl_union_map *isl_union_map_domain_factor_range(
__isl_take isl_union_map *umap)
{
struct isl_un_op_drop_user_data data = { &isl_map_domain_is_wrapping };
struct isl_un_op_control control = {
.filter = &un_op_filter_drop_user,
.filter_user = &data,
.fn_map = &isl_map_domain_factor_range,
};
retur... | subq $0x38, %rsp
leaq -0x6e48e(%rip), %rax # 0x26174e3
movq %rsp, %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq -0x472(%rip), %rax # 0x2685518
movq %rax, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
leaq -0x702cc(%rip), %rax # 0x26156cd
movq %rax, 0x18(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsi... | /External/isl/isl_union_map.c |
isl_union_map_range_factor_range | __isl_give isl_union_map *isl_union_map_range_factor_range(
__isl_take isl_union_map *umap)
{
struct isl_un_op_drop_user_data data = { &isl_map_range_is_wrapping };
struct isl_un_op_control control = {
.filter = &un_op_filter_drop_user,
.filter_user = &data,
.fn_map = &isl_map_range_factor_range,
};
return u... | subq $0x38, %rsp
leaq -0x6e4f5(%rip), %rax # 0x261750c
movq %rsp, %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq -0x502(%rip), %rax # 0x2685518
movq %rax, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
leaq -0x701a3(%rip), %rax # 0x2615886
movq %rax, 0x18(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsi... | /External/isl/isl_union_map.c |
isl_val_list_from_val | __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 0x2688e2b
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl $0x1, %esi
callq 0x2688313
testq %rax, %rax
je 0x2688e23
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x26883ee
movq %rbx, %rdi
callq 0x268852e
xorl %eax, %eax
popq %rbx
retq
| /External/isl/isl_list_templ.c |
isl_printer_print_val | __isl_give isl_printer *isl_printer_print_val(__isl_take isl_printer *p,
__isl_keep isl_val *v)
{
int neg;
if (!p || !v)
return isl_printer_free(p);
neg = isl_int_is_neg(v->n);
if (neg) {
p = isl_printer_print_str(p, "-");
isl_int_neg(v->n, v->n);
}
if (isl_int_is_zero(v->d)) {
int sgn = isl_int_sgn(v-... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
je 0x268900f
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
testb $0x1, %dil
jne 0x2689021
callq 0x26920f1
movl %eax, %ebp
jmp 0x2689035
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
... | /External/isl/isl_val.c |
isl_val_pow2 | __isl_give isl_val *isl_val_pow2(__isl_take isl_val *v)
{
unsigned long exp;
int neg;
v = isl_val_cow(v);
if (!v)
return NULL;
if (!isl_val_is_int(v))
isl_die(isl_val_get_ctx(v), isl_error_invalid,
"can only compute integer powers",
return isl_val_free(v));
neg = isl_val_is_neg(v);
if (neg)
isl_int_... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x268a30f
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x268a311
decl %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x26898a3
movq %rax, %rbx
jmp 0x268a311
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x268a3f4
movq %rbx, %rdi
callq 0x268969c
test... | /External/isl/isl_val.c |
isl_basic_set_coefficients | __isl_give isl_basic_set *isl_basic_set_coefficients(
__isl_take isl_basic_set *bset)
{
isl_space *space;
if (!bset)
return NULL;
if (bset->n_div)
isl_die(bset->ctx, isl_error_invalid,
"input set not allowed to have local variables",
goto error);
space = isl_basic_set_get_space(bset);
space = isl_spac... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x269b875
movq %rdi, %r14
cmpl $0x0, 0x40(%rdi)
je 0x269b87d
movq 0x8(%r14), %rdi
leaq 0x298f2fa(%rip), %rdx # 0x502ab50
leaq 0x298f321(%rip), %rcx # 0x502ab7e
movl $0x5, %esi
movl $0x351, %r8d # imm = 0x351
callq 0x25eea52
movq %r14, %rdi
callq 0x2607... | /External/isl/isl_farkas.c |
isl_basic_set_coefficients_product | static __isl_give isl_basic_set *isl_basic_set_coefficients_product(
__isl_take isl_factorizer *f)
{
struct isl_coefficients_product_data data;
isl_ctx *ctx;
isl_basic_set *coeff;
isl_bool every;
ctx = isl_factorizer_get_ctx(f);
if (isl_coefficients_product_data_init(ctx, &data, f->n_group) < 0)
f = isl_facto... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x269ad5a
movq %rax, %r15
movslq 0x10(%rbx), %rsi
movl %esi, 0x8(%rsp)
movq $0x0, 0xc(%rsp)
movl $0x20, %edx
movq %rax, %rdi
callq 0x25eeb2d
movq %rax, 0x18(%rsp)
testq %rax, %rax
jne 0x269c382
movq %rbx, %rdi
callq... | /External/isl/isl_farkas.c |
isl_pw_qpolynomial_fold_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 0x269ce56
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl %edx, %r15d
addl %esi, %r15d
jb 0x269ce2c
cmpl 0x10(%rbx), %r15d
ja 0x269ce2c
testl %ebp, %ebp
je 0x269ce58
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x269cdd5
decl... | /External/isl/isl_list_templ.c |
isl_pw_qpolynomial_fold_list_take_pw_qpolynomial_fold | static __isl_give EL *FN(FN(LIST(EL),take),EL_BASE)(__isl_keep LIST(EL) *list,
int index)
{
EL *el;
if (FN(LIST(EL),check_index)(list, index) < 0)
return NULL;
if (list->ref != 1)
return FN(FN(LIST(EL),get),EL_BASE)(list, index);
el = list->p[index];
list->p[index] = NULL;
return el;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x269cfde
testl %eax, %eax
js 0x269d1cd
cmpl $0x1, (%rbx)
jne 0x269d1aa
movslq %ebp, %rcx
movq 0x20(%rbx,%rcx,8), %rax
movq $0x0, 0x20(%rbx,%rcx,8)
jmp 0x269d1cf
movq %rbx, %rdi
movl %ebp, %esi
callq 0x269cfde
testl %eax, %eax
js 0x269d1c2
movslq %e... | /External/isl/isl_list_templ.c |
isl_pw_qpolynomial_fold_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 0x269e7eb
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x269e7ed
decl %eax
movl %eax, (%rdi)
jmp 0x269e751
xorl %edi, %edi
movq %rdi, %rax
retq
| /External/isl/isl_pw_templ.c |
isl_union_pw_qpolynomial_fold_coalesce_entry | static isl_stat FN(UNION,coalesce_entry)(void **entry, void *user)
{
PART **part_p = (PART **) entry;
PART *part;
part = FN(PART,copy)(*part_p);
part = FN(PW,coalesce)(part);
if (!part)
return isl_stat_error;
FN(PART,free)(*part_p);
*part_p = part;
return isl_stat_ok;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x26a271b
incl (%rdi)
jmp 0x26a271d
xorl %edi, %edi
callq 0x269f0e7
testq %rax, %rax
je 0x26a2739
movq %rax, %r14
movq (%rbx), %rdi
callq 0x269ccdb
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x26a273e
movl $0xffffffff, %eax # imm = ... | /External/isl/isl_union_templ.c |
isl_printer_print_map_to_basic_set | __isl_give isl_printer *ISL_FN(isl_printer_print,ISL_HMAP_SUFFIX)(
__isl_take isl_printer *p, __isl_keep ISL_HMAP *hmap)
{
ISL_S(print_data) data;
if (!p || !hmap)
return isl_printer_free(p);
p = isl_printer_print_str(p, "{");
data.p = p;
data.first = 1;
if (ISL_FN(ISL_HMAP,foreach)(hmap, &print_pair, &data)... | testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
je 0x26472d2
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0x2125a00(%rip), %rsi # 0x47cc3c1
callq 0x26475d8
movq %rsp, %rdx
movq %rax, (%rdx)
movl $0x1, 0x8(%rdx)
leaq 0x4a(%rip), %rax # 0x26a6a24
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
m... | /External/isl/include/isl/hmap_templ.c |
isl_schedule_band_member_get_coincident | isl_bool isl_schedule_band_member_get_coincident(
__isl_keep isl_schedule_band *band, int pos)
{
if (!band)
return isl_bool_error;
if (pos < 0 || pos >= band->n)
isl_die(isl_schedule_band_get_ctx(band), isl_error_invalid,
"invalid member position", return isl_bool_error);
return isl_bool_ok(band->coinciden... | testq %rdi, %rdi
je 0x26a7048
testl %esi, %esi
js 0x26a7019
cmpl %esi, 0x4(%rdi)
jle 0x26a7019
movq 0x8(%rdi), %rax
movl %esi, %ecx
movl (%rax,%rcx,4), %edi
jmp 0x25ee9b4
pushq %rax
movq 0x18(%rdi), %rdi
callq 0x25c2ed6
leaq 0x2983e2a(%rip), %rdx # 0x502ae54
leaq 0x2983e3b(%rip), %rcx # 0x502ae6c
movq %rax, %rdi
mo... | /External/isl/isl_schedule_band.c |
add_loop_types | static __isl_give isl_union_set *add_loop_types(
__isl_take isl_union_set *options, int n, enum isl_ast_loop_type *type,
int isolate)
{
int i;
if (!type)
return options;
if (!options)
return NULL;
for (i = 0; i < n; ++i) {
int first;
isl_space *space;
isl_set *option;
if (type[i] == isl_ast_loop_de... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movq %rdi, %r15
testq %rdx, %rdx
je 0x26a757b
testq %r15, %r15
je 0x26a7578
testl %esi, %esi
jle 0x26a757b
movq %rdx, %r14
movl %esi, %ebp
xorl %ebx, %ebx
movl %esi, (%rsp)
movslq %ebx, %rax
cmpl $0x0, (%r14,%rax,4)
je 0x2... | /External/isl/isl_schedule_band.c |
getBinOpsForFactorization(llvm::Instruction::BinaryOps, llvm::BinaryOperator*, llvm::Value*&, llvm::Value*&, llvm::BinaryOperator*) | static Instruction::BinaryOps
getBinOpsForFactorization(Instruction::BinaryOps TopOpcode, BinaryOperator *Op,
Value *&LHS, Value *&RHS, BinaryOperator *OtherOp) {
assert(Op && "Expected a binary operator");
LHS = Op->getOperand(0);
RHS = Op->getOperand(1);
if (TopOpcode == Instruction:... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rsi, %rbx
movl %edi, %ebp
movq -0x40(%rsi), %rax
movq %rax, (%rdx)
movq -0x20(%rsi), %rax
movq %rax, (%rcx)
movl %edi, %eax
andl $-0x3, %eax
cmpl $0xd, %eax
jne 0x26ae403
movq %rcx, %r14
leaq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rdi
movq %ra... | /Transforms/InstCombine/InstructionCombining.cpp |
llvm::SmallPtrSetImpl<llvm::User const*>::insert(llvm::User const*) | std::pair<iterator, bool> insert(PtrType Ptr) {
auto p = insert_imp(PtrTraits::getAsVoidPointer(Ptr));
return std::make_pair(makeIterator(p.first), p.second);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x8efa2e
movq 0x8(%r14), %rcx
xorl %esi, %esi
cmpq (%r14), %rcx
sete %sil
movl 0x10(%r14,%rsi,4), %esi
leaq (%rcx,%rsi,8), %rcx
cmpq %rax, %rcx
je 0x26bce57
cmpq $-0x2, (%rax)
jb 0x26bce57
addq $0x8, %rax
cmpq %rcx, %... | /llvm/ADT/SmallPtrSet.h |
bool llvm::PatternMatch::BinOpPred_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::specific_intval64<false>, llvm::PatternMatch::is_right_shift_op, false>::match<llvm::Value>(llvm::Value*) | bool isValue(const APInt &C) { return C.isMaxSignedValue(); } | pushq %rbx
movb (%rsi), %bl
xorl %eax, %eax
cmpb $0x1d, %bl
cmovaeq %rsi, %rax
jb 0x26bdf5e
movzbl (%rax), %ecx
addl $-0x1d, %ecx
andl $-0x2, %ecx
cmpl $0x1a, %ecx
jne 0x26bdf5c
movl 0x4(%rax), %ecx
btl $0x1e, %ecx
jb 0x26bdf22
shll $0x5, %ecx
movq %rax, %rdx
subq %rcx, %rdx
jmp 0x26bdf26
movq -0x8(%rax), %rdx
movq (%r... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::apint_match, 19u, false>::match<llvm::Value>(llvm::Value*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x30, (%rsi)
jne 0x26cba31
movq -0x40(%rsi), %rax
testq %rax, %rax
je 0x26cba31
pushq %rax
movq (%rdi), %rcx
movq %rax, (%rcx)
addq $0x8, %rdi
movq -0x20(%rsi), %rsi
callq 0xc5e5f2
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
leaq 0x8(%rsp), %rsp
jne 0x26cba33
xorl %eax, %eax
retq
| /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Constant>, llvm::PatternMatch::match_combine_or<llvm::PatternMatch::CastInst_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::ZExtInst>, llvm::PatternMatch::bind_ty<llvm::Value>>, 15u, false>::match<llvm::Instruction>(llvm::Instruction*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x2c, (%rsi)
jne 0x26cdefe
movq -0x40(%rsi), %rax
cmpb $0x15, (%rax)
ja 0x26cdefe
movq (%rdi), %rcx
movq %rax, (%rcx)
movq -0x20(%rsi), %rcx
movb (%rcx), %al
cmpb $0x44, %al
jne 0x26cdee9
movq -0x20(%rcx), %rsi
testq %rsi, %rsi
setne %dl
je 0x26cdee9
movq 0x8(%rdi), %rdx
movq %rsi, (%rdx)
movb $0x1, %dl
cmpb $0x4... | /llvm/IR/PatternMatch.h |
llvm::InstCombinerImpl::getSelectCondition(llvm::Value*, llvm::Value*, bool) | Value *InstCombinerImpl::getSelectCondition(Value *A, Value *B,
bool ABIsTheSame) {
// We may have peeked through bitcasts in the caller.
// Exit immediately if we don't have (vector) integer types.
Type *Ty = A->getType();
if (!Ty->isIntOrIntVectorTy() || !B->getType... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movl $0xfe, %ecx
andl 0x8(%r15), %ecx
movq %r15, %rax
cmpl $0x12, %ecx
jne 0x26d9917
movq 0x10(%r15), %rax
movq (%rax), %rax
cmpb $0xd, 0x8(%rax)
jne 0x... | /Transforms/InstCombine/InstCombineAndOrXor.cpp |
foldNotXor(llvm::BinaryOperator&, llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>&) | static Instruction *foldNotXor(BinaryOperator &I,
InstCombiner::BuilderTy &Builder) {
Value *X, *Y;
// FIXME: one-use check is not needed in general, but currently we are unable
// to fold 'not' into 'icmp', if that 'icmp' has multiple uses. (D35182)
if (!match(&I, m_Not(m_OneUse(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x10(%rsp), %rdi
movq $0x0, (%rdi)
leaq 0x8(%rsp), %rax
movq %rax, 0x8(%rdi)
movq %rsp, %rax
movq %rax, 0x10(%rdi)
callq 0x26e4fb8
testb %al, %al
je 0x26dfb60
movq 0x8(%rsp), %r14
movb (%r14), %al
cmpb $0x39, %al
jne 0x26d... | /Transforms/InstCombine/InstCombineAndOrXor.cpp |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_all_ones, llvm::ConstantInt, true>, llvm::PatternMatch::SpecificBinaryOp_match<llvm::PatternMatch::SpecificBinaryOp_match<llvm::PatternMatch::specificval_ty, llvm::PatternMatch::specificval_ty, true>, llvm::PatternMatch::s... | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | pushq %r15
pushq %r14
pushq %rbx
cmpb $0x3b, (%rsi)
jne 0x26e263f
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %r15
movq %r15, %rsi
callq 0xa2e936
movq (%rbx), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x26e25eb
movq %r15, (%rcx)
testb %al, %al
je 0x26e2604
leaq 0x8(%rbx), %rdi
movq -0x20(%r... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::CmpClass_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_any_zero_fp, llvm::ConstantFP, true>, llvm::FCmpInst, llvm::CmpInst::Predicate, false>::match<llvm::Value>(llvm::Value*) | bool match(OpTy *V) {
if (auto *I = dyn_cast<Class>(V)) {
if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
if (Predicate)
*Predicate = I->getPredicate();
return true;
} else if (Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0))) ... | cmpb $0x53, (%rsi)
jne 0x26e27c5
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq -0x40(%rsi), %rax
testq %rax, %rax
je 0x26e27c8
movq %rdi, %r14
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
addq $0x10, %rdi
movq -0x20(%rbx), %r15
movq %r15, %rsi
callq 0xbed4da
movq 0x10(%r14), %rcx
testq %rcx, %rcx
setne %dl
andb %al, ... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_zero_int, llvm::ConstantInt, true>, llvm::PatternMatch::CastInst_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::specificval_ty, llvm::PatternMatch::specific_intval64<false>, 28u, false>, llvm::ZExtInst>, 15u,... | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x2c, (%rsi)
jne 0x26e2a25
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %r15
movq %r15, %rsi
callq 0x9032d2
movq (%rbx), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x26e2a01
movq %r15, (%rcx)
testb %al, %al
je 0x26e2a1d
addq $0x8, %rbx
movq -0x20(%r14), ... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::DisjointOr_match<llvm::PatternMatch::deferredval_ty<llvm::Value>, llvm::PatternMatch::match_combine_and<llvm::PatternMatch::bind_ty<llvm::Constant>, llvm::PatternMatch::match_unless<llvm::PatternMatch::constantexpr_match>>, false>::match<llvm::Value>(llvm::Value*) | bool isValue(const APInt &C) { return C.isMaxSignedValue(); } | pushq %rbx
movb (%rsi), %bl
xorl %eax, %eax
cmpb $0x3a, %bl
cmoveq %rsi, %rax
jne 0x26e59b9
testb $0x2, 0x1(%rax)
je 0x26e59b7
movq (%rdi), %rcx
movq (%rcx), %rcx
cmpq -0x40(%rax), %rcx
jne 0x26e59b7
movq -0x20(%rax), %rax
movb (%rax), %cl
cmpb $0x15, %cl
ja 0x26e59b7
movq 0x8(%rdi), %rdx
movq %rax, (%rdx)
cmpb $0x5, %... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::OneUse_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::match_combine_or<llvm::PatternMatch::CastInst_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::ZExtInst>, llvm::PatternMatch::bind_ty<llvm::Value>>, llvm::PatternMatch::cstval_pred_ty<llv... | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x39, (%rsi)
jne 0x26e6859
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %rsi
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x26e6822
cmpq $0x0, 0x8(%rax)
jne 0x26e6822
movq %rbx, %rdi
callq 0x26e6866
testb %al, %al
je 0x26e6822
movq -0x20(%r14), %rcx
testq %rcx, %rcx
jne 0x26e684... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_all_ones, llvm::ConstantInt, true>, llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::bind_ty<llvm::Value>, 29u, false>, 30u, true>::match<llvm::Value>(llvm::Value*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x3b, (%rsi)
jne 0x26e6d50
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %r15
movq %r15, %rsi
callq 0xa2e936
movq (%rbx), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x26e6cd7
movq %r15, (%rcx)
testb %al, %al
je 0x26e6cfd
movq -0x20(%r14), %rax
cmpb $0x3a,... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::match_combine_and<llvm::PatternMatch::ExtractValue_match<1, llvm::PatternMatch::bind_ty<llvm::Value>>, llvm::PatternMatch::bind_ty<llvm::Value>>, llvm::PatternMatch::match_combine_and<llvm::PatternMatch::CmpClass_match<llvm::PatternMatch::match_combine_and<llv... | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x3a, (%rsi)
jne 0x26e7093
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %rsi
callq 0x26e709e
testb %al, %al
je 0x26e705a
leaq 0x10(%rbx), %rdi
movq -0x20(%r14), %r15
movq %r15, %rsi
callq 0x26e70e4
testq %r15, %r15
je 0x26e705a
testb %al, %al
jne 0x26e7088
movq -0x20(%r14), %... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::LogicalOp_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_all_ones, llvm::ConstantInt, true>, llvm::PatternMatch::bind_ty<llvm::Value>, 30u, true>, llvm::PatternMatch::bind_ty<llvm::Value>, 29u, false>::match<llvm::Value>(llvm::Value*) | inline specific_bbval m_SpecificBB(BasicBlock *BB) {
return specific_bbval(BB);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1d, (%rsi)
jb 0x26e773d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
movl $0xfe, %eax
andl 0x8(%rdi), %eax
cmpl $0x12, %eax
jne 0x26e7706
movq 0x10(%rdi), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x1a89852
testb %al, %al
je 0x26e773d
movzbl (%r1... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_negative, llvm::ConstantInt, true>::match_impl<llvm::Constant>(llvm::Constant*) | bool match_impl(ITy *V) {
if (const auto *CV = dyn_cast<ConstantVal>(V))
return this->isValue(CV->getValue());
if (const auto *VTy = dyn_cast<VectorType>(V->getType())) {
if (const auto *C = dyn_cast<Constant>(V)) {
if (const auto *CV = dyn_cast_or_null<ConstantVal>(C->getSplatValue()))
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movb (%rsi), %al
cmpb $0x11, %al
jne 0x26e7947
movl 0x20(%rbx), %ecx
leal -0x1(%rcx), %edx
movl %edx, %esi
shrl $0x3, %esi
andl $-0x8, %esi
addq 0x18(%rbx), %rsi
leaq 0x18(%rbx), %rdi
cmpl $0x41, %ecx
cmovbq %rdi, %rsi
movq (%rsi), %rcx
btq %rdx, %r... | /llvm/IR/PatternMatch.h |
foldCttzCtlz(llvm::IntrinsicInst&, llvm::InstCombinerImpl&) | static Instruction *foldCttzCtlz(IntrinsicInst &II, InstCombinerImpl &IC) {
assert((II.getIntrinsicID() == Intrinsic::cttz ||
II.getIntrinsicID() == Intrinsic::ctlz) &&
"Expected cttz or ctlz intrinsic");
bool IsTZ = II.getIntrinsicID() == Intrinsic::cttz;
Value *Op0 = II.getArgOperand(0);
Va... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r13
movq %rdi, %rbx
movq -0x20(%rdi), %rax
movl 0x24(%rax), %ebp
movl 0x4(%rdi), %eax
shll $0x5, %eax
movq %rdi, %rcx
subq %rax, %rcx
movq (%rcx), %r15
movq 0x20(%rcx), %r12
leaq 0x50(%rsp), %rdi
movl $0xd, (%rdi)
movl $0x0, ... | /Transforms/InstCombine/InstCombineCalls.cpp |
bool llvm::PatternMatch::MaxMin_match<llvm::ICmpInst, llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::match_combine_and<llvm::PatternMatch::bind_ty<llvm::Constant>, llvm::PatternMatch::match_unless<llvm::PatternMatch::constantexpr_match>>, llvm::PatternMatch::umin_pred_ty, false>::match<llvm::Value>(llvm:... | bool match(OpTy *V) {
if (auto *II = dyn_cast<IntrinsicInst>(V)) {
Intrinsic::ID IID = II->getIntrinsicID();
if ((IID == Intrinsic::smax && Pred_t::match(ICmpInst::ICMP_SGT)) ||
(IID == Intrinsic::smin && Pred_t::match(ICmpInst::ICMP_SLT)) ||
(IID == Intrinsic::umax && Pred_t::match(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x55, (%rsi)
jne 0x26f7d1e
movq %r14, %rdi
callq 0x8f16ea
xorl %ecx, %ecx
testb %al, %al
cmovneq %r14, %rcx
jmp 0x26f7d20
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x26f7d73
movq -0x20(%rcx), %rax
cmpl $0x162, 0x24(%rax) # imm =... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_zero_int, llvm::ConstantInt, true>, llvm::PatternMatch::deferredval_ty<llvm::Value>, 15u, false>, 29u, true>::match<llvm::Value>(llvm::Value*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | pushq %r14
pushq %rbx
pushq %rax
cmpb $0x3a, (%rsi)
jne 0x26f8293
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %rax
testq %rax, %rax
je 0x26f826d
movq (%rbx), %rcx
movq %rax, (%rcx)
leaq 0x8(%rbx), %rdi
movq -0x20(%r14), %rsi
callq 0x26ce962
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x26f8295
movq -0x20(%r... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::MaxMin_match<llvm::ICmpInst, llvm::PatternMatch::bind_ty<llvm::Instruction>, llvm::PatternMatch::apint_match, llvm::PatternMatch::smin_pred_ty, false>::match<llvm::IntrinsicInst>(llvm::IntrinsicInst*) | bool match(OpTy *V) {
if (auto *II = dyn_cast<IntrinsicInst>(V)) {
Intrinsic::ID IID = II->getIntrinsicID();
if ((IID == Intrinsic::smax && Pred_t::match(ICmpInst::ICMP_SGT)) ||
(IID == Intrinsic::smin && Pred_t::match(ICmpInst::ICMP_SLT)) ||
(IID == Intrinsic::umax && Pred_t::match(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x26f854d
movq -0x20(%r14), %rax
cmpl $0x13f, 0x24(%rax) # imm = 0x13F
setne %bpl
jne 0x26f8550
movl 0x4(%r14), %ecx
shll $0x5, %ecx
movq %r14, %rax
subq %rcx, %rax
movq (%rax), %rcx
cmpb $0x1d, (%rcx)
jb 0x2... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::ElementWiseBitCast_match<llvm::PatternMatch::class_match<llvm::Value>>::match<llvm::CastInst>(llvm::CastInst*) | static bool classof(const Instruction *I) {
return I->getOpcode() == BitCast;
} | cmpb $0x4e, (%rsi)
jne 0x2701d75
movq -0x20(%rsi), %rax
movq 0x8(%rsi), %rcx
movq 0x8(%rax), %rax
movl $0xfe, %edi
movl 0x8(%rax), %esi
andl %edi, %esi
cmpl $0x12, %esi
sete %r8b
movl 0x8(%rcx), %edx
andl %edx, %edi
cmpl $0x12, %edi
sete %dil
xorb %r8b, %dil
je 0x2701d78
xorl %eax, %eax
retq
cmpl $0x12, %esi
setne %sil... | /llvm/IR/Instructions.h |
llvm::InstCombinerImpl::foldICmpWithTrunc(llvm::ICmpInst&) | Instruction *InstCombinerImpl::foldICmpWithTrunc(ICmpInst &ICmp) {
ICmpInst::Predicate Pred = ICmp.getPredicate();
Value *Op0 = ICmp.getOperand(0), *Op1 = ICmp.getOperand(1);
// Try to canonicalize trunc + compare-to-constant into a mask + cmp.
// The trunc masks high bits while the compare may effectively mas... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movzwl 0x2(%rsi), %eax
andl $0x3f, %eax
movl %eax, 0x24(%rsp)
movq -0x40(%rsi), %r15
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x271b04d
cmpq $0x0, 0x8(%rax)
jne 0x271b04d
movq %rsi, %r14
movq %rdi, %rbx
movb (%r15), %al
cmpb $0x43, %al
... | /Transforms/InstCombine/InstCombineCompares.cpp |
bool llvm::PatternMatch::match_combine_or<llvm::PatternMatch::match_combine_or<llvm::PatternMatch::MaxMin_match<llvm::ICmpInst, llvm::PatternMatch::class_match<llvm::Value>, llvm::PatternMatch::class_match<llvm::Value>, llvm::PatternMatch::smax_pred_ty, false>, llvm::PatternMatch::MaxMin_match<llvm::ICmpInst, llvm::Pat... | bool match(ITy *V) {
if (L.match(V))
return true;
if (R.match(V))
return true;
return false;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2723e64
testb %al, %al
jne 0x2723e43
leaq 0x2(%r14), %rdi
movq %rbx, %rsi
callq 0x2723ef2
testb %al, %al
jne 0x2723e43
leaq 0x4(%r14), %rdi
movq %rbx, %rsi
callq 0x2723f80
testb %al, %al
je 0x2723e4d
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::match_combine_and<llvm::PatternMatch::match_combine_and<llvm::PatternMatch::match_combine_and<llvm::PatternMatch::IntrinsicID_match, llvm::PatternMatch::Argument_match<llvm::PatternMatch::deferredval_ty<llvm::Value>>>, llvm::PatternMatch::Argument_match<llvm::PatternMatch::deferredval_ty<llvm::... | bool match(ITy *V) {
if (L.match(V))
if (R.match(V))
return true;
return false;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x26cf8ac
testb %al, %al
je 0x272638b
movb (%r14), %al
cmpb $0x55, %al
jne 0x2726380
movl 0x28(%rbx), %ecx
movl 0x4(%r14), %edx
shll $0x5, %edx
subq %rdx, %r14
shlq $0x5, %rcx
movq (%r14,%rcx), %rdx
testq %rdx, %rdx
setne %cl
je 0x2726380
movq 0x30(... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::CmpClass_match<llvm::PatternMatch::OneUse_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::match_combine_or<llvm::PatternMatch::match_combine_or<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch:... | bool match(OpTy *V) {
if (auto *I = dyn_cast<Class>(V)) {
if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
if (Predicate)
*Predicate = I->getPredicate();
return true;
} else if (Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0))) ... | testq %rsi, %rsi
je 0x27266dc
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq -0x40(%rsi), %rsi
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x27266d2
cmpq $0x0, 0x8(%rax)
jne 0x27266d2
movq %rdi, %r14
addq $0x8, %rdi
callq 0x272657e
testb %al, %al
je 0x27266d2
leaq 0x40(%r14), %rdi
movq -0x20(%rbx), %rsi
callq 0x90... | /llvm/IR/PatternMatch.h |
(anonymous namespace)::PointerReplacer::replacePointer(llvm::Value*) | void PointerReplacer::replacePointer(Value *V) {
#ifndef NDEBUG
auto *PT = cast<PointerType>(Root.getType());
auto *NT = cast<PointerType>(V->getType());
assert(PT != NT && "Invalid usage");
#endif
WorkMap[&Root] = V;
for (Instruction *Workitem : Worklist)
replace(Workitem);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
addq $0x168, %rdi # imm = 0x168
movq 0x198(%rbx), %rax
leaq 0x58(%rsp), %rsi
movq %rax, (%rsi)
movq %rdi, 0x38(%rsp)
callq 0x25547c2
movq %r15, (%rax)
movl 0x140(%rbx), %eax
testq %rax, %rax
je ... | /Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp |
llvm::InstCombinerImpl::visitSRem(llvm::BinaryOperator&) | Instruction *InstCombinerImpl::visitSRem(BinaryOperator &I) {
if (Value *V = simplifySRemInst(I.getOperand(0), I.getOperand(1),
SQ.getWithInstruction(&I)))
return replaceInstUsesWith(I, V);
if (Instruction *X = foldVectorBinop(I))
return X;
// Handle the integer rem com... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq -0x40(%rsi), %rdi
movq -0x20(%rsi), %rsi
movups 0x58(%r14), %xmm0
movups 0x68(%r14), %xmm1
movups 0x78(%r14), %xmm2
movups 0x88(%r14), %xmm3
leaq 0x60(%rsp), %rdx
movaps %xmm2, 0x20(%rdx)
movaps %xmm3... | /Transforms/InstCombine/InstCombineMulDivRem.cpp |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::match_combine_and<llvm::PatternMatch::bind_ty<llvm::Constant>, llvm::PatternMatch::match_unless<llvm::PatternMatch::constantexpr_match>>, 25u, false>::match<llvm::Value>(llvm::Value*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x36, (%rsi)
jne 0x2734e03
movq -0x40(%rsi), %rax
testq %rax, %rax
je 0x2734e03
movq (%rdi), %rcx
movq %rax, (%rcx)
movq -0x20(%rsi), %rax
movb (%rax), %cl
cmpb $0x15, %cl
ja 0x2734e03
movq 0x8(%rdi), %rdx
movq %rax, (%rdx)
cmpb $0x5, %cl
je 0x2734e03
pushq %rax
movq %rax, %rdi
callq 0x19d1652
movl %eax, %ecx
mov... | /llvm/IR/PatternMatch.h |
bool llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Value*, llvm::Value*, 4u, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::Value*>>, llvm::Value*, llvm::Value*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::Value*>>::LookupBucketFor<llvm::... | 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 0x2738a81
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 |
isSafeAndProfitableToSinkLoad(llvm::LoadInst*) | static bool isSafeAndProfitableToSinkLoad(LoadInst *L) {
BasicBlock::iterator BBI = L->getIterator(), E = L->getParent()->end();
for (++BBI; BBI != E; ++BBI)
if (BBI->mayWriteToMemory()) {
// Calls that only access inaccessible memory do not block sinking the
// load.
if (auto *CB = dyn_cast<... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r12
addq $0x30, %r12
cmpq %r12, %r15
je 0x273ac9d
movabsq $0x8000000000041, %r13 # imm = 0x8000000000041
leaq -0x18(%r15), %r14
testq %r15, %r15
cmoveq %r15, %r14
movq %r14, %rdi
callq 0x1a40d60
testb %al, %a... | /Transforms/InstCombine/InstCombinePHI.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, llvm::Value*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*>>, llvm::BasicBlock*, llvm::Value*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*>>::clear(... | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x273c079
cmpl $0x0, 0xc(%rdi)
je 0x273c152
shll $0x2, %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
setae %al
cmpl $0x41, %ecx
setb %dl
orb %al, %dl
je 0x273ebac
testq %rcx, %rcx
je 0x273c14a
movq (%rdi), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, ... | /llvm/ADT/DenseMap.h |
llvm::InstCombinerImpl::visitPHINode(llvm::PHINode&) | Instruction *InstCombinerImpl::visitPHINode(PHINode &PN) {
if (Value *V = simplifyInstruction(&PN, SQ.getWithInstruction(&PN)))
return replaceInstUsesWith(PN, V);
if (Instruction *Result = foldPHIArgZextsIntoPHI(PN))
return Result;
if (Instruction *Result = foldPHIArgIntToPtrToPHI(PN))
return Result... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rsi, %rbx
movq %rdi, %r14
movups 0x58(%rdi), %xmm0
movups 0x68(%rdi), %xmm1
movups 0x78(%rdi), %xmm2
movups 0x88(%rdi), %xmm3
leaq 0x90(%rsp), %rsi
movaps %xmm2, 0x20(%rsi)
movaps %xmm3, 0x30(%rsi)
movaps ... | /Transforms/InstCombine/InstCombinePHI.cpp |
PHIsEqualValue(llvm::PHINode*, llvm::Value*&, llvm::SmallPtrSetImpl<llvm::PHINode*>&) | static bool PHIsEqualValue(PHINode *PN, Value *&NonPhiInVal,
SmallPtrSetImpl<PHINode *> &ValueEqualPHIs) {
// See if we already saw this PHI node.
if (!ValueEqualPHIs.insert(PN).second)
return true;
// Don't scan crazily complex things.
if (ValueEqualPHIs.size() == 16)
return... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq 0xc3925e
movb $0x1, %bpl
cmpb $0x1, 0x10(%r12)
jne 0x273cd19
movl 0x14(%rbx), %eax
subl 0x18(%rbx), %eax
cmpl $0x10, %e... | /Transforms/InstCombine/InstCombinePHI.cpp |
simplifyUsingControlFlow(llvm::InstCombiner&, llvm::PHINode&, llvm::DominatorTree const&) | static Value *simplifyUsingControlFlow(InstCombiner &Self, PHINode &PN,
const DominatorTree &DT) {
// Simplify the following patterns:
// if (cond)
// / \
// ... ...
// \ /
// phi [true] [false]
// and
// switch (co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0x903b1e
movq %rdx, %rcx
subq %rax, %rcx
movq %rcx, %rsi
sarq $0x7, %rsi
testq %rsi, %rsi
jle 0x273ce39
andq $-0x80, %rcx
addq %rax, %rcx
inc... | /Transforms/InstCombine/InstCombinePHI.cpp |
foldSelectWithFCmpToFabs(llvm::SelectInst&, llvm::InstCombinerImpl&) | static Instruction *foldSelectWithFCmpToFabs(SelectInst &SI,
InstCombinerImpl &IC) {
Value *CondVal = SI.getCondition();
bool ChangedFMF = false;
for (bool Swap : {false, true}) {
Value *TrueVal = SI.getTrueValue();
Value *X = SI.getFalseValue();
CmpInst::... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, %rbp
movq -0x60(%rdi), %rax
movq %rax, 0x68(%rsp)
movw $0x100, 0x20(%rsp) # imm = 0x100
movq $0x0, 0x70(%rsp)
movq $0x0, 0x60(%rsp)
xorl %r15d, %r15d
movq %rdi, 0x10(%rsp)
movb 0x20(%rsp,%r15), %bl
m... | /Transforms/InstCombine/InstCombineSelect.cpp |
foldSelectCmpBitcasts(llvm::SelectInst&, llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>&) | static Instruction *foldSelectCmpBitcasts(SelectInst &Sel,
InstCombiner::BuilderTy &Builder) {
Value *Cond = Sel.getCondition();
Value *TVal = Sel.getTrueValue();
Value *FVal = Sel.getFalseValue();
CmpInst::Predicate Pred;
Value *A, *B;
if (!match(Cond, m_Cmp(Pred,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq -0x60(%rdi), %r14
movq -0x40(%rdi), %r13
movq -0x20(%rdi), %r12
leaq 0x34(%rsp), %rax
leaq 0x38(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x8(%rsp), %rax
movq %rax, 0x8(%rdi)
movq %rsp, %rax
movq %rax, 0x10(... | /Transforms/InstCombine/InstCombineSelect.cpp |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_all_ones, llvm::ConstantInt, false>, llvm::PatternMatch::SpecificBinaryOp_match<llvm::PatternMatch::specificval_ty, llvm::PatternMatch::specificval_ty, true>, 30u, true>::match<llvm::Value>(llvm::Value*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | pushq %r15
pushq %r14
pushq %rbx
cmpb $0x3b, (%rsi)
jne 0x274bd47
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %r15
movq %r15, %rsi
callq 0x274bd50
movq (%rbx), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x274bcf3
movq %r15, (%rcx)
testb %al, %al
je 0x274bd0c
leaq 0x8(%rbx), %rdi
movq -0x20(%... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::CmpClass_match<llvm::PatternMatch::ElementWiseBitCast_match<llvm::PatternMatch::specificval_ty>, llvm::PatternMatch::apint_match, llvm::ICmpInst, llvm::CmpInst::Predicate, false>::match<llvm::Value>(llvm::Value*) | bool match(OpTy *V) {
if (auto *I = dyn_cast<Class>(V)) {
if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
if (Predicate)
*Predicate = I->getPredicate();
return true;
} else if (Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0))) ... | cmpb $0x52, (%rsi)
jne 0x274c472
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movq -0x40(%rsi), %rsi
callq 0x274c480
testb %al, %al
je 0x274c475
leaq 0x10(%r14), %rdi
movq -0x20(%rbx), %rsi
callq 0xc5e5f2
testb %al, %al
je 0x274c475
movq (%r14), %rcx
movb $0x1, %al
testq %rcx, %rcx
j... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::OneUse_match<llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::specificval_ty, llvm::PatternMatch::apint_match, 29u, false>>::match<llvm::Value>(llvm::Value*) | const_use_iterator materialized_use_begin() const {
return const_use_iterator(UseList);
} | movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x274cd21
cmpq $0x0, 0x8(%rax)
jne 0x274cd21
cmpb $0x3a, (%rsi)
jne 0x274cd21
movq (%rdi), %rax
cmpq -0x40(%rsi), %rax
jne 0x274cd21
pushq %rax
addq $0x8, %rdi
movq -0x20(%rsi), %rsi
callq 0xc5e5f2
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
leaq 0x8(%rsp), %rsp
jne 0x274cd23... | /llvm/IR/Value.h |
llvm::InstCombinerImpl::visitAShr(llvm::BinaryOperator&) | Instruction *InstCombinerImpl::visitAShr(BinaryOperator &I) {
if (Value *V = simplifyAShrInst(I.getOperand(0), I.getOperand(1), I.isExact(),
SQ.getWithInstruction(&I)))
return replaceInstUsesWith(I, V);
if (Instruction *X = foldVectorBinop(I))
return X;
if (Instruction ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %r15
movq -0x20(%rsi), %r12
movq %rsi, %rdi
callq 0x1a3ffd0
movups 0x58(%rbx), %xmm0
movups 0x68(%rbx), %xmm1
movups 0x78(%rbx), %xmm2
movups 0x88(%rbx), %xmm3
l... | /Transforms/InstCombine/InstCombineShifts.cpp |
bool llvm::PatternMatch::OverflowingBinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::specificval_ty, 25u, 1u, false>::match<llvm::Value>(llvm::Value*) | unsigned getValueID() const {
return SubclassID;
} | movzbl (%rsi), %eax
cmpl $0x1d, %eax
jb 0x275599c
leal -0x2a(%rax), %ecx
rorl %ecx
cmpl $0x6, %ecx
ja 0x275599c
movl $0x47, %edx
btl %ecx, %edx
jb 0x27559bb
cmpl $0x5, %eax
jne 0x27559b9
movzwl 0x2(%rsi), %eax
addl $-0xd, %eax
rorl %eax
cmpl $0x6, %eax
ja 0x27559b9
movl $0x47, %ecx
btl %eax, %ecx
jb 0x27559bb
xorl %esi... | /llvm/IR/Value.h |
bool llvm::PatternMatch::OverflowingBinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::OverflowingBinaryOp_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::specificval_ty, 25u, 1u, false>, 15u, 1u, false>::match<llvm::Value>(llvm::Value*) | bool match(OpTy *V) {
if (auto *Op = dyn_cast<OverflowingBinaryOperator>(V)) {
if (Op->getOpcode() != Opcode)
return false;
if ((WrapFlags & OverflowingBinaryOperator::NoUnsignedWrap) &&
!Op->hasNoUnsignedWrap())
return false;
if ((WrapFlags & OverflowingBinaryOperator::N... | pushq %rbx
movq %rsi, %rbx
movzbl (%rsi), %eax
cmpl $0x1d, %eax
jb 0x2755a26
leal -0x2a(%rax), %ecx
rorl %ecx
cmpl $0x6, %ecx
ja 0x2755a26
movl $0x47, %edx
btl %ecx, %edx
jb 0x2755a45
cmpl $0x5, %eax
jne 0x2755a43
movzwl 0x2(%rbx), %eax
addl $-0xd, %eax
rorl %eax
cmpl $0x6, %eax
ja 0x2755a43
movl $0x47, %ecx
btl %eax, ... | /llvm/IR/PatternMatch.h |
bool llvm::PatternMatch::Argument_match<llvm::PatternMatch::OneUse_match<llvm::PatternMatch::CastInst_match<llvm::PatternMatch::bind_ty<llvm::Value>, llvm::ZExtInst>>>::match<llvm::Value>(llvm::Value*) | unsigned getValueID() const {
return SubclassID;
} | movb (%rsi), %al
cmpb $0x55, %al
jne 0x2755ca6
movl (%rdi), %ecx
movl 0x4(%rsi), %edx
shll $0x5, %edx
subq %rdx, %rsi
shlq $0x5, %rcx
movq (%rsi,%rcx), %rdx
movq 0x10(%rdx), %rcx
testq %rcx, %rcx
je 0x2755c7b
cmpq $0x0, 0x8(%rcx)
je 0x2755c7f
xorl %ecx, %ecx
jmp 0x2755ca6
movb (%rdx), %cl
cmpb $0x44, %cl
jne 0x2755c9d
... | /llvm/IR/Value.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_all_ones, llvm::ConstantInt, true>, llvm::PatternMatch::specificval_ty, 25u, false>::match<llvm::Value>(llvm::Value*) | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | cmpb $0x36, (%rsi)
jne 0x2755cf3
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq -0x40(%rsi), %r15
movq %r15, %rsi
callq 0xa2e936
movq (%r14), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x2755cdd
movq %r15, (%rcx)
testb %al, %al
je 0x2755ceb
movq 0x8(%r14), %rax
cmpq -0x20(%r... | /llvm/IR/PatternMatch.h |
getPreferredVectorIndex(llvm::ConstantInt*) | static ConstantInt *getPreferredVectorIndex(ConstantInt *IndexC) {
const unsigned IndexBW = IndexC->getBitWidth();
if (IndexBW == 64 || IndexC->getValue().getActiveBits() > 64)
return nullptr;
return ConstantInt::get(IndexC->getContext(),
IndexC->getValue().zextOrTrunc(64));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x40, 0x20(%rdi)
je 0x27627c4
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movl 0x20(%rdi), %r15d
cmpl $0x40, %r15d
ja 0x27627aa
leal -0x40(%r15), %eax
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x27627b4
bsrq %rcx, %rcx
xorq $0x3f, %rcx
jmp 0x27627b9
movq %rbx, %rdi
callq 0x... | /Transforms/InstCombine/InstCombineVectorOps.cpp |
getAlternateBinop(llvm::BinaryOperator*, llvm::DataLayout const&) | static BinopElts getAlternateBinop(BinaryOperator *BO, const DataLayout &DL) {
Value *BO0 = BO->getOperand(0), *BO1 = BO->getOperand(1);
Type *Ty = BO->getType();
switch (BO->getOpcode()) {
case Instruction::Shl: {
// shl X, C --> mul X, (1 << C)
Constant *C;
if (match(BO1, m_ImmConstant(C))) {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq -0x40(%rsi), %r15
movq -0x20(%rsi), %r14
movq 0x8(%rsi), %r12
movzbl (%rsi), %eax
cmpl $0x2c, %eax
je 0x2765509
cmpl $0x3a, %eax
je 0x27654f3
cmpl $0x36, %eax
jne 0x2765551
movb (%r14), %al
cmpb $0x16, %al
setae %cl
cmpb $0x5, ... | /Transforms/InstCombine/InstCombineVectorOps.cpp |
bool llvm::PatternMatch::ThreeOps_match<llvm::PatternMatch::class_match<llvm::Value>, llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::is_zero, 62u>::match<llvm::Value>(llvm::Value*) | bool match(OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opcode) {
auto *I = cast<Instruction>(V);
return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
Op3.match(I->getOperand(2));
}
return false;
} | cmpb $0x5b, (%rsi)
jne 0x27682dc
movl 0x4(%rsi), %eax
btl $0x1e, %eax
jb 0x27682b3
shll $0x5, %eax
movq %rsi, %rcx
subq %rax, %rcx
jmp 0x27682b7
movq -0x8(%rsi), %rcx
movq 0x20(%rcx), %rax
testq %rax, %rax
je 0x27682dc
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
addq $0x10, %rdi
movl 0x4(%rsi), %eax
btl $0x1e, %eax
jb 0x276... | /llvm/IR/PatternMatch.h |
std::pair<std::pair<llvm::Value*, llvm::Attribute::AttrKind>, unsigned long> const* llvm::SmallVectorTemplateCommon<std::pair<std::pair<llvm::Value*, llvm::Attribute::AttrKind>, unsigned long>, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<std::pair<std::pair<llvm::Value*, llvm::Attribute::AttrK... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x276da0e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
cmpq %rbx, %rax
setbe %sil... | /llvm/ADT/SmallVector.h |
llvm::SmallDenseMap<llvm::BasicBlock*, llvm::SmallVector<llvm::IntrinsicInst*, 4u>, 8u, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::SmallVector<llvm::IntrinsicInst*, 4u>>>::init(unsigned int) | void init(unsigned InitBuckets) {
Small = true;
if (InitBuckets > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(InitBuckets));
}
this->BaseT::initEmpty();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %ecx
orl $0x1, %ecx
movl %ecx, (%rdi)
cmpl $0x9, %esi
jb 0x276dda0
movl %esi, %ebp
andl $-0x2, %eax
movl %eax, (%rbx)
movl %esi, %eax
imulq $0x38, %rax, %rdi
movl $0x8, %esi
callq 0x1cac6bd
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
leaq 0x8(... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::AssumeSimplify::buildMapping(bool) | void buildMapping(bool FilterBooleanArgument) {
BBToAssume.clear();
for (Value *V : AC.assumptions()) {
if (!V)
continue;
IntrinsicInst *Assume = cast<IntrinsicInst>(V);
if (FilterBooleanArgument) {
auto *Arg = dyn_cast<ConstantInt>(Assume->getOperand(0));
if (!Arg || A... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x50(%rdi), %r14
movq %r14, %rdi
callq 0x276e080
movq %rbx, 0x8(%rsp)
movq 0x8(%rbx), %r15
cmpb $0x0, 0xb8(%r15)
jne 0x276deb4
movq %r15, %rdi
callq 0x285f294
movl 0x18(%r15), %r13d
testq %r13, %r13
j... | /Transforms/Utils/AssumeBundleBuilder.cpp |
llvm::DenseMapBase<llvm::SmallDenseMap<std::pair<llvm::Value*, llvm::Attribute::AttrKind>, llvm::SmallVector<(anonymous namespace)::AssumeSimplify::dropRedundantKnowledge()::MapValue, 2u>, 16u, llvm::DenseMapInfo<std::pair<llvm::Value*, llvm::Attribute::AttrKind>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Value... | void grow(unsigned AtLeast) {
static_cast<DerivedT *>(this)->grow(AtLeast);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x500, %rsp # imm = 0x500
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x11, %esi
jb 0x276f02e
decl %ebp
movl %ebp, %eax
shrl %eax
orl %ebp, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx... | /llvm/ADT/DenseMap.h |
UpdatePHINodes(llvm::BasicBlock*, llvm::BasicBlock*, llvm::ArrayRef<llvm::BasicBlock*>, llvm::BranchInst*, bool) | static void UpdatePHINodes(BasicBlock *OrigBB, BasicBlock *NewBB,
ArrayRef<BasicBlock *> Preds, BranchInst *BI,
bool HasLoopExit) {
// Otherwise, create a new PHI node in NewBB for each PHI node in OrigBB.
SmallPtrSet<BasicBlock *, 16> PredSet(Preds.begin(), Pre... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %r9d, 0x14(%rsp)
movq %r8, 0x18(%rsp)
movq %rdx, %rax
movq %rsi, %r13
movq %rdi, %r14
movq %rcx, 0x28(%rsp)
leaq (%rdx,%rcx,8), %rdx
leaq 0x58(%rsp), %rbp
movq %rbp, %rdi
movq %rax, 0x20(%rsp)
movq %rax, %rsi
callq 0x244f3da
movq 0x... | /Transforms/Utils/BasicBlockUtils.cpp |
llvm::emitCalloc(llvm::Value*, llvm::Value*, llvm::IRBuilderBase&, llvm::TargetLibraryInfo const&) | Value *llvm::emitCalloc(Value *Num, Value *Size, IRBuilderBase &B,
const TargetLibraryInfo &TLI) {
Module *M = B.GetInsertBlock()->getModule();
if (!isLibFuncEmittable(M, &TLI, LibFunc_calloc))
return nullptr;
StringRef CallocName = TLI.getName(LibFunc_calloc);
Type *SizeTTy = getSi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r13
movq 0x30(%rdx), %rdi
callq 0x19b93cc
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movl $0xb7, %edx
callq 0x2779fc8
testb %al, %al
je 0x277beb7
movq %r13, 0x10(%rsp)
movq... | /Transforms/Utils/BuildLibCalls.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::DivRemMapKey, (anonymous namespace)::QuotRemPair, llvm::DenseMapInfo<llvm::DivRemMapKey, void>, llvm::detail::DenseMapPair<llvm::DivRemMapKey, (anonymous namespace)::QuotRemPair>>, llvm::DivRemMapKey, (anonymous namespace)::QuotRemPair, llvm::DenseMapInfo<llvm::DivRemMapKey, void... | void grow(unsigned AtLeast) {
static_cast<DerivedT *>(this)->grow(AtLeast);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x10(%rdi), %r13d
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 %... | /llvm/ADT/DenseMap.h |
llvm::cloneAndAdaptNoAliasScopes(llvm::ArrayRef<llvm::MDNode*>, llvm::Instruction*, llvm::Instruction*, llvm::LLVMContext&, llvm::StringRef) | bool empty() const { return Length == 0; } | testq %rsi, %rsi
je 0x2784437
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
leaq 0x40(%rsp), %rax
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movl $0x0, 0x10(%rdx)
movq (%rax), %rcx
movq 0x8(%rax), %r8
movq %rbx, %r9
callq 0x2783d52
addq $0x18, %... | /llvm/ADT/ArrayRef.h |
(anonymous namespace)::ExtTSPImpl::mergeChains((anonymous namespace)::ChainT*, (anonymous namespace)::ChainT*, unsigned long, (anonymous namespace)::MergeTypeT) | void mergeChains(ChainT *Into, ChainT *From, size_t MergeOffset,
MergeTypeT MergeType) {
assert(Into != From && "a chain cannot be merged with itself");
// Merge the nodes.
MergedNodesT MergedNodes =
mergeNodes(Into->Nodes, From->Nodes, MergeOffset, MergeType);
Into->merge(Fr... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rdx
movq 0x28(%rsi), %rax
leaq (%rdx,%rcx,8), %r10
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rcx
movl %r8d, %edi
leaq 0x289b7b8(%rip), %r8 # 0x502cda4
movslq (%r8,%rdi,4), %rdi
addq %r8, %rdi
... | /Transforms/Utils/CodeLayout.cpp |
llvm::nonStrictlyPostDominate(llvm::BasicBlock const*, llvm::BasicBlock const*, llvm::DominatorTree const*, llvm::PostDominatorTree const*) | bool llvm::nonStrictlyPostDominate(const BasicBlock *ThisBlock,
const BasicBlock *OtherBlock,
const DominatorTree *DT,
const PostDominatorTree *PDT) {
assert(isControlFlowEquivalent(*ThisBlock, *OtherBlock, *DT, *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %rdx, (%rsp)
callq 0x1a12328
testq %rax, %rax
je 0x2794d5f
movq %rax, %r15
leaq 0x20(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x... | /Transforms/Utils/CodeMoverUtils.cpp |
void llvm::SmallVectorImpl<llvm::Loop*>::append<__gnu_cxx::__normal_iterator<llvm::Loop**, std::vector<llvm::Loop*, std::allocator<llvm::Loop*>>>, void>(__gnu_cxx::__normal_iterator<llvm::Loop**, std::vector<llvm::Loop*, std::allocator<llvm::Loop*>>>, __gnu_cxx::__normal_iterator<llvm::Loop**, std::vector<llvm::Loop*, ... | 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 0x27a2e8c
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x1cb... | /llvm/ADT/SmallVector.h |
llvm::FunctionComparator::cmpInstMetadata(llvm::Instruction const*, llvm::Instruction const*) const | int FunctionComparator::cmpInstMetadata(Instruction const *L,
Instruction const *R) const {
/// These metadata affects the other optimization passes by making assertions
/// or constraints.
/// Values that carry different expectations should be considered different.
Small... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x300000000, %rax # imm = 0x300000000
movq %rax, -0x8(%rcx)
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
leaq 0x8(%rsp), %r1... | /Transforms/Utils/FunctionComparator.cpp |
llvm::expandDivisionUpTo64Bits(llvm::BinaryOperator*) | bool llvm::expandDivisionUpTo64Bits(BinaryOperator *Div) {
assert((Div->getOpcode() == Instruction::SDiv ||
Div->getOpcode() == Instruction::UDiv) &&
"Trying to expand division from a non-division function");
Type *DivTy = Div->getType();
assert(!DivTy->isVectorTy() && "Div over vectors not s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
cmpl $0x4000, 0x8(%r14) # imm = 0x4000
jb 0x27b44f3
movq %rbx, %rdi
callq 0x27b318c
jmp 0x27b4662
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, ... | /Transforms/Utils/IntegerDivision.cpp |
llvm::formLCSSAForInstructions(llvm::SmallVectorImpl<llvm::Instruction*>&, llvm::DominatorTree const&, llvm::LoopInfo const&, llvm::ScalarEvolution*, llvm::SmallVectorImpl<llvm::PHINode*>*, llvm::SmallVectorImpl<llvm::PHINode*>*) | bool llvm::formLCSSAForInstructions(SmallVectorImpl<Instruction *> &Worklist,
const DominatorTree &DT, const LoopInfo &LI,
ScalarEvolution *SE,
SmallVectorImpl<PHINode *> *PHIsToRemove,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp # imm = 0x498
movq %r9, %r13
movq %r8, 0xb8(%rsp)
movq %rcx, 0x60(%rsp)
movq %rdx, 0x48(%rsp)
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x2e0(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x1000000000, %rcx # imm = 0x1000000000
... | /Transforms/Utils/LCSSA.cpp |
llvm::detail::DenseMapPair<llvm::Loop*, llvm::SmallVector<llvm::BasicBlock*, 1u>>* llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Loop*, llvm::SmallVector<llvm::BasicBlock*, 1u>, 4u, llvm::DenseMapInfo<llvm::Loop*, void>, llvm::detail::DenseMapPair<llvm::Loop*, llvm::SmallVector<llvm::BasicBlock*, 1u>>>, llvm::Loop*, llv... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdi), %edx
movl %edx, %ecx
shrl %ecx
movl $0x4, %esi
testb $0x1, %dl
jne 0x27b6087
movl 0x10(%rbx), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x27b60be
notl %ecx
addl %esi, %ecx
subl ... | /llvm/ADT/DenseMap.h |
getSalvageOpsForGEP(llvm::GetElementPtrInst*, llvm::DataLayout const&, unsigned long, llvm::SmallVectorImpl<unsigned long>&, llvm::SmallVectorImpl<llvm::Value*>&) | Value *getSalvageOpsForGEP(GetElementPtrInst *GEP, const DataLayout &DL,
uint64_t CurrentLocOps,
SmallVectorImpl<uint64_t> &Opcodes,
SmallVectorImpl<Value *> &AdditionalValues) {
unsigned BitWidth = DL.getIndexSizeInBits(GEP->getPointerA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r15
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r14
movl 0x4(%rdi), %eax
shll $0x5, %eax
movq %rdi, %rcx
subq %rax, %rcx
movq (%rcx), %rax
movq 0x8(%rax), %rax
movl $0xfe, %ecx
andl 0x8(%rax), %ecx
cmpl $0... | /Transforms/Utils/Local.cpp |
llvm::removeUnreachableBlocks(llvm::Function&, llvm::DomTreeUpdater*, llvm::MemorySSAUpdater*) | bool llvm::removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU,
MemorySSAUpdater *MSSAU) {
SmallPtrSet<BasicBlock *, 16> Reachable;
bool Changed = markAliveBlocks(F, Reachable, DTU);
// If there are unreachable blocks in the CFG...
if (Reachable.size() == F.size())
r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5e8, %rsp # imm = 0x5E8
movq %rdx, 0x110(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x150(%rsp), %rax
movq %rax, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x10, -0x10(%rax)
movl $0x0, -0x8(%rax)
leaq 0x1e0(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabs... | /Transforms/Utils/Local.cpp |
llvm::MapVector<std::pair<llvm::BasicBlock*, llvm::DbgVariableRecord*>, llvm::DbgVariableRecord*, llvm::DenseMap<std::pair<llvm::BasicBlock*, llvm::DbgVariableRecord*>, unsigned int, llvm::DenseMapInfo<std::pair<llvm::BasicBlock*, llvm::DbgVariableRecord*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::BasicBlock*,... | iterator find(const KeyT &Key) {
typename MapType::const_iterator Pos = Map.find(Key);
return Pos == Map.end()? Vector.end() :
(Vector.begin() + Pos->second);
} | pushq %rbx
movq %rdi, %rbx
callq 0x27c20f6
movl 0x10(%rbx), %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq (%rbx), %rcx
leaq 0x10(%rax), %rdx
leaq 0x20(%rbx), %rsi
cmpq %rcx, %rax
cmoveq %rsi, %rdx
movl (%rdx), %eax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x18(%rbx), %rax
popq %rbx
retq
| /llvm/ADT/MapVector.h |
llvm::DbgAssignIntrinsic::setAddressExpression(llvm::DIExpression*) | void setAddressExpression(DIExpression *NewExpr) {
setArgOperand(OpAddressExpr,
MetadataAsValue::get(NewExpr->getContext(), NewExpr));
} | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, %rdi
andq $-0x8, %rdi
testb $0x4, %al
je 0x27c3b16
movq (%rdi), %rdi
callq 0x1a64472
movq %rbx, %rdi
movl $0x5, %esi
movq %rax, %rdx
popq %rbx
jmp 0xac9ed8
| /llvm/IR/IntrinsicInst.h |
bool llvm::PatternMatch::ExtractValue_match<0, llvm::PatternMatch::bind_ty<llvm::WithOverflowInst>>::match<llvm::Instruction>(llvm::Instruction*) | bool isValue(const APInt &C) { return C.isMaxSignedValue(); } | pushq %rbx
movb (%rsi), %bl
xorl %ecx, %ecx
cmpb $0x5d, %bl
cmoveq %rsi, %rcx
jne 0x27c3c5f
cmpl $0x1, 0x50(%rcx)
jne 0x27c3c5d
movq 0x48(%rcx), %rax
cmpl $0x0, (%rax)
je 0x27c3c6b
xorl %eax, %eax
cmpb $0x5d, %bl
sete %cl
andb %al, %cl
movl %ecx, %eax
popq %rbx
retq
movq -0x20(%rcx), %rsi
callq 0x274cab2
jmp 0x27c3c5f
| /llvm/IR/PatternMatch.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, llvm::UnrollLoop(llvm::Loop*, llvm::UnrollLoopOptions, llvm::LoopInfo*, llvm::ScalarEvolution*, llvm::DominatorTree*, llvm::AssumptionCache*, llvm::TargetTransformInfo const*, llvm::OptimizationRemarkEmitter*, bool, llvm::Loop**, llvm::AAResults*)::ExitInfo, llv... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x27d320b
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movl %esi, %eax
shrl $0x4, %eax
movl %esi, %r8d
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %r11d
leaq (%r11,%r11,2), %r14
shlq $0x5, %r14
le... | /llvm/ADT/DenseMap.h |
llvm::getMinMaxReductionIntrinsicOp(llvm::RecurKind) | Intrinsic::ID llvm::getMinMaxReductionIntrinsicOp(RecurKind RK) {
switch (RK) {
default:
llvm_unreachable("Unknown min/max recurrence kind");
case RecurKind::UMin:
return Intrinsic::umin;
case RecurKind::UMax:
return Intrinsic::umax;
case RecurKind::SMin:
return Intrinsic::smin;
case RecurKi... | movslq %edi, %rax
leaq 0x2852530(%rip), %rcx # 0x502eef4
movl -0x18(%rcx,%rax,4), %eax
retq
| /Transforms/Utils/LoopUtils.cpp |
std::pair<llvm::DenseMapIterator<std::pair<llvm::Value*, llvm::Value*>, llvm::Value*, llvm::DenseMapInfo<std::pair<llvm::Value*, llvm::Value*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Value*, llvm::Value*>, llvm::Value*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Value*, llvm::Value*>, l... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x27e07d8
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x27e08f6
xorl %ecx, %ecx
jmp 0x27e0920
movq %r... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::AllocaInst*, unsigned int, llvm::DenseMapInfo<llvm::AllocaInst*, void>, llvm::detail::DenseMapPair<llvm::AllocaInst*, unsigned int>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::AllocaInst*, unsigned int, llvm::DenseMapInfo<llvm::AllocaInst*, void>, llvm::detail::DenseMap... | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0xca0824
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x27ee6b0
xorl %ecx, %ecx
jmp 0x27ee6d0
movq %r1... | /llvm/ADT/DenseMap.h |
llvm::SCEVExpander::expandWrapPredicate(llvm::SCEVWrapPredicate const*, llvm::Instruction*) | Value *SCEVExpander::expandWrapPredicate(const SCEVWrapPredicate *Pred,
Instruction *IP) {
const auto *A = cast<SCEVAddRecExpr>(Pred->getExpr());
Value *NSSWCheck = nullptr, *NUSWCheck = nullptr;
// Add a check for NUSW
if (Pred->getFlags() & SCEVWrapPredicate::Incremen... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x299b662
movq %rax, %r13
testb $0x1, 0x30(%r12)
jne 0x2805f68
xorl %r15d, %r15d
jmp 0x2805f7b
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x280600c
mov... | /Transforms/Utils/ScalarEvolutionExpander.cpp |
llvm::SCCPInstVisitor::getPredicateInfoFor(llvm::Instruction*) | const PredicateBase *getPredicateInfoFor(Instruction *I) {
auto It = FnPredicateInfo.find(I->getParent()->getParent());
if (It == FnPredicateInfo.end())
return nullptr;
return It->second->getPredicateInfoFor(I);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x960, %rdi # imm = 0x960
movq 0x28(%rsi), %rax
movq 0x48(%rax), %rsi
callq 0x28119a8
movl 0x970(%r14), %ecx
shlq $0x4, %rcx
addq 0x960(%r14), %rcx
cmpq %rcx, %rax
je 0x280fbe3
movq 0x8(%rax), %rdi
addq $0x18, %rdi
leaq 0x10(%rsp), ... | /Transforms/Utils/SCCPSolver.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Value*, unsigned int>, llvm::ValueLatticeElement, llvm::DenseMapInfo<std::pair<llvm::Value*, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Value*, unsigned int>, llvm::ValueLatticeElement>>, std::pair<llvm::Value*, unsigned int>, llvm::ValueLatti... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x2810acf
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %eax
movl 0x8(%rsi), %r8d
movl %eax, %r9d
shrl $0x4, %r9d
shrl $0x9, %eax
xorl %r9d, %eax
leal (%r8,%r8,8), %r9d
leal (%r8,%r9,4), %r8d
shlq $0x20, %rax
orq %rax, %r8
movabsq $-0x40a7b892e31b1a47, %rax # ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Value*, unsigned int>, llvm::ValueLatticeElement, llvm::DenseMapInfo<std::pair<llvm::Value*, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Value*, unsigned int>, llvm::ValueLatticeElement>>, std::pair<llvm::Value*, unsigned int>, llvm::ValueLatticeEle... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x28114eb
movq (%r15), %rax
imulq $0x38, %rcx, %rcx
addq %rax, %rcx
movq $-0x1000, (%rax) # imm = 0xF000
movl $0xffffffff, 0x8(%ra... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<std::pair<llvm::Function*, unsigned int>, unsigned int>* llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Function*, unsigned int>, unsigned int, llvm::DenseMapInfo<std::pair<llvm::Function*, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Function*, unsigned int>, unsigned ... | 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 0x28129a3
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::sampleprof::FunctionSamples const*, std::map<llvm::sampleprof::LineLocation, unsigned int, std::less<llvm::sampleprof::LineLocation>, std::allocator<std::pair<llvm::sampleprof::LineLocation const, unsigned int>>>, llvm::DenseMapInfo<llvm::sampleprof::FunctionSamples const*, void>, llvm::detail::Den... | 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, %r14
movl 0x10(%rdi), %r15d
movq (%rdi), %rbx
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 %... | /llvm/ADT/DenseMap.h |
memChrToCharCompare(llvm::CallInst*, llvm::Value*, llvm::IRBuilderBase&, llvm::DataLayout const&) | static Value* memChrToCharCompare(CallInst *CI, Value *NBytes,
IRBuilderBase &B, const DataLayout &DL)
{
Value *Src = CI->getArgOperand(0);
Value *CharVal = CI->getArgOperand(1);
// Fold memchr(A, C, N) == A to N && *A == C.
Type *CharTy = B.getInt8Ty();
Value *Char0 = B.Cre... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movl 0x4(%rdi), %eax
shll $0x5, %eax
movq %rdi, 0x10(%rsp)
movq %rdi, %rcx
subq %rax, %rcx
movq (%rcx), %r15
movq 0x20(%rcx), %r13
movq 0x48(%rdx), %rdi
callq 0x1a89f30
movq %rax, %rbp
movw $0x101, %r... | /Transforms/Utils/SimplifyLibCalls.cpp |
optimizeMemCmpVarSize(llvm::CallInst*, llvm::Value*, llvm::Value*, llvm::Value*, bool, llvm::IRBuilderBase&, llvm::DataLayout const&) | static Value *optimizeMemCmpVarSize(CallInst *CI, Value *LHS, Value *RHS,
Value *Size, bool StrNCmp,
IRBuilderBase &B, const DataLayout &DL) {
if (LHS == RHS) // memcmp(s,s,x) -> 0
return Constant::getNullValue(CI->getType());
StringRef LS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r15
cmpq %rdx, %rsi
je 0x28408e0
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r13
movq %r9, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rsp)
xorl %r14d, %r14d
movq %rsi, %rdi
mov... | /Transforms/Utils/SimplifyLibCalls.cpp |
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.