gdb:

	PR breakpoints/10738
	* dwarf2read.c (use_deprecated_index_sections): New global.
	(struct partial_die_info): New member may_be_inlined.
	(read_partial_die): Set may_be_inlined where appropriate.
	(add_partial_subprogram): Add partial symbols for partial
	DIEs that may be inlined.
	(new_symbol_full): Add inlined subroutines to the current
	scope.
	(write_psymtabs_to_index): Bump version number.
	(dwarf2_read_index): Read only version 6 indices unless
	use_deprecated_index_sections is set.
	* linespec.c (symbol_and_data_callback): New structure.
	(iterate_inline_only): New function.
	(iterate_over_all_matching_symtabs): New argument
	"include_inline".  If nonzero, also call the callback for
	symbols representing inlined subroutines.
	(lookup_prefix_sym): Pass extra argument to the above.
	(find_function_symbols): Likewise.
	(add_matching_symbols_to_info): Likewise.
	* NEWS: Mention that GDB can now set breakpoints on inlined
	functions.

gdb/doc:
	PR breakpoints/10738
	* gdb.texinfo (Inline Functions): Remove the now-unnecessary @item
	stating that GDB cannot set breakpoints on inlined functions.
	(Mode Options): Document --use-deprecated-index-sections.
	(Index Section Format): Document new index section version format.

gdb/testsuite:
	PR breakpoints/10738
	* gdb.opt/inline-break.exp: New file.
	* gdb.opt/inline-break.c: Likewise.
	* gdb.dwarf2/inline-break.exp: Likewise.
	* gdb.dwarf2/inline-break.S: Likewise.
	* gdb.base/annota1.exp: Cope with old .gdb_index warnings.
	* gdb.base/async-shell.exp: Likewise.
	* lib/mi-support.exp (library_loaded_re): Likewise.

2 files changed, 273 insertions, 0 deletions

diff --git a/gdb/testsuite/gdb.opt/inline-break.c b/gdb/testsuite/gdb.opt/inline-break.c
new file mode 100644
index 0000000..edf82d6
--- /dev/null
+++ b/gdb/testsuite/gdb.opt/inline-break.c
@@ -0,0 +1,159 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright (C) 2012 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 <http://www.gnu.org/licenses/>.  */
+
+/* The file ../gdb.dwarf2/inline-break.S was generated manually from
+   this file, and should be regenerated if this file is modified.  */
+
+#ifdef __GNUC__
+# define ATTR __attribute__((always_inline))
+#else
+# define ATTR
+#endif
+
+/* A static inlined function that is called once.  */
+
+static inline ATTR int
+func1 (int x)
+{
+  return x * 23;
+}
+
+/* A non-static inlined function that is called once.  */
+
+inline ATTR int
+func2 (int x)
+{
+  return x * 17;
+}
+
+/* A static inlined function that calls another static inlined
+   function.  */
+
+static inline ATTR int
+func3b (int x)
+{
+  return x < 14 ? 1 : 2;
+}
+
+static inline ATTR int
+func3a (int x)
+{
+  return func3b (x * 23);
+}
+
+/* A non-static inlined function that calls a static inlined
+   function.  */
+
+static inline ATTR int
+func4b (int x)
+{
+  return x < 13 ? 1 : 2;
+}
+
+inline ATTR int
+func4a (int x)
+{
+  return func4b (x * 17);
+}
+
+/* A static inlined function that calls a non-static inlined
+   function.  */
+
+inline ATTR int
+func5b (int x)
+{
+  return x < 12 ? 1 : 2;
+}
+
+static inline ATTR int
+func5a (int x)
+{
+  return func5b (x * 23);
+}
+
+/* A non-static inlined function that calls another non-static inlined
+   function.  */
+
+inline ATTR int
+func6b (int x)
+{
+  return x < 14 ? 3 : 2;
+}
+
+inline ATTR int
+func6a (int x)
+{
+  return func6b (x * 17);
+}
+
+/* A static inlined function that is called more than once.  */
+
+static inline ATTR int
+func7b (int x)
+{
+  return x < 23 ? 1 : 4;
+}
+
+static inline ATTR int
+func7a (int x)
+{
+  return func7b (x * 29);
+}
+
+/* A non-static inlined function that is called more than once.  */
+
+inline ATTR int
+func8b (int x)
+{
+  return x < 7 ? 11 : 9;
+}
+
+static inline ATTR int
+func8a (int x)
+{
+  return func8b (x * 31);
+}
+
+/* Entry point.  */
+
+int
+main (int argc, char *argv[])
+{
+  /* Declaring x as volatile here prevents GCC from combining calls.
+     If GCC is allowed to combine calls then some of them end up with
+     no instructions at all, so there is no specific address for GDB
+     to set a breakpoint at.  */
+  volatile int x = argc;
+
+  x = func1 (x);
+
+  x = func2 (x);
+
+  x = func3a (x);
+
+  x = func4a (x);
+
+  x = func5a (x);
+
+  x = func6a (x);
+
+  x = func7a (x) + func7b (x);
+
+  x = func8a (x) + func8b (x);
+
+  return x;
+}
diff --git a/gdb/testsuite/gdb.opt/inline-break.exp b/gdb/testsuite/gdb.opt/inline-break.exp
new file mode 100644
index 0000000..c357723
--- /dev/null
+++ b/gdb/testsuite/gdb.opt/inline-break.exp
@@ -0,0 +1,114 @@
+# Copyright 2012 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 <http://www.gnu.org/licenses/>.
+
+# Note that the testcase gdb.dwarf2/dw2-inline-break.exp largely
+# mirrors this testcase, and should be updated if this testcase is
+# changed.
+
+set basename "inline-break"
+set testfile $basename
+
+if { [prepare_for_testing $testfile.exp $testfile $testfile.c \
+          {debug optimize=-O2 additional_flags=-Winline}] } {
+    return -1
+}
+
+#
+# func1 is a static inlined function that is called once.
+# The result should be a single-location breakpoint.
+#
+gdb_test "break func1" \
+    "Breakpoint.*at.* file .*$basename\\.c, line.*"
+
+#
+# func2 is a non-static inlined function that is called once.
+# The result should be a breakpoint with two locations: the
+# out-of-line function and the single inlined instance.
+#
+gdb_test "break func2" \
+    "Breakpoint.*at.*func2.*\\(2 locations\\)"
+
+#
+# func3b is a static inlined function that is called once from
+# within another static inlined function.  The result should be
+# a single-location breakpoint.
+#
+gdb_test "break func3b" \
+    "Breakpoint.*at.* file .*$basename\\.c, line.*"
+
+#
+# func4b is a static inlined function that is called once from
+# within a non-static inlined function.  The result should be
+# a breakpoint with two locations: the inlined instance within
+# the inlined call to func4a in main, and the inlined instance
+# within the out-of-line func4a.
+#
+gdb_test "break func4b" \
+    "Breakpoint.*at.*func4b.*\\(2 locations\\)"
+
+#
+# func5b is a non-static inlined function that is called once
+# from within a static inlined function.  The result should be a
+# breakpoint with two locations: the out-of-line function and the
+# inlined instance within the inlined call to func5a in main.
+#
+gdb_test "break func5b" \
+    "Breakpoint.*at.*func5b.*\\(2 locations\\)"
+#
+# func6b is a non-static inlined function that is called once from
+# within another non-static inlined function.  The result should be
+# a breakpoint with three locations: the out-of-line function, the
+# inlined instance within the out-of-line func6a, and the inlined
+# instance within the inlined call to func6a in main,
+#
+gdb_test "break func6b" \
+    "Breakpoint.*at.*func6b.*\\(3 locations\\)"
+
+#
+# func7b is a static inlined function that is called twice: once from
+# func7a, and once from main.  The result should be a breakpoint with
+# two locations: the inlined instance within the inlined instance of
+# func7a, and the inlined instance within main.
+#
+gdb_test "break func7b" \
+    "Breakpoint.*at.*func7b.*\\(2 locations\\)"
+
+#
+# func8b is a non-static inlined function that is called twice: once
+# func8a, and once from main.  The result should be a breakpoint with
+# three locations: the out-of-line function, the inlined instance
+# within the inlined instance of func7a, and the inlined instance
+# within main.
+#
+gdb_test "break func8b" \
+    "Breakpoint.*at.*func8b.*\\(3 locations\\)"
+
+#
+# func1 is a static inlined function.  The result should be that no
+# symbol is found to print.
+#
+gdb_test "print func1" \
+    "No symbol \"func1\" in current context."
+
+#
+# func2 is a non-static inlined function.  The result should be that
+# one symbol is found to print, and that the printed symbol is called
+# "func2".  Note that this does not cover the failure case that two
+# symbols were found, but that gdb chose the out-of-line copy to
+# print, but if this was failing the "print func1" test would likely
+# fail instead.
+#
+gdb_test "print func2" \
+    "\\\$.* = {int \\(int\\)} .* <func2>"