Ada: make verbatim matcher override other language matchers (PR gdb/22670)

A previous patch fixed verbatim matching in the lookup at the minimal
symbol level, but we should also be finding that same symbol through
the partial/full symtab search.

For example, this is what happens if we use "print" instead of
"break":

    (gdb) p <MixedCaseFunc>
    $1 = {<text variable, no debug info>} 0x4024dc <MixedCaseFunc>

Before the C++ wildmatching series, GDB knows that MixedCaseFunc is a
function without parameters, and the expression above means calling
it.  If you try it before having started the inferior, you'd get the
following (expected) error:

    (gdb) print  <MixedCaseFunc>
    You can't do that without a process to debug.

The main idea behind making the name matcher be determined by the
symbol's language is so that C++ (etc.) wildmatching in linespecs
works even if the current language is not C++, as e.g., when you step
through C or assembly code.

Ada's verbatim matching syntax however ("<...>") isn't quite the same.
It is more a property of the current language than of a particular
symbol's language.  We want to support this syntax when debugging an
Ada program, but it's reason of existence is to find non-Ada symbols.
This suggests going back to enabling it depending on current language
instead of language of the symbol being matched.

I'm not entirely happy with the "current_language" reference (though I
think that it's harmless).  I think we could try storing the current
language in the lookup_name_info object, and then convert a bunch of
functions more to pass around lookup_name_info objects instead of
"const char *" names.  I.e., build the lookup_name_info higher up.
I'm not sure about that, I'll have to think more about it.  Maybe
something different will be better.  Meanwhile, this gets us going.

I've extended the testcase to also exercise a no-debug-info function,
for extra coverage of the minsyms-only paths.

gdb/ChangeLog:
2018-01-10  Pedro Alves  <palves@redhat.com>

	PR gdb/22670
	* dwarf2read.c
	(gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher):
	Adjust to use language_get_symbol_name_matcher instead of
	language_defn::la_get_symbol_name_matcher.
	* language.c (language_get_symbol_name_matcher): If in Ada mode
	and the lookup name is a verbatim match, return Ada's matcher.
	* language.h (language_get_symbol_name_matcher): Adjust comment.
	(ada_lookup_name_info::verbatim_p):: New method.

gdb/testsuite/ChangeLog:
2018-01-10  Pedro Alves  <palves@redhat.com>

	PR gdb/22670
	* gdb.ada/bp_c_mixed_case.exp: Add intro comment.  Test printing C
	functions too.  Test setting breakpoints and printing C functions
	with no debug info too.
	* gdb.ada/bp_c_mixed_case/qux.c: New file.

1 files changed, 56 insertions, 2 deletions

diff --git a/gdb/testsuite/gdb.ada/bp_c_mixed_case.exp b/gdb/testsuite/gdb.ada/bp_c_mixed_case.exp
index 7787646c67..c0920bee06 100644
--- a/gdb/testsuite/gdb.ada/bp_c_mixed_case.exp
+++ b/gdb/testsuite/gdb.ada/bp_c_mixed_case.exp
@@ -13,6 +13,11 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+# Test setting breakpoints in C functions with some uppercase letters
+# in their name, using the "<...>" notation.  See gdb/22670.  While at
+# it, also try evaluating expressions involving calls to such
+# functions.
+
 load_lib "ada.exp"
 
 standard_ada_testfile foo_h731_021
@@ -21,8 +26,19 @@ set cfile "bar"
 set csrcfile ${srcdir}/${subdir}/${testdir}/${cfile}.c
 set cobject [standard_output_file ${cfile}.o]
 
+set cfile2 "qux"
+set csrcfile2 ${srcdir}/${subdir}/${testdir}/${cfile2}.c
+set cobject2 [standard_output_file ${cfile2}.o]
+
 gdb_compile "${csrcfile}" "${cobject}" object [list debug]
-if {[gdb_compile_ada "${srcfile}" "${binfile}" executable [list debug additional_flags=-largs additional_flags=${cobject} additional_flags=-margs]] != "" } {
+gdb_compile "${csrcfile2}" "${cobject2}" object ""
+
+set options [list debug \
+		 additional_flags=-largs \
+		 additional_flags=${cobject} \
+		 additional_flags=${cobject2} \
+		 additional_flags=-margs]
+if {[gdb_compile_ada "${srcfile}" "${binfile}" executable $options] != "" } {
   return -1
 }
 
@@ -37,14 +53,52 @@ if ![runto "foo_h731_021"] then {
 gdb_test "show lang" \
          "\"auto; currently ada\"\\."
 
+# Before running to the C function (and thus switching out of Ada
+# mode), try printing the function using the "<...>" notation.
+gdb_test "p <MixedCaseFunc>" \
+         " = void" \
+         "p <MixedCaseFunc>, in Ada"
+
+gdb_test "p <NoDebugMixedCaseFunc>" \
+         " = {<text variable, no debug info>} $hex <NoDebugMixedCaseFunc>" \
+         "p <NoDebugMixedCaseFunc>, in Ada"
+
 # Try inserting a breakpoint inside a C function. Because the function's
 # name has some uppercase letters, we need to use the "<...>" notation.
 # The purpose of this testcase is to verify that we can in fact do so
-# and that it inserts the breakpoint at the expected location.  See gdb/22670.
+# and that it inserts the breakpoint at the expected location.
 gdb_test "break <MixedCaseFunc>" \
          "Breakpoint $decimal at $hex: file .*bar.c, line $decimal\\."
 
+# Same, but this time on the function with no debug info.
+gdb_test "break <NoDebugMixedCaseFunc>" \
+         "Breakpoint $decimal at $hex"
+
 # Resume the program's execution, verifying that it lands at the expected
 # location.
 gdb_test "continue" \
          "Breakpoint $decimal, MixedCaseFunc \\(\\) at .*bar\\.c:$decimal.*"
+
+# Try printing again using the "<...>" notation.  This shouldn't work
+# now, since the current frame is a C function.
+gdb_test "p <MixedCaseFunc>" \
+         "A syntax error in expression, near `<MixedCaseFunc>'\\." \
+         "p <MixedCaseFunc>, in C"
+
+gdb_test "p <NoDebugMixedCaseFunc>" \
+         "A syntax error in expression, near `<NoDebugMixedCaseFunc>'\\." \
+         "p <NoDebugMixedCaseFunc>, in C"
+
+set test "break <MixedCaseFunc>, in C"
+gdb_test_multiple "break <MixedCaseFunc>" $test {
+	-re "Function \"<MixedCaseFunc>\" not defined\..*Make breakpoint pending on future shared library load.*y or .n.. $" {
+		gdb_test_no_output "n" $test
+	}
+}
+
+set test "break <NoDebugMixedCaseFunc>, in C"
+gdb_test_multiple "break <NoDebugMixedCaseFunc>" $test {
+	-re "Function \"<NoDebugMixedCaseFunc>\" not defined\..*Make breakpoint pending on future shared library load.*y or .n.. $" {
+		gdb_test_no_output "n" $test
+	}
+}