From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 3292 invoked by alias); 22 Mar 2010 20:20:14 -0000 Received: (qmail 3204 invoked by uid 22791); 22 Mar 2010 20:20:04 -0000 X-SWARE-Spam-Status: No, hits=-5.5 required=5.0 tests=AWL,BAYES_40,KAM_STOCKGEN,RCVD_IN_DNSWL_HI,SPF_HELO_PASS X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Mon, 22 Mar 2010 20:19:52 +0000 Received: from int-mx01.intmail.prod.int.phx2.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) by mx1.redhat.com (8.13.8/8.13.8) with ESMTP id o2MKJpa2022773 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Mon, 22 Mar 2010 16:19:51 -0400 Received: from [10.15.16.55] (toner.yyz.redhat.com [10.15.16.55]) by int-mx01.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id o2MKJo8H004062 for ; Mon, 22 Mar 2010 16:19:50 -0400 Message-ID: <4BA7D08C.5070702@redhat.com> Date: Mon, 22 Mar 2010 20:20:00 -0000 From: Sami Wagiaalla User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.1.7) Gecko/20100120 Fedora/3.0.1-1.fc12 Lightning/1.0b1 Thunderbird/3.0.1 MIME-Version: 1.0 To: GDB Patches Subject: [patch] support argument dependent lookup (ADL) Content-Type: multipart/mixed; boundary="------------020009050004080209010203" X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2010-03/txt/msg00775.txt.bz2 This is a multi-part message in MIME format. --------------020009050004080209010203 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit Content-length: 20794 supports printing of variables in this manner: namespace A { class B {} void foo(B){} } int main(){ A::B b; // (gdb) p foo(B) return 0; } foo is found by searching the namespaces which its arguments belong to. 2010-03-22 Sami Wagiaalla PR C++/7943: * valops.c (find_overload_match): Handle fsym == NULL case. (find_oload_champ_namespace_loop): Call make_symbol_overload_list_adl when appropriate. * parse.c (operator_length_standard): Return length for OP_ADL_FUNC expression. * expprint.c (op_name_standard): Added string for OP_ADL_FUNC case. * eval.c (evaluate_subexp_standard): Added OP_ADL_FUNC case. Evaluate arguments and use them to perform ADL lookup. * cp-support.h: Added prototype for make_symbol_overload_list_namespace. * cp-support.c (make_symbol_overload_list_namespace): New function. (make_symbol_overload_list_adl_namespace): New function. (make_symbol_overload_list_adl): New function. (make_symbol_overload_list_using): Moved code to add function to overload set to make_symbol_overload_list_namespace. * c-exp.y: create UNKNOWN_CPP_NAME token. Add parse rule for ADL functions. (classify_name): Recognize an UNKNOWN_CPP_NAME. 2010-03-22 Sami Wagiaalla * gdb.cp/koenig.exp: New test. * gdb.cp/koenig.cc: New test program. diff --git a/gdb/c-exp.y b/gdb/c-exp.y index 1af76c9..d93815d 100644 --- a/gdb/c-exp.y +++ b/gdb/c-exp.y @@ -186,6 +186,7 @@ static struct stoken operator_stoken (const char *); %token STRING %token CHAR %token NAME /* BLOCKNAME defined below to give it higher precedence. */ +%token UNKNOWN_CPP_NAME %token COMPLETE %token TYPENAME %type name @@ -391,6 +392,30 @@ exp : exp '(' write_exp_elt_opcode (OP_FUNCALL); } ; +exp : UNKNOWN_CPP_NAME '(' + { + + /* This could potentially be a an argument defined + lookup function (Koenig). */ + write_exp_elt_opcode (OP_ADL_FUNC); + write_exp_elt_block (expression_context_block); + write_exp_elt_sym (NULL); /* Place holder */ + write_exp_string ($1.stoken); + write_exp_elt_opcode (OP_ADL_FUNC); + + /* This is to save the value of arglist_len + being accumulated by an outer function call. */ + + start_arglist (); + } + arglist ')' %prec ARROW + { + write_exp_elt_opcode (OP_FUNCALL); + write_exp_elt_longcst ((LONGEST) end_arglist ()); + write_exp_elt_opcode (OP_FUNCALL); + } + ; + lcurly : '{' { start_arglist (); } ; @@ -1224,6 +1249,7 @@ name : NAME { $$ = $1.stoken; } | BLOCKNAME { $$ = $1.stoken; } | TYPENAME { $$ = $1.stoken; } | NAME_OR_INT { $$ = $1.stoken; } + | UNKNOWN_CPP_NAME { $$ = $1.stoken; } | operator { $$ = $1; } ; @@ -1236,6 +1262,7 @@ name_not_typename : NAME context where only a name could occur, this might be useful. | NAME_OR_INT */ + | UNKNOWN_CPP_NAME ; %% @@ -2379,6 +2406,12 @@ classify_name (struct block *block) /* Any other kind of symbol */ yylval.ssym.sym = sym; yylval.ssym.is_a_field_of_this = is_a_field_of_this; + + if (sym == NULL + && parse_language->la_language == language_cplus + && !lookup_minimal_symbol (copy, NULL, NULL)) + return UNKNOWN_CPP_NAME; + return NAME; } diff --git a/gdb/cp-support.c b/gdb/cp-support.c index d43d25f..8c18304 100644 --- a/gdb/cp-support.c +++ b/gdb/cp-support.c @@ -52,7 +52,7 @@ static void demangled_name_complaint (const char *name); /* Functions/variables related to overload resolution. */ -static int sym_return_val_size; +static int sym_return_val_size = -1; static int sym_return_val_index; static struct symbol **sym_return_val; @@ -712,6 +712,83 @@ make_symbol_overload_list (const char *func_name, return sym_return_val; } +/* Adds the function FUNC_NAME from NAMESPACE to the overload set. */ + +static void +make_symbol_overload_list_namespace (const char *func_name, + const char *namespace) +{ + + if (namespace[0] == '\0') + { + make_symbol_overload_list_qualified (func_name); + } + else + { + char *concatenated_name + = alloca (strlen (namespace) + 2 + strlen (func_name) + 1); + strcpy (concatenated_name, namespace); + strcat (concatenated_name, "::"); + strcat (concatenated_name, func_name); + make_symbol_overload_list_qualified (concatenated_name); + } +} + +/* Search the namespace of the given type and namespace of and public base + types. */ +static void make_symbol_overload_list_adl_namespace (struct type *type, + const char *func_name) +{ + char *namespace; + char *type_name; + int i, prefix_len; + + if (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF + || TYPE_CODE (type) == TYPE_CODE_ARRAY) + return make_symbol_overload_list_adl_namespace (TYPE_TARGET_TYPE (type), + func_name); + + type_name = TYPE_NAME (type); + + prefix_len = cp_entire_prefix_len (type_name); + + if (prefix_len != 0) + { + namespace = alloca (prefix_len + 1); + strncpy (namespace, type_name, prefix_len); + namespace[prefix_len] = '\0'; + + make_symbol_overload_list_namespace (func_name, namespace); + } + + /* Check public base type */ + if (TYPE_CODE(type) == TYPE_CODE_CLASS) + for (i = 0; i < TYPE_N_BASECLASSES (type); i++) + { + if (BASETYPE_VIA_PUBLIC (type, i)) + make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type, i), + func_name); + } + +} + +/* Adds the the overload list overload candidates for FUNC_NAME found through + argument dependent lookup. */ + +struct symbol ** +make_symbol_overload_list_adl (struct type **arg_types, int nargs, + const char *func_name) +{ + int i; + + gdb_assert (sym_return_val_size != -1); + + for (i = 1; i <= nargs; i++) + make_symbol_overload_list_adl_namespace (arg_types[i - 1], func_name); + + return sym_return_val; +} + /* This applies the using directives to add namespaces to search in, and then searches for overloads in all of those namespaces. It adds the symbols found to sym_return_val. Arguments are as in @@ -739,20 +816,7 @@ make_symbol_overload_list_using (const char *func_name, } /* Now, add names for this namespace. */ - - if (namespace[0] == '\0') - { - make_symbol_overload_list_qualified (func_name); - } - else - { - char *concatenated_name - = alloca (strlen (namespace) + 2 + strlen (func_name) + 1); - strcpy (concatenated_name, namespace); - strcat (concatenated_name, "::"); - strcat (concatenated_name, func_name); - make_symbol_overload_list_qualified (concatenated_name); - } + make_symbol_overload_list_namespace (func_name, namespace); } /* This does the bulk of the work of finding overloaded symbols. diff --git a/gdb/cp-support.h b/gdb/cp-support.h index e10f5a9..f92ca67 100644 --- a/gdb/cp-support.h +++ b/gdb/cp-support.h @@ -79,6 +79,10 @@ extern char *cp_remove_params (const char *demangled_name); extern struct symbol **make_symbol_overload_list (const char *, const char *); +extern struct symbol **make_symbol_overload_list_adl (struct type **arg_types, + int nargs, + const char *func_name); + extern struct type *cp_lookup_rtti_type (const char *name, struct block *block); diff --git a/gdb/eval.c b/gdb/eval.c index 3bcd417..1e1ed0e 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -731,6 +731,7 @@ evaluate_subexp_standard (struct type *expect_type, return value_from_decfloat (exp->elts[pc + 1].type, exp->elts[pc + 2].decfloatconst); + case OP_ADL_FUNC: case OP_VAR_VALUE: (*pos) += 3; if (noside == EVAL_SKIP) @@ -1453,6 +1454,17 @@ evaluate_subexp_standard (struct type *expect_type, tem = 2; } } + else if (op == OP_ADL_FUNC) + { + /* Save the function position and move pos so that the arguments + can be evaluated. */ + int func_name_len; + save_pos1 = *pos; + tem = 1; + + func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst); + (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1); + } else { /* Non-method function call */ @@ -1483,6 +1495,32 @@ evaluate_subexp_standard (struct type *expect_type, /* signal end of arglist */ argvec[tem] = 0; + if (op == OP_ADL_FUNC) + { + struct symbol *symp; + char *func_name; + int name_len; + int string_pc = save_pos1 + 3; + + /* Extract the function name. */ + name_len = longest_to_int (exp->elts[string_pc].longconst); + func_name = (char *) alloca (name_len + 1); + strcpy (func_name, &exp->elts[string_pc + 1].string); + + /* Prepare list of argument types for overload resolution */ + arg_types = (struct type **) alloca (nargs * (sizeof (struct type *))); + for (ix = 1; ix <= nargs; ix++) + arg_types[ix - 1] = value_type (argvec[ix]); + + find_overload_match (arg_types, nargs, func_name, + 0 /* not method */ , 0 /* strict match */ , + NULL, NULL /* pass NULL symbol since symbol is unknown */ , + NULL, &symp, NULL); + + /* Now fix the expression being evaluated. */ + exp->elts[save_pos1 + 2].symbol = symp; + argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside); + } if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR || (op == OP_SCOPE && function_name != NULL)) diff --git a/gdb/expprint.c b/gdb/expprint.c index e378831..45deffe 100644 --- a/gdb/expprint.c +++ b/gdb/expprint.c @@ -816,6 +816,8 @@ op_name_standard (enum exp_opcode opcode) return "OP_TYPE"; case OP_LABELED: return "OP_LABELED"; + case OP_ADL_FUNC: + return "OP_ADL_FUNC"; } } diff --git a/gdb/expression.h b/gdb/expression.h index ca216cf..29ebde4 100644 --- a/gdb/expression.h +++ b/gdb/expression.h @@ -347,6 +347,10 @@ enum exp_opcode Then comes another OP_DECFLOAT. */ OP_DECFLOAT, + /* OP_ADL_FUNC specifies that the function is to be looked up in an + Argument Dependent manner (Koenig lookup). */ + OP_ADL_FUNC, + /* First extension operator. Individual language modules define extra operators in *.inc include files below always starting with numbering at OP_EXTENDED0: diff --git a/gdb/parse.c b/gdb/parse.c index aabc461..b607c71 100644 --- a/gdb/parse.c +++ b/gdb/parse.c @@ -889,6 +889,13 @@ operator_length_standard (struct expression *expr, int endpos, args = 1; break; + case OP_ADL_FUNC: + oplen = longest_to_int (expr->elts[endpos - 2].longconst); + oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1); + oplen++; + oplen++; + break; + case OP_LABELED: case STRUCTOP_STRUCT: case STRUCTOP_PTR: diff --git a/gdb/testsuite/gdb.cp/koenig.cc b/gdb/testsuite/gdb.cp/koenig.cc new file mode 100644 index 0000000..6c2c01d --- /dev/null +++ b/gdb/testsuite/gdb.cp/koenig.cc @@ -0,0 +1,188 @@ +namespace A +{ + class C + { + public: + static const int x = 11; + }; + + int + first (C c) + { + return 11; + } + + int + first (int a, C c) + { + return 22; + } + + int + second (int a, int b, C cc, int c, int d) + { + return 33; + } + +} + +struct B +{ + A::C c; +}; + +//------------ + +namespace E +{ + class O{}; + int foo (O o){return 1; } + int foo (O o, O o2){return 2; } + int foo (O o, O o2, int i){return 3; } +} + +namespace F +{ + class O{}; + int foo ( O fo, ::E::O eo){ return 4;} + int foo (int i, O fo, ::E::O eo){ return 5;} +} + +namespace G +{ + class O{}; + int foo (O go, ::F::O fo, ::E::O eo){ return 6; } +} + +//------------ + +namespace H +{ + class O{}; + int foo (O){ return 7;} +} + +namespace I +{ + class O: public H::O {}; + class X: H::O{}; +} + +//------------ + +namespace J +{ + union U{}; + struct S{}; + enum E{}; + + class A{ + public: + class B{}; + }; + + class C{}; + + int foo (U){ return 8;} + int foo (S){ return 9;} + int foo (E){ return 10;} + int foo (A::B){ return 11;} + int foo (A*){ return 12;} + int foo (A**){ return 13;} + int foo (C[]){ return 14;} + +} +//------------ + +namespace K{ + class O{}; + + int foo(O, int){ + return 15; + } + + int bar(O, int){ + return 15; + } +} + +int foo(K::O, float){ + return 16; +} + +int bar(K::O, int){ + return 16; +} +//------------ + +namespace L { + namespace A{ + namespace B{ + class O {}; + + int foo (O){ + return 17; + } + + } + } +} + +//------------ +int +main () +{ + A::C c; + B b; + + A::first (c); + first (0, c); + second (0, 0, c, 0, 0); + A::first (b.c); + + E::O eo; + F::O fo; + G::O go; + + foo (eo); + foo (eo, eo); + foo (eo, eo, 1); + foo (fo, eo); + foo (1 ,fo, eo); + foo (go, fo, eo); + + I::O io; + I::X ix; + + foo (io); +//foo (ix); + + J::U ju; + J::S js; + J::E je; + J::A::B jab; + J::A *jap; + J::A **japp; + J::C jca[3]; + + foo (ju); + foo (js); + foo (je); + foo (jab); + foo (jap); + foo (japp); + foo (jca); + + K::O ko; + foo (ko, 1); + foo (ko, 1.0f); + //bar(ko,1); + + L::A::B::O labo; + foo (labo); + + return first (0, c) + foo (eo) + + foo (eo, eo) + foo (eo, eo, 1) + + foo (fo, eo) + foo (1 ,fo, eo) + + foo (go, fo, eo); +} diff --git a/gdb/testsuite/gdb.cp/koenig.exp b/gdb/testsuite/gdb.cp/koenig.exp new file mode 100644 index 0000000..cebf045 --- /dev/null +++ b/gdb/testsuite/gdb.cp/koenig.exp @@ -0,0 +1,95 @@ +# Copyright 2008 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +if $tracelevel then { + strace $tracelevel +} + +set prms_id 0 +set bug_id 0 + +set testfile koenig +set srcfile ${testfile}.cc +set binfile ${objdir}/${subdir}/${testfile} +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } { + untested "Couldn't compile test program" + return -1 +} + +# Get things started. + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + +############################################ + +if ![runto_main] then { + perror "couldn't run to breakpoint main" + continue +} + +# Test that koenig lookup finds correct function +gdb_test "p first(c)" "= 11" + +# Change the number of parameters and position of +# the qualifying parameter +gdb_test "p second(0,0,c,0,0)" "= 33" + +# Test that koenig lookup finds correct function +# even if it is overloaded +gdb_test "p first(0,c)" "= 22" + +# Test that koenig lookup finds correct function +# when the argument is an expression +gdb_test "p first(b.c)" "= 11" + +# test that resolutions can be made across namespaces +gdb_test "p foo(eo)" "= 1" +gdb_test "p foo(eo, eo)" "= 2" +gdb_test "p foo(eo, eo, 1)" "= 3" +gdb_test "p foo(fo, eo)" "= 4" +gdb_test "p foo(1 ,fo, eo)" "= 5" +gdb_test "p foo(go, fo, eo)" "= 6" + +#test that gdb fails gracefully +gdb_test "p fake(eo)" "No symbol \"fake\" in current context." + +#test that namespaces of base classes are searched +gdb_test "p foo(io)" "= 7" +gdb_test "p foo(ix)" "Cannot resolve function foo to any overloaded instance" + +#test for other types +gdb_test "p foo(ju)" "= 8" +gdb_test "p foo(js)" "= 9" +gdb_test "p foo(je)" "= 10" + +#test for class members +setup_xfail "*-*-*" +gdb_test "p foo(jab)" "= 11" + +gdb_test "p foo(jap)" "= 12" +gdb_test "p foo(japp)" "= 13" +gdb_test "p foo(jca)" "= 14" + +#test overload resolution +gdb_test "p foo(ko,1)" "= 15" +gdb_test "p foo(ko,1.0f)" "= 16" +setup_xfail "*-*-*" +gdb_test "p bar(ko,1)" "= -1" + +#test lookup of objects belonging to nested namespaces +gdb_test "p foo(labo)" "= 17" diff --git a/gdb/valops.c b/gdb/valops.c index 4a7a334..1cd44f8 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -2336,10 +2336,10 @@ find_overload_match (struct type **arg_types, int nargs, int boffset; int ix; int static_offset; - struct cleanup *old_cleanups = NULL; + struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL); const char *obj_type_name = NULL; - char *func_name = NULL; + const char *func_name = NULL; enum oload_classification match_quality; /* Get the list of overloaded methods or functions. */ @@ -2384,24 +2384,39 @@ find_overload_match (struct type **arg_types, int nargs, } else { - const char *qualified_name = SYMBOL_NATURAL_NAME (fsym); + const char *qualified_name = NULL; - /* If we have a function with a C++ name, try to extract just - the function part. Do not try this for non-functions (e.g. - function pointers). */ - if (qualified_name - && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym))) == TYPE_CODE_FUNC) + if (fsym) + { + qualified_name = SYMBOL_NATURAL_NAME (fsym); + + /* If we have a function with a C++ name, try to extract just + the function part. Do not try this for non-functions (e.g. + function pointers). */ + if (qualified_name + && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym))) == TYPE_CODE_FUNC) + { + char *temp; + + temp = cp_func_name (qualified_name); + + /* If cp_func_name did not remove anything, the name of the + symbol did not include scope or argument types - it was + probably a C-style function. */ + if (temp) + { + make_cleanup (xfree, temp); + if (strcmp (temp, qualified_name) == 0) + func_name = NULL; + else + func_name = temp; + } + } + } + else { - func_name = cp_func_name (qualified_name); - - /* If cp_func_name did not remove anything, the name of the - symbol did not include scope or argument types - it was - probably a C-style function. */ - if (func_name && strcmp (func_name, qualified_name) == 0) - { - xfree (func_name); - func_name = NULL; - } + func_name = name; + qualified_name = name; } /* If there was no C++ name, this must be a C-style function or @@ -2413,7 +2428,6 @@ find_overload_match (struct type **arg_types, int nargs, return 0; } - old_cleanups = make_cleanup (xfree, func_name); make_cleanup (xfree, oload_syms); make_cleanup (xfree, oload_champ_bv); @@ -2424,8 +2438,11 @@ find_overload_match (struct type **arg_types, int nargs, &oload_champ_bv); } - /* Check how bad the best match is. */ + /* Did we find a match ? */ + if (oload_champ == -1) + error ("No symbol \"%s\" in current context.", name); + /* Check how bad the best match is. */ match_quality = classify_oload_match (oload_champ_bv, nargs, oload_method_static (method, fns_ptr, @@ -2482,8 +2499,8 @@ find_overload_match (struct type **arg_types, int nargs, } *objp = temp; } - if (old_cleanups != NULL) - do_cleanups (old_cleanups); + + do_cleanups (all_cleanups); switch (match_quality) { @@ -2591,6 +2608,12 @@ find_oload_champ_namespace_loop (struct type **arg_types, int nargs, new_namespace[namespace_len] = '\0'; new_oload_syms = make_symbol_overload_list (func_name, new_namespace); + + /* If we have reached the deepesst level perform argument + determined lookup. */ + if (!searched_deeper) + make_symbol_overload_list_adl (arg_types, nargs, func_name); + while (new_oload_syms[num_fns]) ++num_fns; @@ -2623,7 +2646,6 @@ find_oload_champ_namespace_loop (struct type **arg_types, int nargs, } else { - gdb_assert (new_oload_champ != -1); *oload_syms = new_oload_syms; *oload_champ = new_oload_champ; *oload_champ_bv = new_oload_champ_bv; --------------020009050004080209010203 Content-Type: text/plain; name="adl.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="adl.patch" Content-length: 20565 2010-03-22 Sami Wagiaalla PR C++/7943: * valops.c (find_overload_match): Handle fsym == NULL case. (find_oload_champ_namespace_loop): Call make_symbol_overload_list_adl when appropriet. * parse.c (operator_length_standard): Return length for OP_ADL_FUNC expression. * expprint.c (op_name_standard): Added string for OP_ADL_FUNC case. * eval.c (evaluate_subexp_standard): Added OP_ADL_FUNC case. Evaluate arguments and use them to perform ADL lookup. * cp-support.h: Added prototype for make_symbol_overload_list_namespace. * cp-support.c (make_symbol_overload_list_namespace): New function. (make_symbol_overload_list_adl_namespace): New function. (make_symbol_overload_list_adl): New function. (make_symbol_overload_list_using): Moved code to add function to overload set to make_symbol_overload_list_namespace. * c-exp.y: create UNKNOWN_CPP_NAME token. Add parse rule for ADL functions. (classify_name): Recognize an UNKNOWN_CPP_NAME. 2010-03-22 Sami Wagiaalla * gdb.cp/koenig.exp: New test. * gdb.cp/koenig.cc: New test program. diff --git a/gdb/c-exp.y b/gdb/c-exp.y index 1af76c9..d93815d 100644 --- a/gdb/c-exp.y +++ b/gdb/c-exp.y @@ -186,6 +186,7 @@ static struct stoken operator_stoken (const char *); %token STRING %token CHAR %token NAME /* BLOCKNAME defined below to give it higher precedence. */ +%token UNKNOWN_CPP_NAME %token COMPLETE %token TYPENAME %type name @@ -391,6 +392,30 @@ exp : exp '(' write_exp_elt_opcode (OP_FUNCALL); } ; +exp : UNKNOWN_CPP_NAME '(' + { + + /* This could potentially be a an argument defined + lookup function (Koenig). */ + write_exp_elt_opcode (OP_ADL_FUNC); + write_exp_elt_block (expression_context_block); + write_exp_elt_sym (NULL); /* Place holder */ + write_exp_string ($1.stoken); + write_exp_elt_opcode (OP_ADL_FUNC); + + /* This is to save the value of arglist_len + being accumulated by an outer function call. */ + + start_arglist (); + } + arglist ')' %prec ARROW + { + write_exp_elt_opcode (OP_FUNCALL); + write_exp_elt_longcst ((LONGEST) end_arglist ()); + write_exp_elt_opcode (OP_FUNCALL); + } + ; + lcurly : '{' { start_arglist (); } ; @@ -1224,6 +1249,7 @@ name : NAME { $$ = $1.stoken; } | BLOCKNAME { $$ = $1.stoken; } | TYPENAME { $$ = $1.stoken; } | NAME_OR_INT { $$ = $1.stoken; } + | UNKNOWN_CPP_NAME { $$ = $1.stoken; } | operator { $$ = $1; } ; @@ -1236,6 +1262,7 @@ name_not_typename : NAME context where only a name could occur, this might be useful. | NAME_OR_INT */ + | UNKNOWN_CPP_NAME ; %% @@ -2379,6 +2406,12 @@ classify_name (struct block *block) /* Any other kind of symbol */ yylval.ssym.sym = sym; yylval.ssym.is_a_field_of_this = is_a_field_of_this; + + if (sym == NULL + && parse_language->la_language == language_cplus + && !lookup_minimal_symbol (copy, NULL, NULL)) + return UNKNOWN_CPP_NAME; + return NAME; } diff --git a/gdb/cp-support.c b/gdb/cp-support.c index d43d25f..8c18304 100644 --- a/gdb/cp-support.c +++ b/gdb/cp-support.c @@ -52,7 +52,7 @@ static void demangled_name_complaint (const char *name); /* Functions/variables related to overload resolution. */ -static int sym_return_val_size; +static int sym_return_val_size = -1; static int sym_return_val_index; static struct symbol **sym_return_val; @@ -712,6 +712,83 @@ make_symbol_overload_list (const char *func_name, return sym_return_val; } +/* Adds the function FUNC_NAME from NAMESPACE to the overload set. */ + +static void +make_symbol_overload_list_namespace (const char *func_name, + const char *namespace) +{ + + if (namespace[0] == '\0') + { + make_symbol_overload_list_qualified (func_name); + } + else + { + char *concatenated_name + = alloca (strlen (namespace) + 2 + strlen (func_name) + 1); + strcpy (concatenated_name, namespace); + strcat (concatenated_name, "::"); + strcat (concatenated_name, func_name); + make_symbol_overload_list_qualified (concatenated_name); + } +} + +/* Search the namespace of the given type and namespace of and public base + types. */ +static void make_symbol_overload_list_adl_namespace (struct type *type, + const char *func_name) +{ + char *namespace; + char *type_name; + int i, prefix_len; + + if (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF + || TYPE_CODE (type) == TYPE_CODE_ARRAY) + return make_symbol_overload_list_adl_namespace (TYPE_TARGET_TYPE (type), + func_name); + + type_name = TYPE_NAME (type); + + prefix_len = cp_entire_prefix_len (type_name); + + if (prefix_len != 0) + { + namespace = alloca (prefix_len + 1); + strncpy (namespace, type_name, prefix_len); + namespace[prefix_len] = '\0'; + + make_symbol_overload_list_namespace (func_name, namespace); + } + + /* Check public base type */ + if (TYPE_CODE(type) == TYPE_CODE_CLASS) + for (i = 0; i < TYPE_N_BASECLASSES (type); i++) + { + if (BASETYPE_VIA_PUBLIC (type, i)) + make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type, i), + func_name); + } + +} + +/* Adds the the overload list overload candidates for FUNC_NAME found through + argument dependent lookup. */ + +struct symbol ** +make_symbol_overload_list_adl (struct type **arg_types, int nargs, + const char *func_name) +{ + int i; + + gdb_assert (sym_return_val_size != -1); + + for (i = 1; i <= nargs; i++) + make_symbol_overload_list_adl_namespace (arg_types[i - 1], func_name); + + return sym_return_val; +} + /* This applies the using directives to add namespaces to search in, and then searches for overloads in all of those namespaces. It adds the symbols found to sym_return_val. Arguments are as in @@ -739,20 +816,7 @@ make_symbol_overload_list_using (const char *func_name, } /* Now, add names for this namespace. */ - - if (namespace[0] == '\0') - { - make_symbol_overload_list_qualified (func_name); - } - else - { - char *concatenated_name - = alloca (strlen (namespace) + 2 + strlen (func_name) + 1); - strcpy (concatenated_name, namespace); - strcat (concatenated_name, "::"); - strcat (concatenated_name, func_name); - make_symbol_overload_list_qualified (concatenated_name); - } + make_symbol_overload_list_namespace (func_name, namespace); } /* This does the bulk of the work of finding overloaded symbols. diff --git a/gdb/cp-support.h b/gdb/cp-support.h index e10f5a9..f92ca67 100644 --- a/gdb/cp-support.h +++ b/gdb/cp-support.h @@ -79,6 +79,10 @@ extern char *cp_remove_params (const char *demangled_name); extern struct symbol **make_symbol_overload_list (const char *, const char *); +extern struct symbol **make_symbol_overload_list_adl (struct type **arg_types, + int nargs, + const char *func_name); + extern struct type *cp_lookup_rtti_type (const char *name, struct block *block); diff --git a/gdb/eval.c b/gdb/eval.c index 3bcd417..1e1ed0e 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -731,6 +731,7 @@ evaluate_subexp_standard (struct type *expect_type, return value_from_decfloat (exp->elts[pc + 1].type, exp->elts[pc + 2].decfloatconst); + case OP_ADL_FUNC: case OP_VAR_VALUE: (*pos) += 3; if (noside == EVAL_SKIP) @@ -1453,6 +1454,17 @@ evaluate_subexp_standard (struct type *expect_type, tem = 2; } } + else if (op == OP_ADL_FUNC) + { + /* Save the function position and move pos so that the arguments + can be evaluated. */ + int func_name_len; + save_pos1 = *pos; + tem = 1; + + func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst); + (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1); + } else { /* Non-method function call */ @@ -1483,6 +1495,32 @@ evaluate_subexp_standard (struct type *expect_type, /* signal end of arglist */ argvec[tem] = 0; + if (op == OP_ADL_FUNC) + { + struct symbol *symp; + char *func_name; + int name_len; + int string_pc = save_pos1 + 3; + + /* Extract the function name. */ + name_len = longest_to_int (exp->elts[string_pc].longconst); + func_name = (char *) alloca (name_len + 1); + strcpy (func_name, &exp->elts[string_pc + 1].string); + + /* Prepare list of argument types for overload resolution */ + arg_types = (struct type **) alloca (nargs * (sizeof (struct type *))); + for (ix = 1; ix <= nargs; ix++) + arg_types[ix - 1] = value_type (argvec[ix]); + + find_overload_match (arg_types, nargs, func_name, + 0 /* not method */ , 0 /* strict match */ , + NULL, NULL /* pass NULL symbol since symbol is unknown */ , + NULL, &symp, NULL); + + /* Now fix the expression being evaluated. */ + exp->elts[save_pos1 + 2].symbol = symp; + argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside); + } if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR || (op == OP_SCOPE && function_name != NULL)) diff --git a/gdb/expprint.c b/gdb/expprint.c index e378831..45deffe 100644 --- a/gdb/expprint.c +++ b/gdb/expprint.c @@ -816,6 +816,8 @@ op_name_standard (enum exp_opcode opcode) return "OP_TYPE"; case OP_LABELED: return "OP_LABELED"; + case OP_ADL_FUNC: + return "OP_ADL_FUNC"; } } diff --git a/gdb/expression.h b/gdb/expression.h index ca216cf..29ebde4 100644 --- a/gdb/expression.h +++ b/gdb/expression.h @@ -347,6 +347,10 @@ enum exp_opcode Then comes another OP_DECFLOAT. */ OP_DECFLOAT, + /* OP_ADL_FUNC specifies that the function is to be looked up in an + Argument Dependent manner (Koenig lookup). */ + OP_ADL_FUNC, + /* First extension operator. Individual language modules define extra operators in *.inc include files below always starting with numbering at OP_EXTENDED0: diff --git a/gdb/parse.c b/gdb/parse.c index aabc461..b607c71 100644 --- a/gdb/parse.c +++ b/gdb/parse.c @@ -889,6 +889,13 @@ operator_length_standard (struct expression *expr, int endpos, args = 1; break; + case OP_ADL_FUNC: + oplen = longest_to_int (expr->elts[endpos - 2].longconst); + oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1); + oplen++; + oplen++; + break; + case OP_LABELED: case STRUCTOP_STRUCT: case STRUCTOP_PTR: diff --git a/gdb/testsuite/gdb.cp/koenig.cc b/gdb/testsuite/gdb.cp/koenig.cc new file mode 100644 index 0000000..6c2c01d --- /dev/null +++ b/gdb/testsuite/gdb.cp/koenig.cc @@ -0,0 +1,188 @@ +namespace A +{ + class C + { + public: + static const int x = 11; + }; + + int + first (C c) + { + return 11; + } + + int + first (int a, C c) + { + return 22; + } + + int + second (int a, int b, C cc, int c, int d) + { + return 33; + } + +} + +struct B +{ + A::C c; +}; + +//------------ + +namespace E +{ + class O{}; + int foo (O o){return 1; } + int foo (O o, O o2){return 2; } + int foo (O o, O o2, int i){return 3; } +} + +namespace F +{ + class O{}; + int foo ( O fo, ::E::O eo){ return 4;} + int foo (int i, O fo, ::E::O eo){ return 5;} +} + +namespace G +{ + class O{}; + int foo (O go, ::F::O fo, ::E::O eo){ return 6; } +} + +//------------ + +namespace H +{ + class O{}; + int foo (O){ return 7;} +} + +namespace I +{ + class O: public H::O {}; + class X: H::O{}; +} + +//------------ + +namespace J +{ + union U{}; + struct S{}; + enum E{}; + + class A{ + public: + class B{}; + }; + + class C{}; + + int foo (U){ return 8;} + int foo (S){ return 9;} + int foo (E){ return 10;} + int foo (A::B){ return 11;} + int foo (A*){ return 12;} + int foo (A**){ return 13;} + int foo (C[]){ return 14;} + +} +//------------ + +namespace K{ + class O{}; + + int foo(O, int){ + return 15; + } + + int bar(O, int){ + return 15; + } +} + +int foo(K::O, float){ + return 16; +} + +int bar(K::O, int){ + return 16; +} +//------------ + +namespace L { + namespace A{ + namespace B{ + class O {}; + + int foo (O){ + return 17; + } + + } + } +} + +//------------ +int +main () +{ + A::C c; + B b; + + A::first (c); + first (0, c); + second (0, 0, c, 0, 0); + A::first (b.c); + + E::O eo; + F::O fo; + G::O go; + + foo (eo); + foo (eo, eo); + foo (eo, eo, 1); + foo (fo, eo); + foo (1 ,fo, eo); + foo (go, fo, eo); + + I::O io; + I::X ix; + + foo (io); +//foo (ix); + + J::U ju; + J::S js; + J::E je; + J::A::B jab; + J::A *jap; + J::A **japp; + J::C jca[3]; + + foo (ju); + foo (js); + foo (je); + foo (jab); + foo (jap); + foo (japp); + foo (jca); + + K::O ko; + foo (ko, 1); + foo (ko, 1.0f); + //bar(ko,1); + + L::A::B::O labo; + foo (labo); + + return first (0, c) + foo (eo) + + foo (eo, eo) + foo (eo, eo, 1) + + foo (fo, eo) + foo (1 ,fo, eo) + + foo (go, fo, eo); +} diff --git a/gdb/testsuite/gdb.cp/koenig.exp b/gdb/testsuite/gdb.cp/koenig.exp new file mode 100644 index 0000000..cebf045 --- /dev/null +++ b/gdb/testsuite/gdb.cp/koenig.exp @@ -0,0 +1,95 @@ +# Copyright 2008 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +if $tracelevel then { + strace $tracelevel +} + +set prms_id 0 +set bug_id 0 + +set testfile koenig +set srcfile ${testfile}.cc +set binfile ${objdir}/${subdir}/${testfile} +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } { + untested "Couldn't compile test program" + return -1 +} + +# Get things started. + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + +############################################ + +if ![runto_main] then { + perror "couldn't run to breakpoint main" + continue +} + +# Test that koenig lookup finds correct function +gdb_test "p first(c)" "= 11" + +# Change the number of parameters and position of +# the qualifying parameter +gdb_test "p second(0,0,c,0,0)" "= 33" + +# Test that koenig lookup finds correct function +# even if it is overloaded +gdb_test "p first(0,c)" "= 22" + +# Test that koenig lookup finds correct function +# when the argument is an expression +gdb_test "p first(b.c)" "= 11" + +# test that resolutions can be made across namespaces +gdb_test "p foo(eo)" "= 1" +gdb_test "p foo(eo, eo)" "= 2" +gdb_test "p foo(eo, eo, 1)" "= 3" +gdb_test "p foo(fo, eo)" "= 4" +gdb_test "p foo(1 ,fo, eo)" "= 5" +gdb_test "p foo(go, fo, eo)" "= 6" + +#test that gdb fails gracefully +gdb_test "p fake(eo)" "No symbol \"fake\" in current context." + +#test that namespaces of base classes are searched +gdb_test "p foo(io)" "= 7" +gdb_test "p foo(ix)" "Cannot resolve function foo to any overloaded instance" + +#test for other types +gdb_test "p foo(ju)" "= 8" +gdb_test "p foo(js)" "= 9" +gdb_test "p foo(je)" "= 10" + +#test for class members +setup_xfail "*-*-*" +gdb_test "p foo(jab)" "= 11" + +gdb_test "p foo(jap)" "= 12" +gdb_test "p foo(japp)" "= 13" +gdb_test "p foo(jca)" "= 14" + +#test overload resolution +gdb_test "p foo(ko,1)" "= 15" +gdb_test "p foo(ko,1.0f)" "= 16" +setup_xfail "*-*-*" +gdb_test "p bar(ko,1)" "= -1" + +#test lookup of objects belonging to nested namespaces +gdb_test "p foo(labo)" "= 17" diff --git a/gdb/valops.c b/gdb/valops.c index 4a7a334..1cd44f8 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -2336,10 +2336,10 @@ find_overload_match (struct type **arg_types, int nargs, int boffset; int ix; int static_offset; - struct cleanup *old_cleanups = NULL; + struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL); const char *obj_type_name = NULL; - char *func_name = NULL; + const char *func_name = NULL; enum oload_classification match_quality; /* Get the list of overloaded methods or functions. */ @@ -2384,24 +2384,39 @@ find_overload_match (struct type **arg_types, int nargs, } else { - const char *qualified_name = SYMBOL_NATURAL_NAME (fsym); + const char *qualified_name = NULL; - /* If we have a function with a C++ name, try to extract just - the function part. Do not try this for non-functions (e.g. - function pointers). */ - if (qualified_name - && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym))) == TYPE_CODE_FUNC) + if (fsym) + { + qualified_name = SYMBOL_NATURAL_NAME (fsym); + + /* If we have a function with a C++ name, try to extract just + the function part. Do not try this for non-functions (e.g. + function pointers). */ + if (qualified_name + && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym))) == TYPE_CODE_FUNC) + { + char *temp; + + temp = cp_func_name (qualified_name); + + /* If cp_func_name did not remove anything, the name of the + symbol did not include scope or argument types - it was + probably a C-style function. */ + if (temp) + { + make_cleanup (xfree, temp); + if (strcmp (temp, qualified_name) == 0) + func_name = NULL; + else + func_name = temp; + } + } + } + else { - func_name = cp_func_name (qualified_name); - - /* If cp_func_name did not remove anything, the name of the - symbol did not include scope or argument types - it was - probably a C-style function. */ - if (func_name && strcmp (func_name, qualified_name) == 0) - { - xfree (func_name); - func_name = NULL; - } + func_name = name; + qualified_name = name; } /* If there was no C++ name, this must be a C-style function or @@ -2413,7 +2428,6 @@ find_overload_match (struct type **arg_types, int nargs, return 0; } - old_cleanups = make_cleanup (xfree, func_name); make_cleanup (xfree, oload_syms); make_cleanup (xfree, oload_champ_bv); @@ -2424,8 +2438,11 @@ find_overload_match (struct type **arg_types, int nargs, &oload_champ_bv); } - /* Check how bad the best match is. */ + /* Did we find a match ? */ + if (oload_champ == -1) + error ("No symbol \"%s\" in current context.", name); + /* Check how bad the best match is. */ match_quality = classify_oload_match (oload_champ_bv, nargs, oload_method_static (method, fns_ptr, @@ -2482,8 +2499,8 @@ find_overload_match (struct type **arg_types, int nargs, } *objp = temp; } - if (old_cleanups != NULL) - do_cleanups (old_cleanups); + + do_cleanups (all_cleanups); switch (match_quality) { @@ -2591,6 +2608,12 @@ find_oload_champ_namespace_loop (struct type **arg_types, int nargs, new_namespace[namespace_len] = '\0'; new_oload_syms = make_symbol_overload_list (func_name, new_namespace); + + /* If we have reached the deepesst level perform argument + determined lookup. */ + if (!searched_deeper) + make_symbol_overload_list_adl (arg_types, nargs, func_name); + while (new_oload_syms[num_fns]) ++num_fns; @@ -2623,7 +2646,6 @@ find_oload_champ_namespace_loop (struct type **arg_types, int nargs, } else { - gdb_assert (new_oload_champ != -1); *oload_syms = new_oload_syms; *oload_champ = new_oload_champ; *oload_champ_bv = new_oload_champ_bv; --------------020009050004080209010203--