Lines Matching refs:RETURN
65 return a < b ? a : b;
71 return a > b ? a : b;
77 return x >= 0 ? (uint64_t)x : -(uint64_t)x;
83 return x >= 0
91 return a < b ? a : b;
97 return a > b ? a : b;
109 return x;
130 return m;
140 return (int)p1->tt_rank_value - (int)p2->tt_rank_value;
147 return tp->t_bitfield
155 return value_bits(width_in_bits(tp));
161 return (int64_t)(ui_max_value(tp) >> 1);
167 return -si_max_value(tp) - 1;
179 return l * r;
181 return -1 - max;
183 return max;
191 return a <= max - b ? a + b : max;
194 return a >= min - b ? a + b : min;
203 return a >= min + b ? a - b : min;
206 return a <= max + b ? a - b : max;
213 return !is_uinteger(tp->t_tspec) && ic.bclr >> 63 == 0;
220 return !is_uinteger(tp->t_tspec) && (a.bclr & b.bclr) >> 63 == 0;
243 return c;
262 return c;
266 return ic_any(tp);
273 return c;
281 return a;
282 return ic_any(tp);
291 return c;
300 return a;
308 return c;
317 return c;
330 return c;
349 return c;
371 return c;
378 return ic_any(tp);
386 return ic_any(tp);
399 return c;
406 return ic_any(tp);
414 return ic_any(tp);
422 return c;
434 return c;
441 return ic_any(tp);
449 return c;
461 return c;
473 return c;
489 return c;
501 return a;
503 return a;
505 return a;
506 return ic_any(ntp);
520 return ic_mult(tn->tn_type, lc, rc);
524 return ic_div(tn->tn_type, lc, rc);
528 return ic_mod(tn->tn_type, lc, rc);
532 return ic_plus(tn->tn_type, lc, rc);
535 return ic_any(tn->tn_type);
538 return ic_minus(tn->tn_type, lc, rc);
542 return ic_shl(tn->tn_type, lc, rc);
546 return ic_shr(tn->tn_type, lc, rc);
550 return ic_bitand(lc, rc);
554 return ic_bitxor(tn->tn_type, lc, rc);
558 return ic_bitor(lc, rc);
562 return ic_quest_colon(lc, rc);
564 return ic_con(tn->tn_type, &tn->u.value);
567 return ic_any(tn->tn_type);
569 return ic_cvt(tn->tn_type, tn->u.ops.left->tn_type, lc);
571 return ic_any(tn->tn_type);
578 return ~ic_expr(tn).bclr;
587 return true;
589 return false;
600 return tp2;
614 return tp2;
622 return call->func->u.ops.left->u.sym->s_name;
623 return type_name(call->func->tn_type->t_subt);
631 return buf->len;
636 return len;
657 return ntn;
670 return n;
684 return n;
692 return;
710 return;
732 return true;
737 return true;
739 return false;
748 return nlen <= hlen &&
756 return strncmp(name, "__builtin_", 10) == 0 &&
773 /* function '%s' implicitly declared to return int */
776 /* function '%s' implicitly declared to return int */
820 return n;
854 return n;
867 return sel->ga_result;
871 return default_result;
877 return tn->tn_op == CON &&
889 return true;
897 return false;
905 return false;
907 return true;
918 return;
921 return;
939 return;
950 return;
961 return;
988 return unsigned_type(t);
989 return t;
997 return lt;
1000 return LCOMPLEX;
1002 return DCOMPLEX;
1004 return FCOMPLEX;
1006 return LDOUBLE;
1008 return DOUBLE;
1010 return FLOAT;
1013 return lt;
1015 return rt;
1024 return arith_rank[i];
1037 return convert(op, 0, ntp, tn);
1051 return;
1086 return tn->u.ops.left;
1089 return build_op(ADDR, sys, expr_derive_type(tn->tn_type, PTR),
1099 return ~l & max_value;
1101 return +l;
1103 return -l & max_value;
1106 return l * r;
1111 return max_value;
1113 return l / r;
1118 return 0;
1120 return l % r;
1123 return l + r;
1126 return l - r;
1130 return l << (r & 63);
1133 return l >> (r & 63);
1135 return l < r ? 1 : 0;
1137 return l <= r ? 1 : 0;
1139 return l > r ? 1 : 0;
1141 return l >= r ? 1 : 0;
1143 return l == r ? 1 : 0;
1145 return l != r ? 1 : 0;
1147 return l & r;
1149 return l ^ r;
1151 return l | r;
1164 return ~l;
1166 return +l;
1169 return *overflow ? l : -l;
1177 return neg ? min_value : max_value;
1179 return l * r;
1184 return max_value;
1188 return l;
1190 return l / r;
1195 return 0;
1199 return 0;
1201 return l % r;
1205 return max_value;
1209 return min_value;
1211 return l + r;
1215 return min_value;
1219 return max_value;
1221 return l - r;
1225 return (int64_t)((uint64_t)l << (r & 63));
1228 return s64_shr(l, r & 63);
1230 return l < r ? 1 : 0;
1232 return l <= r ? 1 : 0;
1234 return l > r ? 1 : 0;
1236 return l >= r ? 1 : 0;
1238 return l == r ? 1 : 0;
1240 return l != r ? 1 : 0;
1242 return l & r;
1244 return l ^ r;
1246 return l | r;
1319 return cn;
1352 return ntn;
1409 return build_integer_constant(PTRDIFF_TSPEC,
1421 return build_op(op, sys, ln->tn_type, ln, cn);
1429 return;
1432 return;
1436 return;
1439 return;
1441 return;
1461 return;
1469 return;
1507 return build_op(op, sys, ln->tn_type, ln, prod);
1523 return build_op(DIV, sys, ptrdiff, raw_diff, elsz);
1526 return build_op(op, sys, ln->tn_type, ln, rn);
1538 return build_op(op, sys, ln->tn_type, ln, rn);
1549 return ((t == PTR && tn->tn_type->t_subt->t_tspec == VOID)
1554 /* Return a type based on tp1, with added qualifiers from tp2. */
1568 return tp1;
1576 return ntp;
1600 return NULL;
1628 return build_op(COLON, sys, tp, ln, rn);
1639 return nt == BOOL && ot == BOOL;
1644 return nw >= ow;
1645 return is_uinteger(ot) && nw > ow;
1649 return is_complex(nt) && is_complex(ot) &&
1653 return size_in_bits(nt) >= size_in_bits(ot);
1657 return false;
1659 return false;
1665 return true;
1668 return false;
1675 return op == ASSIGN ||
1686 op == RETURN ||
1711 if ((op == ASSIGN || op == RETURN || op == INIT) &&
1716 if (op == RETURN)
1717 /* cannot return incomplete type */
1722 return NULL;
1752 return build_op(op, sys, ln->tn_type, ln, rn);
1784 return NULL;
1789 return ntn;
1796 return false;
1801 return *cop = oop, true;
1802 return false;
1807 return *cop = oop, true;
1808 return false;
1814 return *cop = oop, true;
1815 return false;
1831 return;
1875 return build_constant(tn->tn_type, v);
1882 return lv < 0 ? -FLT_MAX : FLT_MAX;
1884 return lv < 0 ? -DBL_MAX : DBL_MAX;
1904 return lv < 0 ? -max : max;
1911 return true;
1913 return true;
1915 return true;
1916 return false;
2001 return build_constant(tn->tn_type, v);
2008 return;
2040 /* If there was an error in one of the operands, return. */
2042 return NULL;
2055 op != ASSIGN && op != RETURN && op != INIT)
2075 return NULL;
2117 case RETURN:
2156 return NULL;
2178 return ntn;
2184 return build_binary(tn, op, sys, NULL);
2191 return false;
2197 return false;
2199 return false;
2202 return false;
2204 return false;
2206 return true;
2210 * Return whether all struct/union members with the same name have the same
2228 return false;
2231 return true;
2242 return mem;
2252 return nested_mem;
2255 return NULL;
2303 return nested_mem;
2308 return msym;
2324 return msym;
2352 return msym;
2361 return NULL;
2367 return build_binary(ln, op, sys, build_name(msym, false));
2404 return tn;
2412 return tn;
2423 return true;
2435 return true;
2443 return false;
2456 return true;
2462 return false;
2476 return false;
2481 return true;
2496 return false;
2501 return false;
2506 return false;
2511 return false;
2513 return true;
2523 return false;
2525 return true;
2559 return false;
2561 return true;
2573 return false;
2580 return true;
2591 return;
2596 return;
2604 return;
2665 return;
2686 return true;
2688 return true;
2689 return false;
2702 if (op == RETURN)
2711 if (op == RETURN)
2739 return;
2744 return;
2762 return true;
2766 return true;
2770 return false;
2777 return true;
2786 return false;
2789 return true;
2807 return;
2811 return;
2822 return true;
2824 return true;
2827 return true;
2829 return true;
2832 return true;
2834 return true;
2842 return true;
2849 return true;
2854 return true;
2859 return false;
2871 return true;
2874 return true;
2876 return false;
2882 if (op == RETURN || op == INIT || op == FARG)
2883 return true;
2892 return false;
2899 return true;
2908 return true;
2912 return false;
2918 return false;
2923 return false;
2929 return false;
2932 return true;
2942 return;
2947 return;
2956 case RETURN:
2979 return true;
2981 return false;
2988 return strcmp(name, "memchr") == 0 ||
3012 return true;
3015 return tp->t_tspec == PTR &&
3024 return tp->t_tspec == PTR && tp->t_subt->t_const;
3062 return false;
3072 case RETURN:
3093 return true;
3103 return false;
3110 case RETURN:
3126 return true;
3135 return false;
3142 return true;
3155 case RETURN:
3156 /* function has return type '%s' but returns '%s' */
3170 * Checks type compatibility for ASSIGN, INIT, FARG and RETURN
3187 return true;
3190 return true;
3193 return ltp->u.sou == rtp->u.sou;
3199 return true;
3206 return true;
3209 return true;
3212 return true;
3215 return false;
3224 return true;
3227 return has_side_effect(tn->u.ops.left);
3230 return has_side_effect(tn->u.ops.right);
3233 return has_side_effect(tn->u.ops.right);
3236 return has_side_effect(tn->u.ops.left) ||
3240 return false;
3247 return tn->tn_op == CVT && tn->tn_cast &&
3255 return tn->tn_op == LOAD &&
3264 return tn->tn_op == CON &&
3295 return typeok_arrow(lt);
3297 return typeok_point(ln, ltp, lt);
3302 return typeok_incdec(op, ln, ltp);
3304 return typeok_indir(ltp, lt);
3306 return typeok_address(op, ln, ltp, lt);
3308 return typeok_plus(op, ltp, lt, rtp, rt);
3310 return typeok_minus(op, ltp, lt, rtp, rt);
3324 return typeok_compare(op, ln, ltp, lt, rn, rtp, rt);
3331 return typeok_quest(lt, rn);
3333 return typeok_colon(ln, ltp, lt, rn, rtp, rt);
3337 case RETURN:
3339 return false;
3349 return false;
3365 return typeok_assign(op, ln, ltp, lt);
3373 return true;
3381 return;
3387 return;
3412 case RETURN:
3413 /* function has return type '%s' but returns '%s' */
3434 return;
3445 return;
3455 case RETURN:
3456 /* combination of '%s' and '%s' in return */
3484 /* Perform most type checks. Return whether the types are ok. */
3499 return false;
3501 return false;
3504 return false;
3507 return true;
3516 return UINT;
3518 return INT;
3520 return DOUBLE;
3522 return INT;
3523 return t;
3540 return INT;
3542 return is_uinteger(t) ? UINT : INT;
3543 return t;
3547 return INT;
3549 return size_in_bits(CHAR) < size_in_bits(INT) ? INT : UINT;
3551 return INT;
3553 return size_in_bits(SHORT) < size_in_bits(INT) ? INT : UINT;
3555 return INT;
3557 return DOUBLE;
3558 return t;
3575 return tn;
3579 return tn;
3586 return convert(op, 0, ntp, tn);
3598 return;
3628 return false;
3631 return false;
3637 return true;
3642 return portable_rank_cmp(ot, INT) > 0;
3646 return false;
3655 return false;
3657 return true;
3674 return;
3683 return;
3708 return true;
3714 return true;
3720 return false;
3739 return !can_represent(ntp, otn);
3741 return false;
3750 return;
3753 return;
3793 return;
3795 return; /* We already got an error. */
3797 return;
3812 return struct_tp->u.sou->sou_first_member != NULL &&
3821 return tp->t_tspec == ARRAY &&
3831 return true;
3833 return false;
3849 return false;
3852 return false;
3855 return false; /* for the sake of traditional C code */
3857 return false; /* for the sake of traditional C code */
3868 return false;
3870 return false;
3872 return false;
3879 return false;
3883 return nstp->u.sou != ostp->u.sou;
3888 return true;
3890 return portable_rank_cmp(nst, ost) != 0;
3912 return;
3915 return;
3919 return;
3999 return ntn;
4086 return false;
4087 return true;
4254 return;
4290 return tn;
4331 return tn;
4388 return elem * elsz;
4398 return NULL;
4403 return NULL;
4408 return NULL;
4413 return NULL;
4415 return build_integer_constant(SIZEOF_TSPEC, (int64_t)alignment(tp));
4425 return NULL;
4434 return ntn;
4440 return NULL;
4460 return build_integer_constant(SIZEOF_TSPEC, (int64_t)off);
4462 return tn;
4470 return NULL;
4485 return cast_to_union(tn, sys, tp);
4495 return NULL;
4520 return tn;
4525 return NULL;
4571 return tn;
4605 return;
4610 return;
4636 return strcmp(name, "__atomic_load_n") == 0
4662 return call->args[0]->tn_type->t_subt;
4663 return func->tn_type->t_subt->t_subt;
4671 return NULL;
4683 return NULL;
4693 return ntn;
4697 * Return the value of an integral constant expression.
4717 return v;
4728 return v;
4744 return v;
4762 return;
4803 return;
4808 return;
4847 return true;
4848 return false;
4942 * retval_discarded whether the return value of a function call
4955 return;
4958 return;
4973 return;
5020 * Return whether the expression can be used for static initialization.
5044 return constant_addr(tn->u.ops.right, symp, offsp);
5046 return false;
5053 return false;
5059 return false;
5061 return false;
5065 return true;
5070 return true;
5074 return true;
5080 return false;
5095 return -1;
5097 return constant_addr(tn->u.ops.left, symp, offsp);
5099 return false;
5111 return s1;
5124 return s1;
5181 return tn;
5187 return stmt_exprs != NULL;
Indexes created Sat Oct 25 16:10:12 GMT 2025