Lines Matching refs:ep
26 static pseudo_t linearize_statement(struct entrypoint *ep, struct statement *stmt);
27 static pseudo_t linearize_expression(struct entrypoint *ep, struct expression *expr);
29 static pseudo_t add_cast(struct entrypoint *ep, struct symbol *to, struct symbol *from, int op, pseudo_t src);
30 static pseudo_t add_binary_op(struct entrypoint *ep, struct symbol *ctype, int op, pseudo_t left, pseudo_t right);
31 static pseudo_t linearize_one_symbol(struct entrypoint *ep, struct symbol *sym);
33 static pseudo_t cast_pseudo(struct entrypoint *ep, pseudo_t src, struct symbol *from, struct symbol *to);
67 static struct basic_block *alloc_basic_block(struct entrypoint *ep, struct position pos)
72 bb->ep = ep;
584 void show_entry(struct entrypoint *ep)
589 printf("%s:\n", show_ident(ep->name->ident));
592 printf("ep %p: %s\n", ep, show_ident(ep->name->ident));
594 FOR_EACH_PTR(ep->syms, sym) {
608 FOR_EACH_PTR(ep->bbs, bb) {
624 if (!insn || !insn->bb || !insn->bb->ep)
626 show_entry(insn->bb->ep);
636 static struct basic_block * get_bound_block(struct entrypoint *ep, struct symbol *label)
641 bb = alloc_basic_block(ep, label->pos);
647 static void finish_block(struct entrypoint *ep)
649 struct basic_block *src = ep->active;
651 ep->active = NULL;
654 static void add_goto(struct entrypoint *ep, struct basic_block *dst)
656 struct basic_block *src = ep->active;
664 ep->active = NULL;
668 static void add_one_insn(struct entrypoint *ep, struct instruction *insn)
670 struct basic_block *bb = ep->active;
678 static void add_unreachable(struct entrypoint *ep)
681 add_one_insn(ep, insn);
682 ep->active = NULL;
685 static void set_activeblock(struct entrypoint *ep, struct basic_block *bb)
687 if (!bb_terminated(ep->active))
688 add_goto(ep, bb);
690 ep->active = bb;
692 add_bb(&ep->bbs, bb);
722 static struct basic_block * add_label(struct entrypoint *ep, struct symbol *label)
727 set_activeblock(ep, bb);
730 bb = ep->active;
732 bb = alloc_basic_block(ep, label->pos);
733 set_activeblock(ep, bb);
739 static void add_branch(struct entrypoint *ep, pseudo_t cond, struct basic_block *bb_true, struct basic_block *bb_false)
741 struct basic_block *bb = ep->active;
753 add_one_insn(ep, br);
767 static pseudo_t symbol_pseudo(struct entrypoint *ep, struct symbol *sym)
782 add_pseudo(&ep->accesses, pseudo);
817 static pseudo_t argument_pseudo(struct entrypoint *ep, int nr)
820 struct instruction *entry = ep->entry;
907 static int linearize_simple_address(struct entrypoint *ep,
912 linearize_one_symbol(ep, addr->symbol);
913 ad->address = symbol_pseudo(ep, addr->symbol);
920 return linearize_simple_address(ep, addr->left, ad);
924 ad->address = linearize_expression(ep, addr);
950 static int linearize_address_gen(struct entrypoint *ep,
960 return linearize_simple_address(ep, expr->unop, ad);
966 static pseudo_t add_load(struct entrypoint *ep, struct access_data *ad)
971 if (!ep->active)
981 add_one_insn(ep, insn);
985 static void add_store(struct entrypoint *ep, struct access_data *ad, pseudo_t value)
987 struct basic_block *bb = ep->active;
998 add_one_insn(ep, store);
1001 static pseudo_t linearize_bitfield_insert(struct entrypoint *ep,
1009 val = add_cast(ep, btype, ctype, OP_ZEXT, val);
1011 val = add_binary_op(ep, btype, OP_SHL, val, value_pseudo(shift));
1014 ori = add_binary_op(ep, btype, OP_AND, ori, value_pseudo(~mask & smask));
1015 val = add_binary_op(ep, btype, OP_OR, ori, val);
1020 static pseudo_t linearize_store_gen(struct entrypoint *ep,
1028 if (!ep->active)
1033 pseudo_t orig = add_load(ep, ad);
1034 store = linearize_bitfield_insert(ep, orig, value, ctype, btype);
1036 add_store(ep, ad, store);
1057 static pseudo_t add_binary_op(struct entrypoint *ep, struct symbol *ctype, int op, pseudo_t left, pseudo_t right)
1064 add_one_insn(ep, insn);
1068 static pseudo_t add_cmp_op(struct entrypoint *ep, struct symbol *ctype, int op, struct symbol *itype, pseudo_t left, pseudo_t right)
1070 pseudo_t target = add_binary_op(ep, ctype, op, left, right);
1075 static pseudo_t add_setval(struct entrypoint *ep, struct symbol *ctype, struct expression *val)
1081 add_one_insn(ep, insn);
1085 static pseudo_t add_setfval(struct entrypoint *ep, struct symbol *ctype, long double fval)
1091 add_one_insn(ep, insn);
1095 static pseudo_t add_symbol_address(struct entrypoint *ep, struct expression *expr)
1101 use_pseudo(insn, symbol_pseudo(ep, expr->symbol), &insn->src);
1102 add_one_insn(ep, insn);
1106 static pseudo_t linearize_bitfield_extract(struct entrypoint *ep,
1113 val = add_binary_op(ep, btype, OP_LSR, val, shift);
1115 val = cast_pseudo(ep, val, btype, ctype);
1119 static pseudo_t linearize_load_gen(struct entrypoint *ep, struct access_data *ad)
1125 if (!ep->active)
1129 new = add_load(ep, ad);
1131 new = linearize_bitfield_extract(ep, new, ctype, btype);
1135 static pseudo_t linearize_access(struct entrypoint *ep, struct expression *expr)
1140 if (!linearize_address_gen(ep, expr, &ad))
1142 value = linearize_load_gen(ep, &ad);
1146 static pseudo_t linearize_inc_dec(struct entrypoint *ep, struct expression *expr, int postop)
1152 if (!linearize_address_gen(ep, expr->unop, &ad))
1155 old = linearize_load_gen(ep, &ad);
1158 one = add_setfval(ep, expr->ctype, expr->op_value);
1162 old = cast_pseudo(ep, old, ad.type, ad.btype);
1163 new = add_binary_op(ep, ad.btype, op, old, one);
1165 new = cast_pseudo(ep, new, ad.btype, ad.type);
1166 linearize_store_gen(ep, new, &ad);
1170 static pseudo_t add_unop(struct entrypoint *ep, struct symbol *ctype, int op, pseudo_t src)
1177 add_one_insn(ep, insn);
1181 static pseudo_t add_cast(struct entrypoint *ep, struct symbol *to,
1184 pseudo_t new = add_unop(ep, to, op, src);
1189 static pseudo_t linearize_slice(struct entrypoint *ep, struct expression *expr)
1191 pseudo_t pre = linearize_expression(ep, expr->base);
1199 add_one_insn(ep, insn);
1203 static pseudo_t linearize_regular_preop(struct entrypoint *ep, struct expression *expr)
1205 pseudo_t pre = linearize_expression(ep, expr->unop);
1212 return add_cmp_op(ep, ctype, OP_SET_EQ, expr->unop->ctype, pre, zero);
1215 return add_unop(ep, ctype, OP_NOT, pre);
1217 return add_unop(ep, ctype, opcode_float(OP_NEG, ctype), pre);
1222 static pseudo_t linearize_preop(struct entrypoint *ep, struct expression *expr)
1230 return linearize_access(ep, expr);
1232 return linearize_inc_dec(ep, expr, 0);
1233 return linearize_regular_preop(ep, expr);
1236 static pseudo_t linearize_postop(struct entrypoint *ep, struct expression *expr)
1238 return linearize_inc_dec(ep, expr, 1);
1360 static pseudo_t cast_pseudo(struct entrypoint *ep, pseudo_t src, struct symbol *from, struct symbol *to)
1384 src = cast_pseudo(ep, src, from, size_t_ctype);
1392 src = cast_pseudo(ep, src, from, size_t_ctype);
1393 return cast_pseudo(ep, src, size_t_ctype, to);
1404 add_one_insn(ep, insn);
1421 static inline pseudo_t add_convert_to_bool(struct entrypoint *ep, pseudo_t src, struct symbol *type)
1433 zero = add_setfval(ep, type, 0.0);
1439 return add_cmp_op(ep, &bool_ctype, op, type, src, zero);
1442 static pseudo_t linearize_expression_to_bool(struct entrypoint *ep, struct expression *expr)
1445 dst = linearize_expression(ep, expr);
1446 dst = add_convert_to_bool(ep, dst, expr->ctype);
1450 static pseudo_t linearize_assignment(struct entrypoint *ep, struct expression *expr)
1458 value = linearize_expression(ep, src);
1459 if (!target || !linearize_address_gen(ep, target, &ad))
1462 pseudo_t oldvalue = linearize_load_gen(ep, &ad);
1482 oldvalue = cast_pseudo(ep, oldvalue, target->ctype, ctype);
1484 dst = add_binary_op(ep, ctype, opcode, oldvalue, value);
1486 value = cast_pseudo(ep, dst, ctype, expr->ctype);
1488 value = linearize_store_gen(ep, value, &ad);
1492 static pseudo_t linearize_call_expression(struct entrypoint *ep, struct expression *expr)
1509 retval = fntype->op->linearize(ep, expr);
1519 pseudo_t new = linearize_expression(ep, arg);
1528 call = symbol_pseudo(ep, fn->symbol);
1530 call = linearize_expression(ep, fn);
1537 add_one_insn(ep, insn);
1559 add_one_insn(ep, insn);
1564 add_unreachable(ep);
1570 static pseudo_t linearize_binop_bool(struct entrypoint *ep, struct expression *expr)
1575 src1 = linearize_expression_to_bool(ep, expr->left);
1576 src2 = linearize_expression_to_bool(ep, expr->right);
1577 dst = add_binary_op(ep, &bool_ctype, op, src1, src2);
1579 dst = cast_pseudo(ep, dst, &bool_ctype, expr->ctype);
1583 static pseudo_t linearize_binop(struct entrypoint *ep, struct expression *expr)
1596 src1 = linearize_expression(ep, expr->left);
1597 src2 = linearize_expression(ep, expr->right);
1599 dst = add_binary_op(ep, expr->ctype, op, src1, src2);
1604 static pseudo_t linearize_logical_branch(struct entrypoint *ep, struct expression *expr, struct basic_block *bb_true, struct basic_block *bb_false);
1606 static pseudo_t linearize_cond_branch(struct entrypoint *ep, struct expression *expr, struct basic_block *bb_true, struct basic_block *bb_false);
1608 static pseudo_t linearize_select(struct entrypoint *ep, struct expression *expr)
1613 valt = linearize_expression(ep, expr->cond_true);
1614 valf = linearize_expression(ep, expr->cond_false);
1615 cond = linearize_expression(ep, expr->conditional);
1626 add_one_insn(ep, insn);
1630 static pseudo_t add_join_conditional(struct entrypoint *ep, struct expression *expr,
1645 add_one_insn(ep, phi_node);
1649 static pseudo_t linearize_short_conditional(struct entrypoint *ep, struct expression *expr,
1658 if (!expr_false || !ep->active)
1661 bb_false = alloc_basic_block(ep, expr_false->pos);
1662 merge = alloc_basic_block(ep, expr->pos);
1664 src1 = linearize_expression(ep, cond);
1665 phi1 = alloc_phi(ep->active, src1, expr->ctype);
1666 add_branch(ep, src1, merge, bb_false);
1668 set_activeblock(ep, bb_false);
1669 src2 = linearize_expression(ep, expr_false);
1670 phi2 = alloc_phi(ep->active, src2, expr->ctype);
1671 set_activeblock(ep, merge);
1673 return add_join_conditional(ep, expr, phi1, phi2);
1676 static pseudo_t linearize_conditional(struct entrypoint *ep, struct expression *expr,
1685 if (!cond || !expr_true || !expr_false || !ep->active)
1687 bb_true = alloc_basic_block(ep, expr_true->pos);
1688 bb_false = alloc_basic_block(ep, expr_false->pos);
1689 merge = alloc_basic_block(ep, expr->pos);
1691 linearize_cond_branch(ep, cond, bb_true, bb_false);
1693 set_activeblock(ep, bb_true);
1694 src1 = linearize_expression(ep, expr_true);
1695 phi1 = alloc_phi(ep->active, src1, expr->ctype);
1696 add_goto(ep, merge);
1698 set_activeblock(ep, bb_false);
1699 src2 = linearize_expression(ep, expr_false);
1700 phi2 = alloc_phi(ep->active, src2, expr->ctype);
1701 set_activeblock(ep, merge);
1703 return add_join_conditional(ep, expr, phi1, phi2);
1718 static pseudo_t linearize_logical(struct entrypoint *ep, struct expression *expr)
1725 if (!ep->active || !expr->left || !expr->right)
1728 other = alloc_basic_block(ep, expr->right->pos);
1729 merge = alloc_basic_block(ep, expr->pos);
1734 linearize_cond_branch(ep, expr->left, merge, other);
1737 linearize_cond_branch(ep, expr->left, other, merge);
1743 set_activeblock(ep, other);
1744 src2 = linearize_expression_to_bool(ep, expr->right);
1745 src2 = cast_pseudo(ep, src2, &bool_ctype, ctype);
1746 phi2 = alloc_phi(ep->active, src2, ctype);
1750 set_activeblock(ep, merge);
1755 static pseudo_t linearize_compare(struct entrypoint *ep, struct expression *expr)
1770 pseudo_t src1 = linearize_expression(ep, expr->left);
1771 pseudo_t src2 = linearize_expression(ep, expr->right);
1772 pseudo_t dst = add_cmp_op(ep, expr->ctype, op, itype, src1, src2);
1777 static pseudo_t linearize_cond_branch(struct entrypoint *ep, struct expression *expr, struct basic_block *bb_true, struct basic_block *bb_false)
1781 if (!expr || !valid_type(expr->ctype) || !bb_reachable(ep->active))
1788 add_goto(ep, expr->value ? bb_true : bb_false);
1791 add_goto(ep, expr->fvalue ? bb_true : bb_false);
1794 linearize_logical_branch(ep, expr, bb_true, bb_false);
1797 cond = linearize_compare(ep, expr);
1798 add_branch(ep, cond, bb_true, bb_false);
1802 return linearize_cond_branch(ep, expr->unop, bb_false, bb_true);
1805 cond = linearize_expression_to_bool(ep, expr);
1806 add_branch(ep, cond, bb_true, bb_false);
1813 static pseudo_t linearize_logical_branch(struct entrypoint *ep, struct expression *expr, struct basic_block *bb_true, struct basic_block *bb_false)
1815 struct basic_block *next = alloc_basic_block(ep, expr->pos);
1818 linearize_cond_branch(ep, expr->left, bb_true, next);
1820 linearize_cond_branch(ep, expr->left, next, bb_false);
1821 set_activeblock(ep, next);
1822 linearize_cond_branch(ep, expr->right, bb_true, bb_false);
1826 static pseudo_t linearize_cast(struct entrypoint *ep, struct expression *expr)
1834 src = linearize_expression(ep, orig);
1835 return cast_pseudo(ep, src, orig->ctype, expr->ctype);
1838 static pseudo_t linearize_initializer(struct entrypoint *ep, struct expression *initializer, struct access_data *ad)
1844 linearize_initializer(ep, expr, ad);
1850 linearize_initializer(ep, initializer->init_expr, ad);
1853 pseudo_t value = linearize_expression(ep, initializer);
1855 linearize_store_gen(ep, value, ad);
1863 static void linearize_argument(struct entrypoint *ep, struct symbol *arg, int nr)
1868 ad.address = symbol_pseudo(ep, arg);
1869 linearize_store_gen(ep, argument_pseudo(ep, nr), &ad);
1872 static pseudo_t linearize_expression(struct entrypoint *ep, struct expression *expr)
1880 linearize_one_symbol(ep, expr->symbol);
1881 return add_symbol_address(ep, expr);
1888 return add_setval(ep, expr->ctype, expr);
1891 return add_setfval(ep, expr->ctype, expr->fvalue);
1894 return linearize_statement(ep, expr->statement);
1897 return linearize_call_expression(ep, expr);
1901 return linearize_binop_bool(ep, expr);
1902 return linearize_binop(ep, expr);
1905 return linearize_logical(ep, expr);
1908 return linearize_compare(ep, expr);
1911 return linearize_select(ep, expr);
1915 return linearize_short_conditional(ep, expr, expr->conditional, expr->cond_false);
1917 return linearize_conditional(ep, expr, expr->conditional,
1921 linearize_expression(ep, expr->left);
1922 return linearize_expression(ep, expr->right);
1925 return linearize_assignment(ep, expr);
1928 return linearize_preop(ep, expr);
1931 return linearize_postop(ep, expr);
1936 return linearize_cast(ep, expr);
1939 return linearize_slice(ep, expr);
1952 static pseudo_t linearize_one_symbol(struct entrypoint *ep, struct symbol *sym)
1965 ad.address = symbol_pseudo(ep, sym);
1974 ad.address = symbol_pseudo(ep, sym);
1975 linearize_store_gen(ep, value_pseudo(0), &ad);
1978 value = linearize_initializer(ep, sym->initializer, &ad);
1982 static pseudo_t linearize_compound_statement(struct entrypoint *ep, struct statement *stmt)
1989 pseudo = linearize_statement(ep, s);
1995 static void add_return(struct entrypoint *ep, struct basic_block *bb, struct symbol *ctype, pseudo_t src)
2005 phi = alloc_phi(ep->active, src, ctype);
2010 static pseudo_t linearize_fn_statement(struct entrypoint *ep, struct statement *stmt)
2016 pseudo = linearize_compound_statement(ep, stmt);
2018 struct basic_block *active = ep->active;
2021 bb_ret = get_bound_block(ep, stmt->ret);
2022 add_return(ep, bb_ret, stmt->ret, undef_pseudo());
2025 bb = add_label(ep, stmt->ret);
2032 static pseudo_t linearize_inlined_call(struct entrypoint *ep, struct statement *stmt)
2042 concat_symbol_list(args->declaration, &ep->syms);
2044 pseudo_t value = linearize_one_symbol(ep, sym);
2049 pseudo = linearize_fn_statement(ep, stmt);
2052 insn->func = symbol_pseudo(ep, stmt->inline_fn);
2053 bb = ep->active;
2056 add_one_insn(ep, insn);
2060 static pseudo_t linearize_context(struct entrypoint *ep, struct statement *stmt)
2067 add_one_insn(ep, insn);
2071 static pseudo_t linearize_range(struct entrypoint *ep, struct statement *stmt)
2075 use_pseudo(insn, linearize_expression(ep, stmt->range_expression), &insn->src1);
2076 use_pseudo(insn, linearize_expression(ep, stmt->range_low), &insn->src2);
2077 use_pseudo(insn, linearize_expression(ep, stmt->range_high), &insn->src3);
2078 add_one_insn(ep, insn);
2095 static void add_asm_input(struct entrypoint *ep, struct instruction *insn, struct asm_operand *op)
2097 pseudo_t pseudo = linearize_expression(ep, op->expr);
2102 static void add_asm_output_address(struct entrypoint *ep, struct instruction *insn, struct asm_operand *op)
2109 pseudo = linearize_expression(ep, op->expr);
2114 static void add_asm_output(struct entrypoint *ep, struct instruction *insn, struct asm_operand *op)
2122 if (!linearize_address_gen(ep, op->expr, &ad))
2125 linearize_store_gen(ep, pseudo, &ad);
2130 static pseudo_t linearize_asm_statement(struct entrypoint *ep, struct statement *stmt)
2150 add_asm_input(ep, insn, op);
2155 add_asm_output_address(ep, insn, op);
2158 add_one_insn(ep, insn);
2162 add_asm_output(ep, insn, op);
2200 static pseudo_t linearize_declaration(struct entrypoint *ep, struct statement *stmt)
2204 concat_symbol_list(stmt->declaration, &ep->syms);
2207 linearize_one_symbol(ep, sym);
2212 static pseudo_t linearize_return(struct entrypoint *ep, struct statement *stmt)
2216 struct basic_block *bb_return = get_bound_block(ep, ret);
2218 pseudo_t src = linearize_expression(ep, expr);
2219 active = ep->active;
2221 add_return(ep, bb_return, ret, src);
2223 add_goto(ep, bb_return);
2227 static pseudo_t linearize_switch(struct entrypoint *ep, struct statement *stmt)
2231 struct basic_block *switch_end = alloc_basic_block(ep, stmt->pos);
2239 pseudo = linearize_expression(ep, expr);
2240 active = ep->active;
2242 active = alloc_basic_block(ep, stmt->pos);
2243 set_activeblock(ep, active);
2248 add_one_insn(ep, switch_ins);
2249 finish_block(ep);
2254 struct basic_block *bb_case = get_bound_block(ep, sym);
2282 linearize_statement(ep, stmt->switch_statement);
2283 set_activeblock(ep, switch_end);
2297 static pseudo_t linearize_iterator(struct entrypoint *ep, struct statement *stmt)
2308 linearize_one_symbol(ep, sym);
2310 concat_symbol_list(stmt->iterator_syms, &ep->syms);
2311 linearize_statement(ep, pre_statement);
2313 loop_body = loop_top = alloc_basic_block(ep, stmt->pos);
2314 loop_continue = alloc_basic_block(ep, stmt->pos);
2315 loop_end = alloc_basic_block(ep, stmt->pos);
2319 loop_top = alloc_basic_block(ep, stmt->pos);
2320 set_activeblock(ep, loop_top);
2324 linearize_cond_branch(ep, pre_condition, loop_body, loop_end);
2329 set_activeblock(ep, loop_body);
2330 linearize_statement(ep, statement);
2331 add_goto(ep, loop_continue);
2333 set_activeblock(ep, loop_continue);
2334 linearize_statement(ep, post_statement);
2336 add_goto(ep, loop_top);
2338 linearize_cond_branch(ep, post_condition, loop_top, loop_end);
2339 set_activeblock(ep, loop_end);
2344 static pseudo_t linearize_statement(struct entrypoint *ep, struct statement *stmt)
2351 bb = ep->active;
2361 return linearize_declaration(ep, stmt);
2364 return linearize_context(ep, stmt);
2367 return linearize_range(ep, stmt);
2370 return linearize_expression(ep, stmt->expression);
2373 return linearize_asm_statement(ep, stmt);
2376 return linearize_return(ep, stmt);
2379 add_label(ep, stmt->case_label);
2380 linearize_statement(ep, stmt->case_statement);
2388 add_label(ep, label);
2390 return linearize_statement(ep, stmt->label_statement);
2400 active = ep->active;
2405 add_goto(ep, get_bound_block(ep, stmt->goto_label));
2415 add_goto(ep, get_bound_block(ep, expr->label_symbol));
2419 pseudo = linearize_expression(ep, expr);
2422 add_one_insn(ep, goto_ins);
2425 struct basic_block *bb_computed = get_bound_block(ep, sym);
2428 add_bb(&bb_computed->parents, ep->active);
2432 finish_block(ep);
2438 return linearize_inlined_call(ep, stmt);
2439 return linearize_compound_statement(ep, stmt);
2449 bb_true = alloc_basic_block(ep, stmt->pos);
2450 bb_false = endif = alloc_basic_block(ep, stmt->pos);
2456 linearize_cond_branch(ep, cond, bb_true, bb_false);
2458 set_activeblock(ep, bb_true);
2459 linearize_statement(ep, stmt->if_true);
2462 endif = alloc_basic_block(ep, stmt->pos);
2463 add_goto(ep, endif);
2464 set_activeblock(ep, bb_false);
2465 linearize_statement(ep, stmt->if_false);
2467 set_activeblock(ep, endif);
2472 return linearize_switch(ep, stmt);
2475 return linearize_iterator(ep, stmt);
2512 static void late_warnings(struct entrypoint *ep)
2515 FOR_EACH_PTR(ep->bbs, bb) {
2535 struct entrypoint *ep;
2547 ep = alloc_entrypoint();
2548 ep->name = sym;
2549 sym->ep = ep;
2550 bb = alloc_basic_block(ep, sym->pos);
2551 set_activeblock(ep, bb);
2554 linearize_asm_statement(ep, stmt);
2555 return ep;
2559 add_one_insn(ep, entry);
2560 ep->entry = entry;
2562 concat_symbol_list(base_type->arguments, &ep->syms);
2567 linearize_argument(ep, arg, ++i);
2570 result = linearize_fn_statement(ep, stmt);
2575 add_one_insn(ep, ret);
2577 optimize(ep);
2578 late_warnings(ep);
2579 return ep;
2601 static pseudo_t linearize_fma(struct entrypoint *ep, struct expression *expr)
2607 use_pseudo(insn, linearize_expression(ep, arg), &insn->src1);
2609 use_pseudo(insn, linearize_expression(ep, arg), &insn->src2);
2611 use_pseudo(insn, linearize_expression(ep, arg), &insn->src3);
2614 add_one_insn(ep, insn);
2618 static pseudo_t linearize_isdigit(struct entrypoint *ep, struct expression *expr)
2624 src = linearize_expression(ep, first_expression(expr->args));
2628 add_one_insn(ep, insn);
2635 add_one_insn(ep, insn);
2640 static pseudo_t linearize_unreachable(struct entrypoint *ep, struct expression *exp)
2642 add_unreachable(ep);