gcc/cp/call.c

882   struct z_candidate *candidates;
905   candidates = 0;
932 	      cand = add_template_candidate (&candidates,
953 		      candidates = candidates->next;
960 	    cand = add_function_candidate (&candidates, f, s, arglist,
984   candidates = splice_viable (candidates, pedantic, &any_viable_p);
990   cand = tourney (candidates);
1269 /* Add a new entry to the list of candidates.  Used by the add_*_candidate
1273 add_candidate (struct z_candidate **candidates,
1289   cand->next = *candidates;
1290   *candidates = cand;
1303 add_function_candidate (struct z_candidate **candidates,
1428   return add_candidate (candidates, fn, orig_arglist, len, convs,
1444 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1464   if (*candidates && (*candidates)->fn == totype)
1508   return add_candidate (candidates, totype, arglist, len, convs,
1513 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1560   add_candidate (candidates, fnname, /*args=*/NULL_TREE,
1590 /* Create any builtin operator overload candidates for the operator in
1596    If CODE is requires candidates operands of the same type of the kind
1597    of which TYPE1 and TYPE2 are, we add both candidates
1601 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1959 	 below will actually create two candidates; one in which both
1969      we need candidates for both of them.  */
1980 	(candidates, fnname, type1, type1, args, argtypes, flags);
1982 	(candidates, fnname, type2, type2, args, argtypes, flags);
1987     (candidates, fnname, type1, type2, args, argtypes, flags);
2000 /* There are three conditions of builtin candidates:
2002    1) bool-taking candidates.  These are the same regardless of the input.
2003    2) pointer-pair taking candidates.  These are generated for each type
2005    3) arithmetic candidates.  According to the standard, we should generate
2008    Here we generate a superset of the possible candidates for this particular
2014 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2057 	(candidates, fnname, boolean_type_node,
2064 	(candidates, fnname, boolean_type_node,
2160      creating candidates with those parameter types.  */
2166 	    (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2170 	  (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2189 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2255     cand = add_conv_candidate (candidates, fn, obj, access_path,
2258     cand = add_function_candidate (candidates, fn, ctype,
2288 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2294     add_template_candidate_real (candidates, tmpl, ctype,
2302 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2307     add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2312 /* The CANDS are the set of candidates that were considered for
2313    overload resolution.  Return the set of viable candidates.  If none
2314    of the candidates were viable, set *ANY_VIABLE_P to true.  STRICT_P
2421 print_z_candidates (struct z_candidate *candidates)
2427   /* There may be duplicates in the set of candidates.  We put off
2432   for (cand1 = candidates; cand1; cand1 = cand1->next)
2435       /* Skip builtin candidates and conversion functions.  */
2449   if (!candidates)
2452   str = _("candidates are:");
2453   print_z_candidate (str, candidates);
2454   if (candidates->next)
2456       /* Indent successive candidates by the width of the translation
2463       candidates = candidates->next;
2466 	  print_z_candidate (spaces, candidates);
2467 	  candidates = candidates->next;
2469       while (candidates);
2510   struct z_candidate *candidates, *cand;
2530   candidates = 0;
2554 	cand = add_template_candidate (&candidates, ctor, totype,
2561 	cand = add_function_candidate (&candidates, ctor, totype,
2598 	    cand = add_template_candidate (&candidates, fn, fromtype,
2606 	    cand = add_function_candidate (&candidates, fn, fromtype,
2624 	      else if (candidates->viable == 1 && ics->bad_p)
2630   candidates = splice_viable (candidates, pedantic, &any_viable_p);
2634   cand = tourney (candidates);
2641 	  print_z_candidates (candidates);
2644       cand = candidates;	/* any one will do */
2647       if (!any_strictly_viable (candidates))
2649       /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2718    candidates considered, and ANY_VIABLE_P will be set to true or
2719    false to indicate whether or not any of the candidates were
2728 			     struct z_candidate **candidates,
2735   *candidates = NULL;
2757 		  candidates);
2759   *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2763   cand = tourney (*candidates);
2773   struct z_candidate *candidates, *cand;
2801   cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2805       if (!any_viable_p && candidates && ! candidates->next)
2806 	return build_function_call (candidates->fn, args);
2815       if (candidates)
2816 	print_z_candidates (candidates);
2840   struct z_candidate *candidates;
2861   cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2873       if (candidates)
2874 	print_z_candidates (candidates);
2928   struct z_candidate *candidates = 0, *cand;
2969 	    add_template_candidate (&candidates, fn, base, NULL_TREE,
2976 	      (&candidates, fn, base, mem_args, TYPE_BINFO (type),
3000 		(&candidates, fn, obj, args, totype,
3004 	      add_conv_candidate (&candidates, fn, obj, args,
3010   candidates = splice_viable (candidates, pedantic, &any_viable_p);
3014       print_z_candidates (candidates);
3019       cand = tourney (candidates);
3023 	  print_z_candidates (candidates);
3164   struct z_candidate *candidates = 0;
3379       add_builtin_candidates (&candidates,
3390       candidates = splice_viable (candidates, pedantic, &any_viable_p);
3394 	  print_z_candidates (candidates);
3397       cand = tourney (candidates);
3401 	  print_z_candidates (candidates);
3565 		struct z_candidate **candidates)
3596 	add_template_candidate (candidates,
3607 	add_function_candidate (candidates,
3622   struct z_candidate *candidates = 0, *cand;
3698 		  flags, &candidates);
3715 			flags, &candidates);
3735   add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3741       /* For these, the built-in candidates set is empty
3755   candidates = splice_viable (candidates, strict_p, &any_viable_p);
3789 	      print_z_candidates (candidates);
3797       cand = tourney (candidates);
3803 	      print_z_candidates (candidates);
3920       return build_unary_op (code, arg1, candidates != 0);
5267   struct z_candidate *candidates = 0, *cand;
5388 	add_template_candidate (&candidates, t,
5397 	add_function_candidate (&candidates, t,
5405   candidates = splice_viable (candidates, pedantic, &any_viable_p);
5422       print_z_candidates (candidates);
5427       cand = tourney (candidates);
5436 	  print_z_candidates (candidates);
5987 /* Compare two candidates for overloading as described in
6009   /* If we have two pseudo-candidates for conversions to the same type,
6010      or two candidates for the same function, arbitrarily pick one.  */
6192      have two identical ones or matching builtin and non-builtin candidates.
6198      ... the builtin candidates include ...
6212 	    /* Two built-in candidates; arbitrarily pick one.  */
6270 /* Given a list of candidates for overloading, find the best one, if any.
6276 tourney (struct z_candidate *candidates)
6278   struct z_candidate *champ = candidates, *challenger;
6309   /* Make sure the champ is better than all the candidates it hasn't yet
6312   for (challenger = candidates;