diff --git a/gdb-archer-next-over-throw-cxx-exec.patch b/gdb-archer-next-over-throw-cxx-exec.patch
new file mode 100644
index 0000000..41409f0
--- /dev/null
+++ b/gdb-archer-next-over-throw-cxx-exec.patch
@@ -0,0 +1,104 @@
+Archer-upstreamed:
+http://sourceware.org/ml/archer/2010-q2/msg00031.html
+
+--- ./gdb/breakpoint.c 2010-05-29 01:12:32.000000000 +0200
++++ ./gdb/breakpoint.c 2010-05-29 01:22:21.000000000 +0200
+@@ -1679,14 +1679,11 @@ create_exception_master_breakpoint (void
+ debug_hook = lookup_minimal_symbol_text ("_Unwind_DebugHook", objfile);
+ if (debug_hook != NULL)
+ {
+- CORE_ADDR pc;
+ struct breakpoint *b;
+
+- pc = find_function_start_pc (get_objfile_arch (objfile),
+- SYMBOL_VALUE_ADDRESS (debug_hook),
+- SYMBOL_OBJ_SECTION (debug_hook));
+ b = create_internal_breakpoint (get_objfile_arch (objfile),
+- pc, bp_exception_master);
++ SYMBOL_VALUE_ADDRESS (debug_hook),
++ bp_exception_master);
+ b->addr_string = xstrdup ("_Unwind_DebugHook");
+ b->enable_state = bp_disabled;
+ }
+--- ./gdb/testsuite/gdb.cp/cxxexec.cc 1970-01-01 01:00:00.000000000 +0100
++++ ./gdb/testsuite/gdb.cp/cxxexec.cc 2010-05-29 01:18:56.000000000 +0200
+@@ -0,0 +1,25 @@
++/* This test script is part of GDB, the GNU debugger.
++
++ Copyright 2010 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 . */
++
++#include
++
++int
++main()
++{
++ execlp ("true", "true", NULL);
++ return 1;
++}
+--- ./gdb/testsuite/gdb.cp/cxxexec.exp 1970-01-01 01:00:00.000000000 +0100
++++ ./gdb/testsuite/gdb.cp/cxxexec.exp 2010-05-29 01:29:25.000000000 +0200
+@@ -0,0 +1,51 @@
++# Copyright 2010 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 { [skip_cplus_tests] } { continue }
++
++set testfile cxxexec
++if { [prepare_for_testing ${testfile}.exp ${testfile} ${testfile}.cc {c++ debug}] } {
++ return -1
++}
++
++runto_main
++
++# We could stop after `continue' again at `main'.
++delete_breakpoints
++
++set test "p _Unwind_DebugHook"
++gdb_test_multiple $test $test {
++ -re " = .* 0x\[0-9a-f\].*\r\n$gdb_prompt $" {
++ pass $test
++ }
++ -re "\r\nNo symbol .*\r\n$gdb_prompt $" {
++ xfail $test
++ untested ${testfile}.exp
++ return -1
++ }
++}
++
++set test continue
++gdb_test_multiple $test $test {
++ -re "Cannot access memory at address 0x\[0-9a-f\]+\r\n$gdb_prompt $" {
++ fail $test
++ }
++ -re "\r\n$gdb_prompt $" {
++ pass $test
++ }
++}
++
++# `info inferiors' can show on older GDBs.
++gdb_test "info threads" "info threads" "program finished"
diff --git a/gdb-bz589467-pieces-vla-compat.patch b/gdb-bz589467-pieces-vla-compat.patch
new file mode 100644
index 0000000..ca5762d
--- /dev/null
+++ b/gdb-bz589467-pieces-vla-compat.patch
@@ -0,0 +1,59 @@
+06e357f534abcf8912e4fd597daae8f1387d631c
+
+Fix compatibility with: FYI: fix BINOP_SUBSCRIPT with pieced arrays
+ http://sourceware.org/ml/gdb-patches/2010-05/msg00281.html
+
+2010-05-30 Jan Kratochvil
+
+ * valarith.c (binop_user_defined_p): Return 0 on ARG1 or ARG2 being
+ TYPE_DYNAMIC.
+ * value.c (coerce_ref): Use object_address_get_data resolution for
+ TYPE_DYNAMIC ARG.
+
+[ Backported. ]
+
+Index: gdb-7.1/gdb/valarith.c
+===================================================================
+--- gdb-7.1.orig/gdb/valarith.c 2010-05-30 18:54:28.000000000 +0200
++++ gdb-7.1/gdb/valarith.c 2010-05-30 18:54:43.000000000 +0200
+@@ -309,6 +309,10 @@ int
+ binop_user_defined_p (enum exp_opcode op,
+ struct value *arg1, struct value *arg2)
+ {
++ /* FIXME: We should support user defined ops for dynamic types. */
++ if (TYPE_DYNAMIC (value_type (arg1)) || TYPE_DYNAMIC (value_type (arg2)))
++ return 0;
++
+ return binop_types_user_defined_p (op, value_type (arg1), value_type (arg2));
+ }
+
+Index: gdb-7.1/gdb/value.c
+===================================================================
+--- gdb-7.1.orig/gdb/value.c 2010-05-30 18:54:36.000000000 +0200
++++ gdb-7.1/gdb/value.c 2010-05-30 18:55:52.000000000 +0200
+@@ -2400,7 +2400,24 @@ value_from_decfloat (struct type *type,
+ struct value *
+ coerce_ref (struct value *arg)
+ {
+- struct type *value_type_arg_tmp = check_typedef (value_type (arg));
++ struct type *value_type_arg_tmp;
++
++ if (TYPE_DYNAMIC (value_type (arg)))
++ {
++ struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
++ CORE_ADDR address;
++
++ value_type_arg_tmp = value_type (arg);
++ address = value_raw_address (arg);
++ if (! object_address_get_data (value_type_arg_tmp, &address))
++ error (_("Attempt to coerce non-valid value."));
++ CHECK_TYPEDEF (value_type_arg_tmp);
++ arg = value_at_lazy (value_type_arg_tmp, address);
++ do_cleanups (cleanups);
++ }
++ else
++ value_type_arg_tmp = check_typedef (value_type (arg));
++
+ if (TYPE_CODE (value_type_arg_tmp) == TYPE_CODE_REF)
+ arg = value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp),
+ unpack_pointer (value_type (arg),
diff --git a/gdb-bz589467-pieces01of4.patch b/gdb-bz589467-pieces01of4.patch
new file mode 100644
index 0000000..f077d19
--- /dev/null
+++ b/gdb-bz589467-pieces01of4.patch
@@ -0,0 +1,80 @@
+commit 96c23bfd2863bcca7388653a7bc4c9f8a64a03be
+Author: Ulrich Weigand
+Date: Fri Feb 26 12:48:17 2010 +0000
+
+ * dwarf2loc.c (struct piece_closure): Remove ARCH member,
+ add ADDR_SIZE member.
+ (allocate_piece_closure): Update.
+ (copy_pieced_value_closure): Likewise.
+ (dwarf2_evaluate_loc_desc): Likewise.
+ (read_pieced_value): Use DWARF address size instead of
+ GDB's gdbarch_addr_bit as size of values on the DWARF stack.
+
+diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
+index 1c4d057..20ede3e 100644
+--- a/gdb/dwarf2loc.c
++++ b/gdb/dwarf2loc.c
+@@ -232,8 +232,8 @@ struct piece_closure
+ /* The number of pieces used to describe this variable. */
+ int n_pieces;
+
+- /* The architecture, used only for DWARF_VALUE_STACK. */
+- struct gdbarch *arch;
++ /* The target address size, used only for DWARF_VALUE_STACK. */
++ int addr_size;
+
+ /* The pieces themselves. */
+ struct dwarf_expr_piece *pieces;
+@@ -244,12 +244,12 @@ struct piece_closure
+
+ static struct piece_closure *
+ allocate_piece_closure (int n_pieces, struct dwarf_expr_piece *pieces,
+- struct gdbarch *arch)
++ int addr_size)
+ {
+ struct piece_closure *c = XZALLOC (struct piece_closure);
+
+ c->n_pieces = n_pieces;
+- c->arch = arch;
++ c->addr_size = addr_size;
+ c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece);
+
+ memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
+@@ -298,13 +298,12 @@ read_pieced_value (struct value *v)
+
+ case DWARF_VALUE_STACK:
+ {
+- size_t n;
+- int addr_size = gdbarch_addr_bit (c->arch) / 8;
+- n = p->size;
+- if (n > addr_size)
+- n = addr_size;
++ struct gdbarch *gdbarch = get_type_arch (value_type (v));
++ size_t n = p->size;
++ if (n > c->addr_size)
++ n = c->addr_size;
+ store_unsigned_integer (contents + offset, n,
+- gdbarch_byte_order (c->arch),
++ gdbarch_byte_order (gdbarch),
+ p->v.expr.value);
+ }
+ break;
+@@ -377,7 +376,7 @@ copy_pieced_value_closure (struct value *v)
+ {
+ struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
+
+- return allocate_piece_closure (c->n_pieces, c->pieces, c->arch);
++ return allocate_piece_closure (c->n_pieces, c->pieces, c->addr_size);
+ }
+
+ static void
+@@ -439,7 +438,8 @@ dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
+ struct piece_closure *c;
+ struct frame_id frame_id = get_frame_id (frame);
+
+- c = allocate_piece_closure (ctx->num_pieces, ctx->pieces, ctx->gdbarch);
++ c = allocate_piece_closure (ctx->num_pieces, ctx->pieces,
++ ctx->addr_size);
+ retval = allocate_computed_value (type, &pieced_value_funcs, c);
+ VALUE_FRAME_ID (retval) = frame_id;
+ }
diff --git a/gdb-bz589467-pieces02of4.patch b/gdb-bz589467-pieces02of4.patch
new file mode 100644
index 0000000..f9986f0
--- /dev/null
+++ b/gdb-bz589467-pieces02of4.patch
@@ -0,0 +1,68 @@
+commit 60d15ff6d78921d080aee681e60372abe6627570
+Author: mgretton
+Date: Tue May 4 09:54:17 2010 +0000
+
+ * gdb/dwarf2loc.c (read_pieced_value, write_pieced_value,
+ dwarf2_evaluate_loc_desc): Handle not being able to access DWARF
+ registers gracefully.
+
+Index: gdb-7.1/gdb/dwarf2loc.c
+===================================================================
+--- gdb-7.1.orig/gdb/dwarf2loc.c 2010-05-25 21:35:10.000000000 +0200
++++ gdb-7.1/gdb/dwarf2loc.c 2010-05-25 21:37:32.000000000 +0200
+@@ -458,8 +458,16 @@ read_pieced_value (struct value *v)
+ /* Big-endian, and we want less than full size. */
+ reg_offset = register_size (arch, gdb_regnum) - p->size;
+
+- get_frame_register_bytes (frame, gdb_regnum, reg_offset, p->size,
+- contents + offset);
++ if (gdb_regnum != -1)
++ {
++ get_frame_register_bytes (frame, gdb_regnum, reg_offset,
++ p->size, contents + offset);
++ }
++ else
++ {
++ error (_("Unable to access DWARF register number %s"),
++ paddress (arch, p->v.expr.value));
++ }
+ }
+ break;
+
+@@ -531,8 +539,16 @@ write_pieced_value (struct value *to, st
+ /* Big-endian, and we want less than full size. */
+ reg_offset = register_size (arch, gdb_regnum) - p->size;
+
+- put_frame_register_bytes (frame, gdb_regnum, reg_offset, p->size,
+- contents + offset);
++ if (gdb_regnum != -1)
++ {
++ put_frame_register_bytes (frame, gdb_regnum, reg_offset,
++ p->size, contents + offset);
++ }
++ else
++ {
++ error (_("Unable to write to DWARF register number %s"),
++ paddress (arch, p->v.expr.value));
++ }
+ }
+ break;
+ case DWARF_VALUE_MEMORY:
+@@ -611,7 +627,16 @@ dwarf2_evaluate_loc_desc (struct type *t
+ struct gdbarch *arch = get_frame_arch (frame);
+ CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
+ int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
+- retval = value_from_register (type, gdb_regnum, frame);
++ if (gdb_regnum != -1)
++ {
++ retval = value_from_register (type,
++ gdb_regnum, frame);
++ }
++ else
++ {
++ error (_("Unable to access DWARF register number %s"),
++ paddress (arch, dwarf_regnum));
++ }
+ }
+ break;
+
diff --git a/gdb-bz589467-pieces03of4.patch b/gdb-bz589467-pieces03of4.patch
new file mode 100644
index 0000000..8fc73f9
--- /dev/null
+++ b/gdb-bz589467-pieces03of4.patch
@@ -0,0 +1,99 @@
+commit dacd66a53b559be9c26d2c523f168f1ef0261f4d
+Author: Michael Snyder
+Date: Fri May 14 17:53:11 2010 +0000
+
+ 2010-05-14 Michael Snyder
+
+ * dbxread.c: White space.
+ * dcache.c: White space.
+ * disasm.c: White space.
+ * doublest.c: White space.
+ * dsrec.c: White space.
+ * dummy-frame.c: White space.
+ * dwarf2expr.c: White space.
+ * dwarf2-frame.c: White space.
+ * dwarf2loc.c: White space.
+ * dwarf2read.c: White space.
+
+--- gdb-7.1/gdb/dwarf2loc.c.orig 2010-05-25 23:06:46.000000000 +0200
++++ gdb-7.1/gdb/dwarf2loc.c 2010-05-25 23:06:46.000000000 +0200
+@@ -236,6 +236,7 @@ static CORE_ADDR
+ dwarf_expr_frame_cfa (void *baton)
+ {
+ struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
++
+ return dwarf2_frame_cfa (debaton->frame);
+ }
+
+@@ -444,6 +445,7 @@ read_pieced_value (struct value *v)
+ for (i = 0; i < c->n_pieces; i++)
+ {
+ struct dwarf_expr_piece *p = &c->pieces[i];
++
+ switch (p->location)
+ {
+ case DWARF_VALUE_REGISTER:
+@@ -482,6 +484,7 @@ read_pieced_value (struct value *v)
+ {
+ struct gdbarch *gdbarch = get_type_arch (value_type (v));
+ size_t n = p->size;
++
+ if (n > c->addr_size)
+ n = c->addr_size;
+ store_unsigned_integer (contents + offset, n,
+@@ -493,6 +496,7 @@ read_pieced_value (struct value *v)
+ case DWARF_VALUE_LITERAL:
+ {
+ size_t n = p->size;
++
+ if (n > p->v.literal.length)
+ n = p->v.literal.length;
+ memcpy (contents + offset, p->v.literal.data, n);
+@@ -525,6 +529,7 @@ write_pieced_value (struct value *to, st
+ for (i = 0; i < c->n_pieces; i++)
+ {
+ struct dwarf_expr_piece *p = &c->pieces[i];
++
+ switch (p->location)
+ {
+ case DWARF_VALUE_REGISTER:
+@@ -712,6 +717,7 @@ static CORE_ADDR
+ needs_frame_read_reg (void *baton, int regnum)
+ {
+ struct needs_frame_baton *nf_baton = baton;
++
+ nf_baton->needs_frame = 1;
+ return 1;
+ }
+@@ -742,6 +748,7 @@ static CORE_ADDR
+ needs_frame_frame_cfa (void *baton)
+ {
+ struct needs_frame_baton *nf_baton = baton;
++
+ nf_baton->needs_frame = 1;
+ return 1;
+ }
+@@ -751,6 +758,7 @@ static CORE_ADDR
+ needs_frame_tls_address (void *baton, CORE_ADDR offset)
+ {
+ struct needs_frame_baton *nf_baton = baton;
++
+ nf_baton->needs_frame = 1;
+ return 1;
+ }
+@@ -907,6 +915,7 @@ locexpr_read_variable (struct symbol *sy
+ {
+ struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct value *val;
++
+ val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
+ dlbaton->size, dlbaton->per_cu);
+
+@@ -918,6 +927,7 @@ static int
+ locexpr_read_needs_frame (struct symbol *symbol)
+ {
+ struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
++
+ return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
+ dlbaton->per_cu);
+ }
diff --git a/gdb-bz589467-pieces1of4.patch b/gdb-bz589467-pieces1of4.patch
new file mode 100644
index 0000000..52163c6
--- /dev/null
+++ b/gdb-bz589467-pieces1of4.patch
@@ -0,0 +1,2075 @@
+http://sourceware.org/ml/gdb-cvs/2010-05/msg00186.html
+
+### src/gdb/ChangeLog 2010/05/21 20:34:45 1.11828
+### src/gdb/ChangeLog 2010/05/21 20:39:50 1.11829
+## -1,3 +1,9 @@
++2010-05-21 Tom Tromey
++
++ * dwarf2loc.c (read_pieced_value): Work properly when 'v' has an
++ offset.
++ (write_pieced_value): Likewise.
++
+### src/gdb/testsuite/ChangeLog 2010/05/20 19:18:57 1.2272
+### src/gdb/testsuite/ChangeLog 2010/05/21 20:39:50 1.2273
+## -1,3 +1,9 @@
++2010-05-21 Tom Tromey
++
++ * gdb.dwarf2.pieces.exp: New file.
++ * gdb.dwarf2.pieces.S: New file.
++ * gdb.dwarf2.pieces.c: New file.
++
+--- src/gdb/dwarf2loc.c 2010/05/14 17:53:16 1.78
++++ src/gdb/dwarf2loc.c 2010/05/21 20:39:50 1.79
+@@ -264,14 +264,46 @@
+ {
+ int i;
+ long offset = 0;
++ ULONGEST bytes_to_skip;
+ gdb_byte *contents;
+ struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
+ struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
++ size_t type_len;
++
++ if (value_type (v) != value_enclosing_type (v))
++ internal_error (__FILE__, __LINE__,
++ _("Should not be able to create a lazy value with "
++ "an enclosing type"));
+
+ contents = value_contents_raw (v);
+- for (i = 0; i < c->n_pieces; i++)
++ bytes_to_skip = value_offset (v);
++ type_len = TYPE_LENGTH (value_type (v));
++ for (i = 0; i < c->n_pieces && offset < type_len; i++)
+ {
+ struct dwarf_expr_piece *p = &c->pieces[i];
++ size_t this_size;
++ long dest_offset, source_offset;
++
++ if (bytes_to_skip > 0 && bytes_to_skip >= p->size)
++ {
++ bytes_to_skip -= p->size;
++ continue;
++ }
++ this_size = p->size;
++ if (this_size > type_len - offset)
++ this_size = type_len - offset;
++ if (bytes_to_skip > 0)
++ {
++ dest_offset = 0;
++ source_offset = bytes_to_skip;
++ this_size -= bytes_to_skip;
++ bytes_to_skip = 0;
++ }
++ else
++ {
++ dest_offset = offset;
++ source_offset = 0;
++ }
+
+ switch (p->location)
+ {
+@@ -280,17 +312,17 @@
+ struct gdbarch *arch = get_frame_arch (frame);
+ int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch,
+ p->v.expr.value);
+- int reg_offset = 0;
++ int reg_offset = source_offset;
+
+ if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
+- && p->size < register_size (arch, gdb_regnum))
++ && this_size < register_size (arch, gdb_regnum))
+ /* Big-endian, and we want less than full size. */
+- reg_offset = register_size (arch, gdb_regnum) - p->size;
++ reg_offset = register_size (arch, gdb_regnum) - this_size;
+
+ if (gdb_regnum != -1)
+ {
+ get_frame_register_bytes (frame, gdb_regnum, reg_offset,
+- p->size, contents + offset);
++ this_size, contents + dest_offset);
+ }
+ else
+ {
+@@ -302,38 +334,60 @@
+
+ case DWARF_VALUE_MEMORY:
+ if (p->v.expr.in_stack_memory)
+- read_stack (p->v.expr.value, contents + offset, p->size);
++ read_stack (p->v.expr.value + source_offset,
++ contents + dest_offset, this_size);
+ else
+- read_memory (p->v.expr.value, contents + offset, p->size);
++ read_memory (p->v.expr.value + source_offset,
++ contents + dest_offset, this_size);
+ break;
+
+ case DWARF_VALUE_STACK:
+ {
+ struct gdbarch *gdbarch = get_type_arch (value_type (v));
+- size_t n = p->size;
++ size_t n = this_size;
++
++ if (n > c->addr_size - source_offset)
++ n = (c->addr_size >= source_offset
++ ? c->addr_size - source_offset
++ : 0);
++ if (n == 0)
++ {
++ /* Nothing. */
++ }
++ else if (source_offset == 0)
++ store_unsigned_integer (contents + dest_offset, n,
++ gdbarch_byte_order (gdbarch),
++ p->v.expr.value);
++ else
++ {
++ gdb_byte bytes[sizeof (ULONGEST)];
+
+- if (n > c->addr_size)
+- n = c->addr_size;
+- store_unsigned_integer (contents + offset, n,
+- gdbarch_byte_order (gdbarch),
+- p->v.expr.value);
++ store_unsigned_integer (bytes, n + source_offset,
++ gdbarch_byte_order (gdbarch),
++ p->v.expr.value);
++ memcpy (contents + dest_offset, bytes + source_offset, n);
++ }
+ }
+ break;
+
+ case DWARF_VALUE_LITERAL:
+ {
+- size_t n = p->size;
++ size_t n = this_size;
+
+- if (n > p->v.literal.length)
+- n = p->v.literal.length;
+- memcpy (contents + offset, p->v.literal.data, n);
++ if (n > p->v.literal.length - source_offset)
++ n = (p->v.literal.length >= source_offset
++ ? p->v.literal.length - source_offset
++ : 0);
++ if (n != 0)
++ memcpy (contents + dest_offset,
++ p->v.literal.data + source_offset, n);
+ }
+ break;
+
+ default:
+ internal_error (__FILE__, __LINE__, _("invalid location type"));
+ }
+- offset += p->size;
++ offset += this_size;
+ }
+ }
+
+@@ -342,9 +396,11 @@
+ {
+ int i;
+ long offset = 0;
+- gdb_byte *contents;
++ ULONGEST bytes_to_skip;
++ const gdb_byte *contents;
+ struct piece_closure *c = (struct piece_closure *) value_computed_closure (to);
+ struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
++ size_t type_len;
+
+ if (frame == NULL)
+ {
+@@ -352,10 +408,35 @@
+ return;
+ }
+
+- contents = value_contents_raw (from);
+- for (i = 0; i < c->n_pieces; i++)
++ contents = value_contents (from);
++ bytes_to_skip = value_offset (to);
++ type_len = TYPE_LENGTH (value_type (to));
++ for (i = 0; i < c->n_pieces && offset < type_len; i++)
+ {
+ struct dwarf_expr_piece *p = &c->pieces[i];
++ size_t this_size;
++ long dest_offset, source_offset;
++
++ if (bytes_to_skip > 0 && bytes_to_skip >= p->size)
++ {
++ bytes_to_skip -= p->size;
++ continue;
++ }
++ this_size = p->size;
++ if (this_size > type_len - offset)
++ this_size = type_len - offset;
++ if (bytes_to_skip > 0)
++ {
++ dest_offset = bytes_to_skip;
++ source_offset = 0;
++ this_size -= bytes_to_skip;
++ bytes_to_skip = 0;
++ }
++ else
++ {
++ dest_offset = 0;
++ source_offset = offset;
++ }
+
+ switch (p->location)
+ {
+@@ -363,17 +444,17 @@
+ {
+ struct gdbarch *arch = get_frame_arch (frame);
+ int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.expr.value);
+- int reg_offset = 0;
++ int reg_offset = dest_offset;
+
+ if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
+- && p->size < register_size (arch, gdb_regnum))
++ && this_size <= register_size (arch, gdb_regnum))
+ /* Big-endian, and we want less than full size. */
+- reg_offset = register_size (arch, gdb_regnum) - p->size;
++ reg_offset = register_size (arch, gdb_regnum) - this_size;
+
+ if (gdb_regnum != -1)
+ {
+ put_frame_register_bytes (frame, gdb_regnum, reg_offset,
+- p->size, contents + offset);
++ this_size, contents + source_offset);
+ }
+ else
+ {
+@@ -383,13 +464,14 @@
+ }
+ break;
+ case DWARF_VALUE_MEMORY:
+- write_memory (p->v.expr.value, contents + offset, p->size);
++ write_memory (p->v.expr.value + dest_offset,
++ contents + source_offset, this_size);
+ break;
+ default:
+ set_value_optimized_out (to, 1);
+ return;
+ }
+- offset += p->size;
++ offset += this_size;
+ }
+ }
+
+--- src/gdb/testsuite/gdb.dwarf2/pieces.S
++++ src/gdb/testsuite/gdb.dwarf2/pieces.S 2010-05-25 20:17:51.988718000 +0000
+@@ -0,0 +1,1655 @@
++/*
++ Copyright 2010 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 .
++ */
++
++/* This was compiled with a version of gcc modified to emit better
++ debuginfo for SRA'd structures. See:
++ http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43983
++
++ The original program is "pieces.c", in this directory.
++*/
++
++ .file "pieces.c"
++ .section .debug_abbrev,"",@progbits
++.Ldebug_abbrev0:
++ .section .debug_info,"",@progbits
++.Ldebug_info0:
++ .section .debug_line,"",@progbits
++.Ldebug_line0:
++ .text
++.Ltext0:
++ .p2align 4,,15
++.globl bar
++ .type bar, @function
++bar:
++.LFB0:
++ .file 1 "pieces.c"
++ # pieces.c:28
++ .loc 1 28 0
++.LVL0:
++ # basic block 2
++ pushl %ebp
++.LCFI0:
++ movl %esp, %ebp
++.LCFI1:
++ # pieces.c:29
++ .loc 1 29 0
++ movl 8(%ebp), %eax
++ # pieces.c:30
++ .loc 1 30 0
++ popl %ebp
++.LCFI2:
++ ret
++.LFE0:
++ .size bar, .-bar
++ .p2align 4,,15
++.globl f1
++ .type f1, @function
++f1:
++.LFB1:
++ # pieces.c:34
++ .loc 1 34 0
++.LVL1:
++ # basic block 2
++ pushl %ebp
++.LCFI3:
++ movl %esp, %ebp
++.LCFI4:
++.LVL2:
++ subl $12, %esp
++.LCFI5:
++ movl %esi, -4(%ebp)
++.LCFI6:
++ # pieces.c:37
++ .loc 1 37 0
++ movl 8(%ebp), %esi
++ # pieces.c:34
++ .loc 1 34 0
++ movl %ebx, -8(%ebp)
++.LCFI7:
++ # pieces.c:36
++ .loc 1 36 0
++ movl $4, %ebx
++.LVL3:
++ # pieces.c:38
++ .loc 1 38 0
++ movl %ebx, (%esp)
++ # pieces.c:37
++ .loc 1 37 0
++ addl $7, %esi
++.LVL4:
++ # pieces.c:38
++ .loc 1 38 0
++ call bar
++ # pieces.c:39
++ .loc 1 39 0
++ movl %esi, (%esp)
++ call bar
++ # pieces.c:40
++ .loc 1 40 0
++ leal (%ebx,%esi), %eax
++ # pieces.c:41
++ .loc 1 41 0
++ movl -8(%ebp), %ebx
++.LVL5:
++ movl -4(%ebp), %esi
++.LVL6:
++ movl %ebp, %esp
++.LCFI8:
++ popl %ebp
++.LCFI9:
++ ret
++.LFE1:
++ .size f1, .-f1
++ .p2align 4,,15
++.globl f2
++ .type f2, @function
++f2:
++.LFB2:
++ # pieces.c:45
++ .loc 1 45 0
++.LVL7:
++ # basic block 2
++ pushl %ebp
++.LCFI10:
++ movl %esp, %ebp
++.LCFI11:
++.LVL8:
++ subl $12, %esp
++.LCFI12:
++ movl %esi, -4(%ebp)
++.LCFI13:
++ # pieces.c:48
++ .loc 1 48 0
++ movl 8(%ebp), %esi
++ # pieces.c:45
++ .loc 1 45 0
++ movl %ebx, -8(%ebp)
++.LCFI14:
++ # pieces.c:47
++ .loc 1 47 0
++ movl $4, %ebx
++.LVL9:
++ # pieces.c:49
++ .loc 1 49 0
++ movl %ebx, (%esp)
++ # pieces.c:48
++ .loc 1 48 0
++ addl $7, %esi
++.LVL10:
++ # pieces.c:49
++ .loc 1 49 0
++ call bar
++ # pieces.c:50
++ .loc 1 50 0
++ movl %esi, (%esp)
++ call bar
++ # pieces.c:51
++ .loc 1 51 0
++ leal (%ebx,%esi), %eax
++ # pieces.c:52
++ .loc 1 52 0
++ movl -8(%ebp), %ebx
++.LVL11:
++ movl -4(%ebp), %esi
++.LVL12:
++ movl %ebp, %esp
++.LCFI15:
++ popl %ebp
++.LCFI16:
++ ret
++.LFE2:
++ .size f2, .-f2
++ .p2align 4,,15
++.globl f3
++ .type f3, @function
++f3:
++.LFB3:
++ # pieces.c:56
++ .loc 1 56 0
++.LVL13:
++ # basic block 2
++ pushl %ebp
++.LCFI17:
++ # pieces.c:58
++ .loc 1 58 0
++ movl $4, %edx
++ # pieces.c:56
++ .loc 1 56 0
++ movl %esp, %ebp
++.LCFI18:
++.LVL14:
++ subl $12, %esp
++.LCFI19:
++ # pieces.c:58
++ .loc 1 58 0
++.LVL15:
++ # pieces.c:56
++ .loc 1 56 0
++ movl %esi, -4(%ebp)
++.LCFI20:
++ # pieces.c:60
++ .loc 1 60 0
++ movswl %dx, %esi
++ # pieces.c:56
++ .loc 1 56 0
++ movl %ebx, -8(%ebp)
++.LCFI21:
++ # pieces.c:60
++ .loc 1 60 0
++ movl %esi, (%esp)
++ call bar
++.LVL16:
++ # pieces.c:57
++ .loc 1 57 0
++ movl 8(%ebp), %edx
++ sall $4, %edx
++ # pieces.c:59
++ .loc 1 59 0
++ addl $112, %edx
++ sarw $4, %dx
++ # pieces.c:61
++ .loc 1 61 0
++ movswl %dx, %ebx
++ movl %ebx, (%esp)
++ call bar
++ # pieces.c:62
++ .loc 1 62 0
++ leal (%esi,%ebx), %eax
++ # pieces.c:63
++ .loc 1 63 0
++ movl -8(%ebp), %ebx
++ movl -4(%ebp), %esi
++.LVL17:
++ movl %ebp, %esp
++.LCFI22:
++ popl %ebp
++.LCFI23:
++ ret
++.LFE3:
++ .size f3, .-f3
++ .p2align 4,,15
++.globl f4
++ .type f4, @function
++f4:
++.LFB4:
++ # pieces.c:67
++ .loc 1 67 0
++.LVL18:
++ # basic block 2
++ pushl %ebp
++.LCFI24:
++ movl %esp, %ebp
++.LCFI25:
++ subl $12, %esp
++.LCFI26:
++ movl %esi, -4(%ebp)
++.LCFI27:
++ movl 8(%ebp), %esi
++.LVL19:
++ movl %ebx, -8(%ebp)
++.LCFI28:
++ # pieces.c:69
++ .loc 1 69 0
++ movl %esi, %ebx
++ # pieces.c:70
++ .loc 1 70 0
++ addl $1, %esi
++ # pieces.c:69
++ .loc 1 69 0
++.LVL20:
++ # pieces.c:71
++ .loc 1 71 0
++ movl %ebx, (%esp)
++ call bar
++ # pieces.c:72
++ .loc 1 72 0
++ movl %esi, (%esp)
++ call bar
++ # pieces.c:73
++ .loc 1 73 0
++ leal (%ebx,%esi), %eax
++ # pieces.c:74
++ .loc 1 74 0
++ movl -8(%ebp), %ebx
++.LVL21:
++ movl -4(%ebp), %esi
++.LVL22:
++ movl %ebp, %esp
++.LCFI29:
++ popl %ebp
++.LCFI30:
++ ret
++.LFE4:
++ .size f4, .-f4
++ .p2align 4,,15
++.globl f5
++ .type f5, @function
++f5:
++.LFB5:
++ # pieces.c:78
++ .loc 1 78 0
++.LVL23:
++ # basic block 2
++ pushl %ebp
++.LCFI31:
++ movl %esp, %ebp
++.LCFI32:
++ subl $12, %esp
++.LCFI33:
++ movl %esi, -4(%ebp)
++.LCFI34:
++ movl 8(%ebp), %esi
++.LVL24:
++ movl %ebx, -8(%ebp)
++.LCFI35:
++ # pieces.c:80
++ .loc 1 80 0
++ movl %esi, %ebx
++ # pieces.c:81
++ .loc 1 81 0
++ addl $1, %esi
++ # pieces.c:80
++ .loc 1 80 0
++.LVL25:
++ # pieces.c:82
++ .loc 1 82 0
++ movl %ebx, (%esp)
++ call bar
++ # pieces.c:83
++ .loc 1 83 0
++ movl %esi, (%esp)
++ call bar
++ # pieces.c:84
++ .loc 1 84 0
++ leal (%ebx,%esi), %eax
++ # pieces.c:85
++ .loc 1 85 0
++ movl -8(%ebp), %ebx
++.LVL26:
++ movl -4(%ebp), %esi
++.LVL27:
++ movl %ebp, %esp
++.LCFI36:
++ popl %ebp
++.LCFI37:
++ ret
++.LFE5:
++ .size f5, .-f5
++ .p2align 4,,15
++.globl main
++ .type main, @function
++main:
++.LFB6:
++ # pieces.c:89
++ .loc 1 89 0
++ # basic block 2
++ pushl %ebp
++.LCFI38:
++ movl %esp, %ebp
++.LCFI39:
++ pushl %ebx
++.LCFI40:
++ # pieces.c:91
++ .loc 1 91 0
++ movl $7, %ebx
++ # pieces.c:89
++ .loc 1 89 0
++ subl $4, %esp
++.LCFI41:
++ # pieces.c:91
++ .loc 1 91 0
++.LVL28:
++ # pieces.c:92
++ .loc 1 92 0
++ movl %ebx, (%esp)
++ call f1
++ # pieces.c:93
++ .loc 1 93 0
++ movl %ebx, (%esp)
++ call f2
++ # pieces.c:94
++ .loc 1 94 0
++ movl %ebx, (%esp)
++ call f3
++ # pieces.c:95
++ .loc 1 95 0
++ movl %ebx, (%esp)
++ call f4
++ # pieces.c:96
++ .loc 1 96 0
++ movl %ebx, (%esp)
++ call f5
++ # pieces.c:98
++ .loc 1 98 0
++ addl $4, %esp
++ xorl %eax, %eax
++ popl %ebx
++.LCFI42:
++.LVL29:
++ popl %ebp
++.LCFI43:
++ ret
++.LFE6:
++ .size main, .-main
++#APP
++ .section .debug_frame,"",@progbits
++.Lframe0:
++ .long .LECIE0-.LSCIE0 # Length of Common Information Entry
++.LSCIE0:
++ .long 0xffffffff # CIE Identifier Tag
++ .byte 0x1 # CIE Version
++ .ascii "\0" # CIE Augmentation
++ .uleb128 0x1 # CIE Code Alignment Factor
++ .sleb128 -4 # CIE Data Alignment Factor
++ .byte 0x8 # CIE RA Column
++ .byte 0xc # DW_CFA_def_cfa
++ .uleb128 0x4
++ .uleb128 0x4
++ .byte 0x88 # DW_CFA_offset, column 0x8
++ .uleb128 0x1
++ .align 4
++.LECIE0:
++.LSFDE0:
++ .long .LEFDE0-.LASFDE0 # FDE Length
++.LASFDE0:
++ .long .Lframe0 # FDE CIE offset
++ .long .LFB0 # FDE initial location
++ .long .LFE0-.LFB0 # FDE address range
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI0-.LFB0
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x8
++ .byte 0x85 # DW_CFA_offset, column 0x5
++ .uleb128 0x2
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI1-.LCFI0
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x5
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI2-.LCFI1
++ .byte 0xc5 # DW_CFA_restore, column 0x5
++ .byte 0xc # DW_CFA_def_cfa
++ .uleb128 0x4
++ .uleb128 0x4
++ .align 4
++.LEFDE0:
++.LSFDE2:
++ .long .LEFDE2-.LASFDE2 # FDE Length
++.LASFDE2:
++ .long .Lframe0 # FDE CIE offset
++ .long .LFB1 # FDE initial location
++ .long .LFE1-.LFB1 # FDE address range
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI3-.LFB1
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x8
++ .byte 0x85 # DW_CFA_offset, column 0x5
++ .uleb128 0x2
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI4-.LCFI3
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x5
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI6-.LCFI4
++ .byte 0x86 # DW_CFA_offset, column 0x6
++ .uleb128 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI7-.LCFI6
++ .byte 0x83 # DW_CFA_offset, column 0x3
++ .uleb128 0x4
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI8-.LCFI7
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x4
++ .byte 0xc6 # DW_CFA_restore, column 0x6
++ .byte 0xc3 # DW_CFA_restore, column 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI9-.LCFI8
++ .byte 0xc5 # DW_CFA_restore, column 0x5
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x4
++ .align 4
++.LEFDE2:
++.LSFDE4:
++ .long .LEFDE4-.LASFDE4 # FDE Length
++.LASFDE4:
++ .long .Lframe0 # FDE CIE offset
++ .long .LFB2 # FDE initial location
++ .long .LFE2-.LFB2 # FDE address range
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI10-.LFB2
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x8
++ .byte 0x85 # DW_CFA_offset, column 0x5
++ .uleb128 0x2
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI11-.LCFI10
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x5
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI13-.LCFI11
++ .byte 0x86 # DW_CFA_offset, column 0x6
++ .uleb128 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI14-.LCFI13
++ .byte 0x83 # DW_CFA_offset, column 0x3
++ .uleb128 0x4
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI15-.LCFI14
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x4
++ .byte 0xc6 # DW_CFA_restore, column 0x6
++ .byte 0xc3 # DW_CFA_restore, column 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI16-.LCFI15
++ .byte 0xc5 # DW_CFA_restore, column 0x5
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x4
++ .align 4
++.LEFDE4:
++.LSFDE6:
++ .long .LEFDE6-.LASFDE6 # FDE Length
++.LASFDE6:
++ .long .Lframe0 # FDE CIE offset
++ .long .LFB3 # FDE initial location
++ .long .LFE3-.LFB3 # FDE address range
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI17-.LFB3
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x8
++ .byte 0x85 # DW_CFA_offset, column 0x5
++ .uleb128 0x2
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI18-.LCFI17
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x5
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI20-.LCFI18
++ .byte 0x86 # DW_CFA_offset, column 0x6
++ .uleb128 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI21-.LCFI20
++ .byte 0x83 # DW_CFA_offset, column 0x3
++ .uleb128 0x4
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI22-.LCFI21
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x4
++ .byte 0xc6 # DW_CFA_restore, column 0x6
++ .byte 0xc3 # DW_CFA_restore, column 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI23-.LCFI22
++ .byte 0xc5 # DW_CFA_restore, column 0x5
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x4
++ .align 4
++.LEFDE6:
++.LSFDE8:
++ .long .LEFDE8-.LASFDE8 # FDE Length
++.LASFDE8:
++ .long .Lframe0 # FDE CIE offset
++ .long .LFB4 # FDE initial location
++ .long .LFE4-.LFB4 # FDE address range
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI24-.LFB4
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x8
++ .byte 0x85 # DW_CFA_offset, column 0x5
++ .uleb128 0x2
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI25-.LCFI24
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x5
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI27-.LCFI25
++ .byte 0x86 # DW_CFA_offset, column 0x6
++ .uleb128 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI28-.LCFI27
++ .byte 0x83 # DW_CFA_offset, column 0x3
++ .uleb128 0x4
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI29-.LCFI28
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x4
++ .byte 0xc6 # DW_CFA_restore, column 0x6
++ .byte 0xc3 # DW_CFA_restore, column 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI30-.LCFI29
++ .byte 0xc5 # DW_CFA_restore, column 0x5
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x4
++ .align 4
++.LEFDE8:
++.LSFDE10:
++ .long .LEFDE10-.LASFDE10 # FDE Length
++.LASFDE10:
++ .long .Lframe0 # FDE CIE offset
++ .long .LFB5 # FDE initial location
++ .long .LFE5-.LFB5 # FDE address range
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI31-.LFB5
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x8
++ .byte 0x85 # DW_CFA_offset, column 0x5
++ .uleb128 0x2
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI32-.LCFI31
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x5
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI34-.LCFI32
++ .byte 0x86 # DW_CFA_offset, column 0x6
++ .uleb128 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI35-.LCFI34
++ .byte 0x83 # DW_CFA_offset, column 0x3
++ .uleb128 0x4
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI36-.LCFI35
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x4
++ .byte 0xc6 # DW_CFA_restore, column 0x6
++ .byte 0xc3 # DW_CFA_restore, column 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI37-.LCFI36
++ .byte 0xc5 # DW_CFA_restore, column 0x5
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x4
++ .align 4
++.LEFDE10:
++.LSFDE12:
++ .long .LEFDE12-.LASFDE12 # FDE Length
++.LASFDE12:
++ .long .Lframe0 # FDE CIE offset
++ .long .LFB6 # FDE initial location
++ .long .LFE6-.LFB6 # FDE address range
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI38-.LFB6
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x8
++ .byte 0x85 # DW_CFA_offset, column 0x5
++ .uleb128 0x2
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI39-.LCFI38
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x5
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI40-.LCFI39
++ .byte 0x83 # DW_CFA_offset, column 0x3
++ .uleb128 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI42-.LCFI40
++ .byte 0xc3 # DW_CFA_restore, column 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI43-.LCFI42
++ .byte 0xc5 # DW_CFA_restore, column 0x5
++ .byte 0xc # DW_CFA_def_cfa
++ .uleb128 0x4
++ .uleb128 0x4
++ .align 4
++.LEFDE12:
++#NO_APP
++ .text
++.Letext0:
++ .section .debug_loc,"",@progbits
++.Ldebug_loc0:
++.LLST0:
++ .long .LFB0-.Ltext0 # Location list begin address (*.LLST0)
++ .long .LCFI0-.Ltext0 # Location list end address (*.LLST0)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long .LCFI0-.Ltext0 # Location list begin address (*.LLST0)
++ .long .LCFI1-.Ltext0 # Location list end address (*.LLST0)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI1-.Ltext0 # Location list begin address (*.LLST0)
++ .long .LCFI2-.Ltext0 # Location list end address (*.LLST0)
++ .value 0x2 # Location expression size
++ .byte 0x75 # DW_OP_breg5
++ .sleb128 8
++ .long .LCFI2-.Ltext0 # Location list begin address (*.LLST0)
++ .long .LFE0-.Ltext0 # Location list end address (*.LLST0)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long 0 # Location list terminator begin (*.LLST0)
++ .long 0 # Location list terminator end (*.LLST0)
++.LLST1:
++ .long .LFB1-.Ltext0 # Location list begin address (*.LLST1)
++ .long .LCFI3-.Ltext0 # Location list end address (*.LLST1)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long .LCFI3-.Ltext0 # Location list begin address (*.LLST1)
++ .long .LCFI4-.Ltext0 # Location list end address (*.LLST1)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI4-.Ltext0 # Location list begin address (*.LLST1)
++ .long .LCFI8-.Ltext0 # Location list end address (*.LLST1)
++ .value 0x2 # Location expression size
++ .byte 0x75 # DW_OP_breg5
++ .sleb128 8
++ .long .LCFI8-.Ltext0 # Location list begin address (*.LLST1)
++ .long .LCFI9-.Ltext0 # Location list end address (*.LLST1)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI9-.Ltext0 # Location list begin address (*.LLST1)
++ .long .LFE1-.Ltext0 # Location list end address (*.LLST1)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long 0 # Location list terminator begin (*.LLST1)
++ .long 0 # Location list terminator end (*.LLST1)
++.LLST2:
++ .long .LVL1-.Ltext0 # Location list begin address (*.LLST2)
++ .long .LVL2-.Ltext0 # Location list end address (*.LLST2)
++ .value 0x6 # Location expression size
++ .byte 0x34 # DW_OP_lit4
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL2-.Ltext0 # Location list begin address (*.LLST2)
++ .long .LVL3-.Ltext0 # Location list end address (*.LLST2)
++ .value 0xc # Location expression size
++ .byte 0x34 # DW_OP_lit4
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x6 # DW_OP_deref
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0x6
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL3-.Ltext0 # Location list begin address (*.LLST2)
++ .long .LVL4-.Ltext0 # Location list end address (*.LLST2)
++ .value 0xb # Location expression size
++ .byte 0x53 # DW_OP_reg3
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x6 # DW_OP_deref
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0x6
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL4-.Ltext0 # Location list begin address (*.LLST2)
++ .long .LVL5-.Ltext0 # Location list end address (*.LLST2)
++ .value 0x6 # Location expression size
++ .byte 0x53 # DW_OP_reg3
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x56 # DW_OP_reg6
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL5-.Ltext0 # Location list begin address (*.LLST2)
++ .long .LVL6-.Ltext0 # Location list end address (*.LLST2)
++ .value 0x5 # Location expression size
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x56 # DW_OP_reg6
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long 0 # Location list terminator begin (*.LLST2)
++ .long 0 # Location list terminator end (*.LLST2)
++.LLST3:
++ .long .LFB2-.Ltext0 # Location list begin address (*.LLST3)
++ .long .LCFI10-.Ltext0 # Location list end address (*.LLST3)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long .LCFI10-.Ltext0 # Location list begin address (*.LLST3)
++ .long .LCFI11-.Ltext0 # Location list end address (*.LLST3)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI11-.Ltext0 # Location list begin address (*.LLST3)
++ .long .LCFI15-.Ltext0 # Location list end address (*.LLST3)
++ .value 0x2 # Location expression size
++ .byte 0x75 # DW_OP_breg5
++ .sleb128 8
++ .long .LCFI15-.Ltext0 # Location list begin address (*.LLST3)
++ .long .LCFI16-.Ltext0 # Location list end address (*.LLST3)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI16-.Ltext0 # Location list begin address (*.LLST3)
++ .long .LFE2-.Ltext0 # Location list end address (*.LLST3)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long 0 # Location list terminator begin (*.LLST3)
++ .long 0 # Location list terminator end (*.LLST3)
++.LLST4:
++ .long .LVL7-.Ltext0 # Location list begin address (*.LLST4)
++ .long .LVL8-.Ltext0 # Location list end address (*.LLST4)
++ .value 0x6 # Location expression size
++ .byte 0x34 # DW_OP_lit4
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL8-.Ltext0 # Location list begin address (*.LLST4)
++ .long .LVL9-.Ltext0 # Location list end address (*.LLST4)
++ .value 0xc # Location expression size
++ .byte 0x34 # DW_OP_lit4
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x6 # DW_OP_deref
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0x6
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL9-.Ltext0 # Location list begin address (*.LLST4)
++ .long .LVL10-.Ltext0 # Location list end address (*.LLST4)
++ .value 0xb # Location expression size
++ .byte 0x53 # DW_OP_reg3
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x6 # DW_OP_deref
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0x6
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL10-.Ltext0 # Location list begin address (*.LLST4)
++ .long .LVL11-.Ltext0 # Location list end address (*.LLST4)
++ .value 0x6 # Location expression size
++ .byte 0x53 # DW_OP_reg3
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x56 # DW_OP_reg6
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL11-.Ltext0 # Location list begin address (*.LLST4)
++ .long .LVL12-.Ltext0 # Location list end address (*.LLST4)
++ .value 0x5 # Location expression size
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x56 # DW_OP_reg6
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long 0 # Location list terminator begin (*.LLST4)
++ .long 0 # Location list terminator end (*.LLST4)
++.LLST5:
++ .long .LFB3-.Ltext0 # Location list begin address (*.LLST5)
++ .long .LCFI17-.Ltext0 # Location list end address (*.LLST5)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long .LCFI17-.Ltext0 # Location list begin address (*.LLST5)
++ .long .LCFI18-.Ltext0 # Location list end address (*.LLST5)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI18-.Ltext0 # Location list begin address (*.LLST5)
++ .long .LCFI22-.Ltext0 # Location list end address (*.LLST5)
++ .value 0x2 # Location expression size
++ .byte 0x75 # DW_OP_breg5
++ .sleb128 8
++ .long .LCFI22-.Ltext0 # Location list begin address (*.LLST5)
++ .long .LCFI23-.Ltext0 # Location list end address (*.LLST5)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI23-.Ltext0 # Location list begin address (*.LLST5)
++ .long .LFE3-.Ltext0 # Location list end address (*.LLST5)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long 0 # Location list terminator begin (*.LLST5)
++ .long 0 # Location list terminator end (*.LLST5)
++.LLST6:
++ .long .LVL13-.Ltext0 # Location list begin address (*.LLST6)
++ .long .LVL14-.Ltext0 # Location list end address (*.LLST6)
++ .value 0xa # Location expression size
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0x4
++ .uleb128 0
++ .byte 0x34 # DW_OP_lit4
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0xc
++ .uleb128 0
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x2
++ .long .LVL14-.Ltext0 # Location list begin address (*.LLST6)
++ .long .LVL15-.Ltext0 # Location list end address (*.LLST6)
++ .value 0x15 # Location expression size
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0x4
++ .uleb128 0
++ .byte 0x34 # DW_OP_lit4
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0xc
++ .uleb128 0
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x94 # DW_OP_deref_size
++ .byte 0x2
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0x6
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0xc
++ .uleb128 0
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0x4
++ .uleb128 0
++ .long .LVL15-.Ltext0 # Location list begin address (*.LLST6)
++ .long .LVL16-1-.Ltext0 # Location list end address (*.LLST6)
++ .value 0x14 # Location expression size
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0x4
++ .uleb128 0
++ .byte 0x52 # DW_OP_reg2
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0xc
++ .uleb128 0
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x94 # DW_OP_deref_size
++ .byte 0x2
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0x7
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0xc
++ .uleb128 0
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0x4
++ .uleb128 0
++ .long .LVL16-1-.Ltext0 # Location list begin address (*.LLST6)
++ .long .LVL17-.Ltext0 # Location list end address (*.LLST6)
++ .value 0x14 # Location expression size
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0x4
++ .uleb128 0
++ .byte 0x56 # DW_OP_reg6
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0xc
++ .uleb128 0
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x94 # DW_OP_deref_size
++ .byte 0x2
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0x7
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0xc
++ .uleb128 0
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0x4
++ .uleb128 0
++ .long .LVL17-.Ltext0 # Location list begin address (*.LLST6)
++ .long .LFE3-.Ltext0 # Location list end address (*.LLST6)
++ .value 0xf # Location expression size
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x2
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x94 # DW_OP_deref_size
++ .byte 0x2
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0x7
++ .byte 0x9f # DW_OP_stack_value
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0xc
++ .uleb128 0
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0x4
++ .uleb128 0
++ .long 0 # Location list terminator begin (*.LLST6)
++ .long 0 # Location list terminator end (*.LLST6)
++.LLST7:
++ .long .LFB4-.Ltext0 # Location list begin address (*.LLST7)
++ .long .LCFI24-.Ltext0 # Location list end address (*.LLST7)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long .LCFI24-.Ltext0 # Location list begin address (*.LLST7)
++ .long .LCFI25-.Ltext0 # Location list end address (*.LLST7)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI25-.Ltext0 # Location list begin address (*.LLST7)
++ .long .LCFI29-.Ltext0 # Location list end address (*.LLST7)
++ .value 0x2 # Location expression size
++ .byte 0x75 # DW_OP_breg5
++ .sleb128 8
++ .long .LCFI29-.Ltext0 # Location list begin address (*.LLST7)
++ .long .LCFI30-.Ltext0 # Location list end address (*.LLST7)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI30-.Ltext0 # Location list begin address (*.LLST7)
++ .long .LFE4-.Ltext0 # Location list end address (*.LLST7)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long 0 # Location list terminator begin (*.LLST7)
++ .long 0 # Location list terminator end (*.LLST7)
++.LLST8:
++ .long .LVL19-.Ltext0 # Location list begin address (*.LLST8)
++ .long .LVL20-.Ltext0 # Location list end address (*.LLST8)
++ .value 0x8 # Location expression size
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL20-.Ltext0 # Location list begin address (*.LLST8)
++ .long .LVL21-.Ltext0 # Location list end address (*.LLST8)
++ .value 0x6 # Location expression size
++ .byte 0x53 # DW_OP_reg3
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x56 # DW_OP_reg6
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL21-.Ltext0 # Location list begin address (*.LLST8)
++ .long .LVL22-.Ltext0 # Location list end address (*.LLST8)
++ .value 0x5 # Location expression size
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x56 # DW_OP_reg6
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long 0 # Location list terminator begin (*.LLST8)
++ .long 0 # Location list terminator end (*.LLST8)
++.LLST9:
++ .long .LFB5-.Ltext0 # Location list begin address (*.LLST9)
++ .long .LCFI31-.Ltext0 # Location list end address (*.LLST9)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long .LCFI31-.Ltext0 # Location list begin address (*.LLST9)
++ .long .LCFI32-.Ltext0 # Location list end address (*.LLST9)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI32-.Ltext0 # Location list begin address (*.LLST9)
++ .long .LCFI36-.Ltext0 # Location list end address (*.LLST9)
++ .value 0x2 # Location expression size
++ .byte 0x75 # DW_OP_breg5
++ .sleb128 8
++ .long .LCFI36-.Ltext0 # Location list begin address (*.LLST9)
++ .long .LCFI37-.Ltext0 # Location list end address (*.LLST9)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI37-.Ltext0 # Location list begin address (*.LLST9)
++ .long .LFE5-.Ltext0 # Location list end address (*.LLST9)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long 0 # Location list terminator begin (*.LLST9)
++ .long 0 # Location list terminator end (*.LLST9)
++.LLST10:
++ .long .LVL24-.Ltext0 # Location list begin address (*.LLST10)
++ .long .LVL25-.Ltext0 # Location list end address (*.LLST10)
++ .value 0x8 # Location expression size
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL25-.Ltext0 # Location list begin address (*.LLST10)
++ .long .LVL26-.Ltext0 # Location list end address (*.LLST10)
++ .value 0x6 # Location expression size
++ .byte 0x53 # DW_OP_reg3
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x56 # DW_OP_reg6
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL26-.Ltext0 # Location list begin address (*.LLST10)
++ .long .LVL27-.Ltext0 # Location list end address (*.LLST10)
++ .value 0x5 # Location expression size
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x56 # DW_OP_reg6
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long 0 # Location list terminator begin (*.LLST10)
++ .long 0 # Location list terminator end (*.LLST10)
++.LLST11:
++ .long .LFB6-.Ltext0 # Location list begin address (*.LLST11)
++ .long .LCFI38-.Ltext0 # Location list end address (*.LLST11)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long .LCFI38-.Ltext0 # Location list begin address (*.LLST11)
++ .long .LCFI39-.Ltext0 # Location list end address (*.LLST11)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI39-.Ltext0 # Location list begin address (*.LLST11)
++ .long .LCFI43-.Ltext0 # Location list end address (*.LLST11)
++ .value 0x2 # Location expression size
++ .byte 0x75 # DW_OP_breg5
++ .sleb128 8
++ .long .LCFI43-.Ltext0 # Location list begin address (*.LLST11)
++ .long .LFE6-.Ltext0 # Location list end address (*.LLST11)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long 0 # Location list terminator begin (*.LLST11)
++ .long 0 # Location list terminator end (*.LLST11)
++.LLST12:
++ .long .LVL28-.Ltext0 # Location list begin address (*.LLST12)
++ .long .LVL29-.Ltext0 # Location list end address (*.LLST12)
++ .value 0x1 # Location expression size
++ .byte 0x53 # DW_OP_reg3
++ .long 0 # Location list terminator begin (*.LLST12)
++ .long 0 # Location list terminator end (*.LLST12)
++ .section .debug_info
++ .long 0x1e3 # Length of Compilation Unit Info
++ .value 0x2 # DWARF version number
++ .long .Ldebug_abbrev0 # Offset Into Abbrev. Section
++ .byte 0x4 # Pointer Size (in bytes)
++ .uleb128 0x1 # (DIE (0xb) DW_TAG_compile_unit)
++ .long .LASF1 # DW_AT_producer: "GNU C 4.6.0 20100506 (experimental) [trunk revision 159117]"
++ .byte 0x1 # DW_AT_language
++ .long .LASF2 # DW_AT_name: "pieces.c"
++ .long .LASF3 # DW_AT_comp_dir: "/home/tromey/gnu/archer/archer/gdb/testsuite/gdb.dwarf2"
++ .long .Ltext0 # DW_AT_low_pc
++ .long .Letext0 # DW_AT_high_pc
++ .long .Ldebug_line0 # DW_AT_stmt_list
++ .uleb128 0x2 # (DIE (0x25) DW_TAG_structure_type)
++ .ascii "A\0" # DW_AT_name
++ .byte 0x8 # DW_AT_byte_size
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x17 # DW_AT_decl_line
++ .long 0x48 # DW_AT_sibling
++ .uleb128 0x3 # (DIE (0x2f) DW_TAG_member)
++ .ascii "i\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x17 # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x2 # DW_AT_data_member_location
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0
++ .uleb128 0x3 # (DIE (0x3b) DW_TAG_member)
++ .ascii "j\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x17 # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x2 # DW_AT_data_member_location
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0x4
++ .byte 0 # end of children of DIE 0x25
++ .uleb128 0x4 # (DIE (0x48) DW_TAG_base_type)
++ .byte 0x4 # DW_AT_byte_size
++ .byte 0x5 # DW_AT_encoding
++ .ascii "int\0" # DW_AT_name
++ .uleb128 0x2 # (DIE (0x4f) DW_TAG_structure_type)
++ .ascii "B\0" # DW_AT_name
++ .byte 0x4 # DW_AT_byte_size
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x18 # DW_AT_decl_line
++ .long 0x78 # DW_AT_sibling
++ .uleb128 0x5 # (DIE (0x59) DW_TAG_member)
++ .ascii "i\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x18 # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x4 # DW_AT_byte_size
++ .byte 0xc # DW_AT_bit_size
++ .byte 0x10 # DW_AT_bit_offset
++ .byte 0x2 # DW_AT_data_member_location
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0
++ .uleb128 0x5 # (DIE (0x68) DW_TAG_member)
++ .ascii "j\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x18 # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x4 # DW_AT_byte_size
++ .byte 0xc # DW_AT_bit_size
++ .byte 0x4 # DW_AT_bit_offset
++ .byte 0x2 # DW_AT_data_member_location
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0
++ .byte 0 # end of children of DIE 0x4f
++ .uleb128 0x6 # (DIE (0x78) DW_TAG_subprogram)
++ .byte 0x1 # DW_AT_external
++ .ascii "bar\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x1b # DW_AT_decl_line
++ .byte 0x1 # DW_AT_prototyped
++ .long .LFB0 # DW_AT_low_pc
++ .long .LFE0 # DW_AT_high_pc
++ .long .LLST0 # DW_AT_frame_base
++ .long 0x9e # DW_AT_sibling
++ .uleb128 0x7 # (DIE (0x91) DW_TAG_formal_parameter)
++ .ascii "x\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x1b # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x2 # DW_AT_location
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0 # end of children of DIE 0x78
++ .uleb128 0x8 # (DIE (0x9e) DW_TAG_subprogram)
++ .byte 0x1 # DW_AT_external
++ .ascii "f1\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x21 # DW_AT_decl_line
++ .byte 0x1 # DW_AT_prototyped
++ .long 0x48 # DW_AT_type
++ .long .LFB1 # DW_AT_low_pc
++ .long .LFE1 # DW_AT_high_pc
++ .long .LLST1 # DW_AT_frame_base
++ .long 0xd4 # DW_AT_sibling
++ .uleb128 0x7 # (DIE (0xba) DW_TAG_formal_parameter)
++ .ascii "k\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x21 # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x2 # DW_AT_location
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .uleb128 0x9 # (DIE (0xc6) DW_TAG_variable)
++ .ascii "a\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x23 # DW_AT_decl_line
++ .long 0x25 # DW_AT_type
++ .long .LLST2 # DW_AT_location
++ .byte 0 # end of children of DIE 0x9e
++ .uleb128 0x8 # (DIE (0xd4) DW_TAG_subprogram)
++ .byte 0x1 # DW_AT_external
++ .ascii "f2\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x2c # DW_AT_decl_line
++ .byte 0x1 # DW_AT_prototyped
++ .long 0x48 # DW_AT_type
++ .long .LFB2 # DW_AT_low_pc
++ .long .LFE2 # DW_AT_high_pc
++ .long .LLST3 # DW_AT_frame_base
++ .long 0x10a # DW_AT_sibling
++ .uleb128 0x7 # (DIE (0xf0) DW_TAG_formal_parameter)
++ .ascii "k\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x2c # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x2 # DW_AT_location
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .uleb128 0x9 # (DIE (0xfc) DW_TAG_variable)
++ .ascii "a\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x2e # DW_AT_decl_line
++ .long 0x10a # DW_AT_type
++ .long .LLST4 # DW_AT_location
++ .byte 0 # end of children of DIE 0xd4
++ .uleb128 0xa # (DIE (0x10a) DW_TAG_array_type)
++ .long 0x48 # DW_AT_type
++ .long 0x11a # DW_AT_sibling
++ .uleb128 0xb # (DIE (0x113) DW_TAG_subrange_type)
++ .long 0x11a # DW_AT_type
++ .byte 0x1 # DW_AT_upper_bound
++ .byte 0 # end of children of DIE 0x10a
++ .uleb128 0xc # (DIE (0x11a) DW_TAG_base_type)
++ .byte 0x4 # DW_AT_byte_size
++ .byte 0x7 # DW_AT_encoding
++ .uleb128 0x8 # (DIE (0x11d) DW_TAG_subprogram)
++ .byte 0x1 # DW_AT_external
++ .ascii "f3\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x37 # DW_AT_decl_line
++ .byte 0x1 # DW_AT_prototyped
++ .long 0x48 # DW_AT_type
++ .long .LFB3 # DW_AT_low_pc
++ .long .LFE3 # DW_AT_high_pc
++ .long .LLST5 # DW_AT_frame_base
++ .long 0x153 # DW_AT_sibling
++ .uleb128 0x7 # (DIE (0x139) DW_TAG_formal_parameter)
++ .ascii "k\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x37 # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x2 # DW_AT_location
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .uleb128 0x9 # (DIE (0x145) DW_TAG_variable)
++ .ascii "a\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x39 # DW_AT_decl_line
++ .long 0x4f # DW_AT_type
++ .long .LLST6 # DW_AT_location
++ .byte 0 # end of children of DIE 0x11d
++ .uleb128 0x8 # (DIE (0x153) DW_TAG_subprogram)
++ .byte 0x1 # DW_AT_external
++ .ascii "f4\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x42 # DW_AT_decl_line
++ .byte 0x1 # DW_AT_prototyped
++ .long 0x48 # DW_AT_type
++ .long .LFB4 # DW_AT_low_pc
++ .long .LFE4 # DW_AT_high_pc
++ .long .LLST7 # DW_AT_frame_base
++ .long 0x189 # DW_AT_sibling
++ .uleb128 0x7 # (DIE (0x16f) DW_TAG_formal_parameter)
++ .ascii "k\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x42 # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x2 # DW_AT_location
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .uleb128 0x9 # (DIE (0x17b) DW_TAG_variable)
++ .ascii "a\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x44 # DW_AT_decl_line
++ .long 0x10a # DW_AT_type
++ .long .LLST8 # DW_AT_location
++ .byte 0 # end of children of DIE 0x153
++ .uleb128 0x8 # (DIE (0x189) DW_TAG_subprogram)
++ .byte 0x1 # DW_AT_external
++ .ascii "f5\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x4d # DW_AT_decl_line
++ .byte 0x1 # DW_AT_prototyped
++ .long 0x48 # DW_AT_type
++ .long .LFB5 # DW_AT_low_pc
++ .long .LFE5 # DW_AT_high_pc
++ .long .LLST9 # DW_AT_frame_base
++ .long 0x1bf # DW_AT_sibling
++ .uleb128 0x7 # (DIE (0x1a5) DW_TAG_formal_parameter)
++ .ascii "k\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x4d # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x2 # DW_AT_location
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .uleb128 0x9 # (DIE (0x1b1) DW_TAG_variable)
++ .ascii "a\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x4f # DW_AT_decl_line
++ .long 0x25 # DW_AT_type
++ .long .LLST10 # DW_AT_location
++ .byte 0 # end of children of DIE 0x189
++ .uleb128 0xd # (DIE (0x1bf) DW_TAG_subprogram)
++ .byte 0x1 # DW_AT_external
++ .long .LASF0 # DW_AT_name: "main"
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x58 # DW_AT_decl_line
++ .byte 0x1 # DW_AT_prototyped
++ .long 0x48 # DW_AT_type
++ .long .LFB6 # DW_AT_low_pc
++ .long .LFE6 # DW_AT_high_pc
++ .long .LLST11 # DW_AT_frame_base
++ .uleb128 0x9 # (DIE (0x1d8) DW_TAG_variable)
++ .ascii "k\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x5a # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .long .LLST12 # DW_AT_location
++ .byte 0 # end of children of DIE 0x1bf
++ .byte 0 # end of children of DIE 0xb
++ .section .debug_abbrev
++ .uleb128 0x1 # (abbrev code)
++ .uleb128 0x11 # (TAG: DW_TAG_compile_unit)
++ .byte 0x1 # DW_children_yes
++ .uleb128 0x25 # (DW_AT_producer)
++ .uleb128 0xe # (DW_FORM_strp)
++ .uleb128 0x13 # (DW_AT_language)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3 # (DW_AT_name)
++ .uleb128 0xe # (DW_FORM_strp)
++ .uleb128 0x1b # (DW_AT_comp_dir)
++ .uleb128 0xe # (DW_FORM_strp)
++ .uleb128 0x11 # (DW_AT_low_pc)
++ .uleb128 0x1 # (DW_FORM_addr)
++ .uleb128 0x12 # (DW_AT_high_pc)
++ .uleb128 0x1 # (DW_FORM_addr)
++ .uleb128 0x10 # (DW_AT_stmt_list)
++ .uleb128 0x6 # (DW_FORM_data4)
++ .byte 0
++ .byte 0
++ .uleb128 0x2 # (abbrev code)
++ .uleb128 0x13 # (TAG: DW_TAG_structure_type)
++ .byte 0x1 # DW_children_yes
++ .uleb128 0x3 # (DW_AT_name)
++ .uleb128 0x8 # (DW_FORM_string)
++ .uleb128 0xb # (DW_AT_byte_size)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3a # (DW_AT_decl_file)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3b # (DW_AT_decl_line)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x1 # (DW_AT_sibling)
++ .uleb128 0x13 # (DW_FORM_ref4)
++ .byte 0
++ .byte 0
++ .uleb128 0x3 # (abbrev code)
++ .uleb128 0xd # (TAG: DW_TAG_member)
++ .byte 0 # DW_children_no
++ .uleb128 0x3 # (DW_AT_name)
++ .uleb128 0x8 # (DW_FORM_string)
++ .uleb128 0x3a # (DW_AT_decl_file)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3b # (DW_AT_decl_line)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x49 # (DW_AT_type)
++ .uleb128 0x13 # (DW_FORM_ref4)
++ .uleb128 0x38 # (DW_AT_data_member_location)
++ .uleb128 0xa # (DW_FORM_block1)
++ .byte 0
++ .byte 0
++ .uleb128 0x4 # (abbrev code)
++ .uleb128 0x24 # (TAG: DW_TAG_base_type)
++ .byte 0 # DW_children_no
++ .uleb128 0xb # (DW_AT_byte_size)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3e # (DW_AT_encoding)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3 # (DW_AT_name)
++ .uleb128 0x8 # (DW_FORM_string)
++ .byte 0
++ .byte 0
++ .uleb128 0x5 # (abbrev code)
++ .uleb128 0xd # (TAG: DW_TAG_member)
++ .byte 0 # DW_children_no
++ .uleb128 0x3 # (DW_AT_name)
++ .uleb128 0x8 # (DW_FORM_string)
++ .uleb128 0x3a # (DW_AT_decl_file)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3b # (DW_AT_decl_line)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x49 # (DW_AT_type)
++ .uleb128 0x13 # (DW_FORM_ref4)
++ .uleb128 0xb # (DW_AT_byte_size)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0xd # (DW_AT_bit_size)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0xc # (DW_AT_bit_offset)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x38 # (DW_AT_data_member_location)
++ .uleb128 0xa # (DW_FORM_block1)
++ .byte 0
++ .byte 0
++ .uleb128 0x6 # (abbrev code)
++ .uleb128 0x2e # (TAG: DW_TAG_subprogram)
++ .byte 0x1 # DW_children_yes
++ .uleb128 0x3f # (DW_AT_external)
++ .uleb128 0xc # (DW_FORM_flag)
++ .uleb128 0x3 # (DW_AT_name)
++ .uleb128 0x8 # (DW_FORM_string)
++ .uleb128 0x3a # (DW_AT_decl_file)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3b # (DW_AT_decl_line)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x27 # (DW_AT_prototyped)
++ .uleb128 0xc # (DW_FORM_flag)
++ .uleb128 0x11 # (DW_AT_low_pc)
++ .uleb128 0x1 # (DW_FORM_addr)
++ .uleb128 0x12 # (DW_AT_high_pc)
++ .uleb128 0x1 # (DW_FORM_addr)
++ .uleb128 0x40 # (DW_AT_frame_base)
++ .uleb128 0x6 # (DW_FORM_data4)
++ .uleb128 0x1 # (DW_AT_sibling)
++ .uleb128 0x13 # (DW_FORM_ref4)
++ .byte 0
++ .byte 0
++ .uleb128 0x7 # (abbrev code)
++ .uleb128 0x5 # (TAG: DW_TAG_formal_parameter)
++ .byte 0 # DW_children_no
++ .uleb128 0x3 # (DW_AT_name)
++ .uleb128 0x8 # (DW_FORM_string)
++ .uleb128 0x3a # (DW_AT_decl_file)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3b # (DW_AT_decl_line)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x49 # (DW_AT_type)
++ .uleb128 0x13 # (DW_FORM_ref4)
++ .uleb128 0x2 # (DW_AT_location)
++ .uleb128 0xa # (DW_FORM_block1)
++ .byte 0
++ .byte 0
++ .uleb128 0x8 # (abbrev code)
++ .uleb128 0x2e # (TAG: DW_TAG_subprogram)
++ .byte 0x1 # DW_children_yes
++ .uleb128 0x3f # (DW_AT_external)
++ .uleb128 0xc # (DW_FORM_flag)
++ .uleb128 0x3 # (DW_AT_name)
++ .uleb128 0x8 # (DW_FORM_string)
++ .uleb128 0x3a # (DW_AT_decl_file)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3b # (DW_AT_decl_line)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x27 # (DW_AT_prototyped)
++ .uleb128 0xc # (DW_FORM_flag)
++ .uleb128 0x49 # (DW_AT_type)
++ .uleb128 0x13 # (DW_FORM_ref4)
++ .uleb128 0x11 # (DW_AT_low_pc)
++ .uleb128 0x1 # (DW_FORM_addr)
++ .uleb128 0x12 # (DW_AT_high_pc)
++ .uleb128 0x1 # (DW_FORM_addr)
++ .uleb128 0x40 # (DW_AT_frame_base)
++ .uleb128 0x6 # (DW_FORM_data4)
++ .uleb128 0x1 # (DW_AT_sibling)
++ .uleb128 0x13 # (DW_FORM_ref4)
++ .byte 0
++ .byte 0
++ .uleb128 0x9 # (abbrev code)
++ .uleb128 0x34 # (TAG: DW_TAG_variable)
++ .byte 0 # DW_children_no
++ .uleb128 0x3 # (DW_AT_name)
++ .uleb128 0x8 # (DW_FORM_string)
++ .uleb128 0x3a # (DW_AT_decl_file)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3b # (DW_AT_decl_line)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x49 # (DW_AT_type)
++ .uleb128 0x13 # (DW_FORM_ref4)
++ .uleb128 0x2 # (DW_AT_location)
++ .uleb128 0x6 # (DW_FORM_data4)
++ .byte 0
++ .byte 0
++ .uleb128 0xa # (abbrev code)
++ .uleb128 0x1 # (TAG: DW_TAG_array_type)
++ .byte 0x1 # DW_children_yes
++ .uleb128 0x49 # (DW_AT_type)
++ .uleb128 0x13 # (DW_FORM_ref4)
++ .uleb128 0x1 # (DW_AT_sibling)
++ .uleb128 0x13 # (DW_FORM_ref4)
++ .byte 0
++ .byte 0
++ .uleb128 0xb # (abbrev code)
++ .uleb128 0x21 # (TAG: DW_TAG_subrange_type)
++ .byte 0 # DW_children_no
++ .uleb128 0x49 # (DW_AT_type)
++ .uleb128 0x13 # (DW_FORM_ref4)
++ .uleb128 0x2f # (DW_AT_upper_bound)
++ .uleb128 0xb # (DW_FORM_data1)
++ .byte 0
++ .byte 0
++ .uleb128 0xc # (abbrev code)
++ .uleb128 0x24 # (TAG: DW_TAG_base_type)
++ .byte 0 # DW_children_no
++ .uleb128 0xb # (DW_AT_byte_size)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3e # (DW_AT_encoding)
++ .uleb128 0xb # (DW_FORM_data1)
++ .byte 0
++ .byte 0
++ .uleb128 0xd # (abbrev code)
++ .uleb128 0x2e # (TAG: DW_TAG_subprogram)
++ .byte 0x1 # DW_children_yes
++ .uleb128 0x3f # (DW_AT_external)
++ .uleb128 0xc # (DW_FORM_flag)
++ .uleb128 0x3 # (DW_AT_name)
++ .uleb128 0xe # (DW_FORM_strp)
++ .uleb128 0x3a # (DW_AT_decl_file)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3b # (DW_AT_decl_line)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x27 # (DW_AT_prototyped)
++ .uleb128 0xc # (DW_FORM_flag)
++ .uleb128 0x49 # (DW_AT_type)
++ .uleb128 0x13 # (DW_FORM_ref4)
++ .uleb128 0x11 # (DW_AT_low_pc)
++ .uleb128 0x1 # (DW_FORM_addr)
++ .uleb128 0x12 # (DW_AT_high_pc)
++ .uleb128 0x1 # (DW_FORM_addr)
++ .uleb128 0x40 # (DW_AT_frame_base)
++ .uleb128 0x6 # (DW_FORM_data4)
++ .byte 0
++ .byte 0
++ .byte 0
++ .section .debug_pubnames,"",@progbits
++ .long 0x42 # Length of Public Names Info
++ .value 0x2 # DWARF Version
++ .long .Ldebug_info0 # Offset of Compilation Unit Info
++ .long 0x1e7 # Compilation Unit Length
++ .long 0x78 # DIE offset
++ .ascii "bar\0" # external name
++ .long 0x9e # DIE offset
++ .ascii "f1\0" # external name
++ .long 0xd4 # DIE offset
++ .ascii "f2\0" # external name
++ .long 0x11d # DIE offset
++ .ascii "f3\0" # external name
++ .long 0x153 # DIE offset
++ .ascii "f4\0" # external name
++ .long 0x189 # DIE offset
++ .ascii "f5\0" # external name
++ .long 0x1bf # DIE offset
++ .ascii "main\0" # external name
++ .long 0
++ .section .debug_pubtypes,"",@progbits
++ .long 0x1a # Length of Public Type Names Info
++ .value 0x2 # DWARF Version
++ .long .Ldebug_info0 # Offset of Compilation Unit Info
++ .long 0x1e7 # Compilation Unit Length
++ .long 0x25 # DIE offset
++ .ascii "A\0" # external name
++ .long 0x4f # DIE offset
++ .ascii "B\0" # external name
++ .long 0
++ .section .debug_aranges,"",@progbits
++ .long 0x1c # Length of Address Ranges Info
++ .value 0x2 # DWARF Version
++ .long .Ldebug_info0 # Offset of Compilation Unit Info
++ .byte 0x4 # Size of Address
++ .byte 0 # Size of Segment Descriptor
++ .value 0 # Pad to 8 byte boundary
++ .value 0
++ .long .Ltext0 # Address
++ .long .Letext0-.Ltext0 # Length
++ .long 0
++ .long 0
++ .section .debug_str,"MS",@progbits,1
++.LASF2:
++ .string "pieces.c"
++.LASF3:
++ .string "/home/tromey/gnu/archer/archer/gdb/testsuite/gdb.dwarf2"
++.LASF1:
++ .string "GNU C 4.6.0 20100506 (experimental) [trunk revision 159117]"
++.LASF0:
++ .string "main"
++ .ident "GCC: (GNU) 4.6.0 20100506 (experimental) [trunk revision 159117]"
++ .section .note.GNU-stack,"",@progbits
+--- src/gdb/testsuite/gdb.dwarf2/pieces.c
++++ src/gdb/testsuite/gdb.dwarf2/pieces.c 2010-05-25 20:18:00.627622000 +0000
+@@ -0,0 +1,98 @@
++/* Copyright (C) 2010 Free Software Foundation, Inc.
++
++ This file is part of GDB.
++
++ 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 . */
++
++/* The original program corresponding to pieces.S.
++ This came from https://bugzilla.redhat.com/show_bug.cgi?id=589467
++ Note that it is not ever compiled, pieces.S is used instead.
++ However, it is used to extract breakpoint line numbers. */
++
++struct A { int i; int j; };
++struct B { int : 4; int i : 12; int j : 12; int : 4; };
++
++__attribute__((noinline)) void
++bar (int x)
++{
++ asm volatile ("" : : "r" (x) : "memory");
++}
++
++__attribute__((noinline)) int
++f1 (int k)
++{
++ struct A a = { 4, k + 6 };
++ asm ("" : "+r" (a.i));
++ a.j++;
++ bar (a.i); /* { dg-final { gdb-test 20 "a.i" "4" } } */
++ bar (a.j); /* { dg-final { gdb-test 20 "a.j" "14" } } */
++ return a.i + a.j; /* f1 breakpoint */
++}
++
++__attribute__((noinline)) int
++f2 (int k)
++{
++ int a[2] = { 4, k + 6 };
++ asm ("" : "+r" (a[0]));
++ a[1]++;
++ bar (a[0]); /* { dg-final { gdb-test 31 "a\[0\]" "4" } } */
++ bar (a[1]); /* { dg-final { gdb-test 31 "a\[1\]" "14" } } */
++ return a[0] + a[1]; /* f2 breakpoint */
++}
++
++__attribute__((noinline)) int
++f3 (int k)
++{
++ struct B a = { 4, k + 6 };
++ asm ("" : "+r" (a.i));
++ a.j++;
++ bar (a.i); /* { dg-final { gdb-test 42 "a.i" "4" } } */
++ bar (a.j); /* { dg-final { gdb-test 42 "a.j" "14" } } */
++ return a.i + a.j; /* f3 breakpoint */
++}
++
++__attribute__((noinline)) int
++f4 (int k)
++{
++ int a[2] = { k, k };
++ asm ("" : "+r" (a[0]));
++ a[1]++;
++ bar (a[0]);
++ bar (a[1]);
++ return a[0] + a[1]; /* f4 breakpoint */
++}
++
++__attribute__((noinline)) int
++f5 (int k)
++{
++ struct A a = { k, k };
++ asm ("" : "+r" (a.i));
++ a.j++;
++ bar (a.i);
++ bar (a.j);
++ return a.i + a.j; /* f5 breakpoint */
++}
++
++int
++main (void)
++{
++ int k;
++ asm ("" : "=r" (k) : "0" (7));
++ f1 (k);
++ f2 (k);
++ f3 (k);
++ f4 (k);
++ f5 (k);
++ return 0;
++}
+--- src/gdb/testsuite/gdb.dwarf2/pieces.exp
++++ src/gdb/testsuite/gdb.dwarf2/pieces.exp 2010-05-25 20:18:03.961111000 +0000
+@@ -0,0 +1,57 @@
++# Copyright 2010 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 .
++
++# Test some DWARF piece operators.
++
++# This test can only be run on targets which support DWARF-2 and use gas.
++# For now pick a sampling of likely targets.
++if {![istarget *-*-linux*]
++ && ![istarget *-*-gnu*]
++ && ![istarget *-*-elf*]
++ && ![istarget *-*-openbsd*]
++ && ![istarget arm-*-eabi*]
++ && ![istarget powerpc-*-eabi*]} {
++ return 0
++}
++# This test can only be run on x86 targets.
++if {![istarget i?86-*]} {
++ return 0
++}
++
++set testfile "pieces"
++set srcfile ${testfile}.S
++set csrcfile ${testfile}.c
++set binfile ${objdir}/${subdir}/${testfile}.x
++
++if {[prepare_for_testing ${testfile}.exp ${testfile}.x $srcfile]} {
++ return -1
++}
++
++if ![runto_main] {
++ return -1
++}
++
++# Function f1 tests a particular gdb bug involving DW_OP_piece.
++proc pieces_test_f1 {} {
++ global csrcfile
++ set line [gdb_get_line_number "f1 breakpoint" $csrcfile]
++ gdb_test "break pieces.c:$line" "Breakpoint 2.*" \
++ "set f1 breakpoint for pieces"
++ gdb_continue_to_breakpoint "continue to f1 breakpoint for pieces"
++ gdb_test "print a" " = {i = 4, j = 14}" "print a in pieces:f1"
++ gdb_test "print a.j" " = 14" "print a.j in pieces:f1"
++}
++
++pieces_test_f1
diff --git a/gdb-bz589467-pieces2of4.patch b/gdb-bz589467-pieces2of4.patch
new file mode 100644
index 0000000..4c27039
--- /dev/null
+++ b/gdb-bz589467-pieces2of4.patch
@@ -0,0 +1,53 @@
+http://sourceware.org/ml/gdb-cvs/2010-05/msg00188.html
+http://sourceware.org/ml/gdb-cvs/2010-05/msg00189.html
+
+### src/gdb/ChangeLog 2010/05/21 20:45:18 1.11830
+### src/gdb/ChangeLog 2010/05/21 20:56:48 1.11831
+## -1,3 +1,8 @@
++2010-05-21 Tom Tromey
++
++ * eval.c (evaluate_subexp_standard) : Call
++ evaluate_subexp, not evaluate_subexp_with_coercion.
++
+### src/gdb/testsuite/ChangeLog 2010/05/21 20:39:50 1.2273
+### src/gdb/testsuite/ChangeLog 2010/05/21 20:56:49 1.2274
+## -1,5 +1,10 @@
+ 2010-05-21 Tom Tromey
+
++ * gdb.dwarf2/pieces.exp (pieces_test_f2): New proc.
++ Call it.
++
+--- src/gdb/eval.c 2010/05/14 18:35:11 1.134
++++ src/gdb/eval.c 2010/05/21 20:56:49 1.135
+@@ -2059,8 +2059,8 @@
+ error (_("':' operator used in invalid context"));
+
+ case BINOP_SUBSCRIPT:
+- arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
+- arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
++ arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
++ arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ if (noside == EVAL_SKIP)
+ goto nosideret;
+ if (binop_user_defined_p (op, arg1, arg2))
+--- src/gdb/testsuite/gdb.dwarf2/pieces.exp 2010/05/21 20:39:50 1.1
++++ src/gdb/testsuite/gdb.dwarf2/pieces.exp 2010/05/21 21:00:27 1.2
+@@ -54,4 +54,18 @@
+ gdb_test "print a.j" " = 14" "print a.j in pieces:f1"
+ }
+
++# Function f2 tests for a bug when indexing into an array created
++# using DW_OP_piece.
++proc pieces_test_f2 {} {
++ global csrcfile
++ set line [gdb_get_line_number "f2 breakpoint" $csrcfile]
++ gdb_test "break pieces.c:$line" "Breakpoint 3.*" \
++ "set f2 breakpoint for pieces"
++ gdb_continue_to_breakpoint "continue to f2 breakpoint for pieces"
++ gdb_test "print a" " = .4, 14." "print a in pieces:f2"
++ gdb_test "print a\[0\]" " = 4" "print a\[0\] in pieces:f2"
++ gdb_test "print a\[1\]" " = 14" "print a\[1\] in pieces:f2"
++}
++
+ pieces_test_f1
++pieces_test_f2
diff --git a/gdb-bz589467-pieces3of4.patch b/gdb-bz589467-pieces3of4.patch
new file mode 100644
index 0000000..3d77fcf
--- /dev/null
+++ b/gdb-bz589467-pieces3of4.patch
@@ -0,0 +1,1198 @@
+http://sourceware.org/ml/gdb-cvs/2010-05/msg00190.html
+
+### src/gdb/ChangeLog 2010/05/21 20:56:48 1.11831
+### src/gdb/ChangeLog 2010/05/21 21:01:46 1.11832
+## -1,5 +1,16 @@
+ 2010-05-21 Tom Tromey
+
++ * dwarf2loc.c (read_pieced_value): Exit loop when result is full.
++ : New case.
++ * dwarf2expr.h (enum dwarf_value_location)
++ : New constant.
++ * dwarf2expr.c (dwarf_expr_stack_empty_p): New function.
++ (add_piece): Handle empty piece.
++ (execute_stack_op) : Handle
++ DWARF_VALUE_OPTIMIZED_OUT.
++
+### src/gdb/testsuite/ChangeLog 2010/05/21 20:56:49 1.2274
+### src/gdb/testsuite/ChangeLog 2010/05/21 21:01:46 1.2275
+## -1,5 +1,13 @@
+ 2010-05-21 Tom Tromey
+
++ * gdb.dwarf2/pieces.exp (pieces_test_f6): New proc.
++ Call it.
++ * gdb.dwarf2/pieces.c (struct C): New.
++ (f6): New function.
++ * gdb.dwarf2/pieces.S: Replace.
++
+--- src/gdb/dwarf2expr.c 2010/05/14 17:53:16 1.42
++++ src/gdb/dwarf2expr.c 2010/05/21 21:01:46 1.43
+@@ -143,6 +143,14 @@
+
+ }
+
++/* Return true if the expression stack is empty. */
++
++static int
++dwarf_expr_stack_empty_p (struct dwarf_expr_context *ctx)
++{
++ return ctx->stack_len == 0;
++}
++
+ /* Add a new piece to CTX's piece list. */
+ static void
+ add_piece (struct dwarf_expr_context *ctx, ULONGEST size)
+@@ -167,6 +175,15 @@
+ p->v.literal.data = ctx->data;
+ p->v.literal.length = ctx->len;
+ }
++ else if (dwarf_expr_stack_empty_p (ctx))
++ {
++ p->location = DWARF_VALUE_OPTIMIZED_OUT;
++ /* Also reset the context's location, for our callers. This is
++ a somewhat strange approach, but this lets us avoid setting
++ the location to DWARF_VALUE_MEMORY in all the individual
++ cases in the evaluator. */
++ ctx->location = DWARF_VALUE_OPTIMIZED_OUT;
++ }
+ else
+ {
+ p->v.expr.value = dwarf_expr_fetch (ctx, 0);
+@@ -859,7 +876,8 @@
+
+ /* Pop off the address/regnum, and reset the location
+ type. */
+- if (ctx->location != DWARF_VALUE_LITERAL)
++ if (ctx->location != DWARF_VALUE_LITERAL
++ && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
+ dwarf_expr_pop (ctx);
+ ctx->location = DWARF_VALUE_MEMORY;
+ }
+--- src/gdb/dwarf2expr.h 2010/01/01 07:31:30 1.20
++++ src/gdb/dwarf2expr.h 2010/05/21 21:01:46 1.21
+@@ -38,7 +38,10 @@
+ DWARF_VALUE_STACK,
+
+ /* The piece is a literal. */
+- DWARF_VALUE_LITERAL
++ DWARF_VALUE_LITERAL,
++
++ /* The piece was optimized out. */
++ DWARF_VALUE_OPTIMIZED_OUT
+ };
+
+ /* The dwarf expression stack. */
+--- src/gdb/dwarf2loc.c 2010/05/21 20:39:50 1.79
++++ src/gdb/dwarf2loc.c 2010/05/21 21:01:46 1.80
+@@ -384,6 +384,16 @@
+ }
+ break;
+
++ case DWARF_VALUE_OPTIMIZED_OUT:
++ /* We just leave the bits empty for now. This is not ideal
++ but gdb currently does not have a nice way to represent
++ optimized-out pieces. */
++ warning (_("bytes %ld-%ld in computed object were optimized out; "
++ "replacing with zeroes"),
++ offset,
++ offset + (long) this_size);
++ break;
++
+ default:
+ internal_error (__FILE__, __LINE__, _("invalid location type"));
+ }
+@@ -609,6 +619,9 @@
+ }
+ break;
+
++ /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
++ it can only be encountered when making a piece. */
++ case DWARF_VALUE_OPTIMIZED_OUT:
+ default:
+ internal_error (__FILE__, __LINE__, _("invalid location type"));
+ }
+--- src/gdb/testsuite/gdb.dwarf2/pieces.S 2010/05/21 20:39:50 1.1
++++ src/gdb/testsuite/gdb.dwarf2/pieces.S 2010/05/21 21:01:46 1.2
+@@ -37,19 +37,19 @@
+ bar:
+ .LFB0:
+ .file 1 "pieces.c"
+- # pieces.c:28
+- .loc 1 28 0
++ # pieces.c:29
++ .loc 1 29 0
+ .LVL0:
+ # basic block 2
+ pushl %ebp
+ .LCFI0:
+ movl %esp, %ebp
+ .LCFI1:
+- # pieces.c:29
+- .loc 1 29 0
+- movl 8(%ebp), %eax
+ # pieces.c:30
+ .loc 1 30 0
++ movl 8(%ebp), %eax
++ # pieces.c:31
++ .loc 1 31 0
+ popl %ebp
+ .LCFI2:
+ ret
+@@ -60,8 +60,8 @@
+ .type f1, @function
+ f1:
+ .LFB1:
+- # pieces.c:34
+- .loc 1 34 0
++ # pieces.c:35
++ .loc 1 35 0
+ .LVL1:
+ # basic block 2
+ pushl %ebp
+@@ -73,36 +73,36 @@
+ .LCFI5:
+ movl %esi, -4(%ebp)
+ .LCFI6:
+- # pieces.c:37
+- .loc 1 37 0
++ # pieces.c:38
++ .loc 1 38 0
+ movl 8(%ebp), %esi
+- # pieces.c:34
+- .loc 1 34 0
++ # pieces.c:35
++ .loc 1 35 0
+ movl %ebx, -8(%ebp)
+ .LCFI7:
+- # pieces.c:36
+- .loc 1 36 0
++ # pieces.c:37
++ .loc 1 37 0
+ movl $4, %ebx
+ .LVL3:
++ # pieces.c:39
++ .loc 1 39 0
++ movl %ebx, (%esp)
+ # pieces.c:38
+ .loc 1 38 0
+- movl %ebx, (%esp)
+- # pieces.c:37
+- .loc 1 37 0
+ addl $7, %esi
+ .LVL4:
+- # pieces.c:38
+- .loc 1 38 0
+- call bar
+ # pieces.c:39
+ .loc 1 39 0
+- movl %esi, (%esp)
+ call bar
+ # pieces.c:40
+ .loc 1 40 0
+- leal (%ebx,%esi), %eax
++ movl %esi, (%esp)
++ call bar
+ # pieces.c:41
+ .loc 1 41 0
++ leal (%ebx,%esi), %eax
++ # pieces.c:42
++ .loc 1 42 0
+ movl -8(%ebp), %ebx
+ .LVL5:
+ movl -4(%ebp), %esi
+@@ -119,8 +119,8 @@
+ .type f2, @function
+ f2:
+ .LFB2:
+- # pieces.c:45
+- .loc 1 45 0
++ # pieces.c:46
++ .loc 1 46 0
+ .LVL7:
+ # basic block 2
+ pushl %ebp
+@@ -132,36 +132,36 @@
+ .LCFI12:
+ movl %esi, -4(%ebp)
+ .LCFI13:
+- # pieces.c:48
+- .loc 1 48 0
++ # pieces.c:49
++ .loc 1 49 0
+ movl 8(%ebp), %esi
+- # pieces.c:45
+- .loc 1 45 0
++ # pieces.c:46
++ .loc 1 46 0
+ movl %ebx, -8(%ebp)
+ .LCFI14:
+- # pieces.c:47
+- .loc 1 47 0
++ # pieces.c:48
++ .loc 1 48 0
+ movl $4, %ebx
+ .LVL9:
++ # pieces.c:50
++ .loc 1 50 0
++ movl %ebx, (%esp)
+ # pieces.c:49
+ .loc 1 49 0
+- movl %ebx, (%esp)
+- # pieces.c:48
+- .loc 1 48 0
+ addl $7, %esi
+ .LVL10:
+- # pieces.c:49
+- .loc 1 49 0
+- call bar
+ # pieces.c:50
+ .loc 1 50 0
+- movl %esi, (%esp)
+ call bar
+ # pieces.c:51
+ .loc 1 51 0
+- leal (%ebx,%esi), %eax
++ movl %esi, (%esp)
++ call bar
+ # pieces.c:52
+ .loc 1 52 0
++ leal (%ebx,%esi), %eax
++ # pieces.c:53
++ .loc 1 53 0
+ movl -8(%ebp), %ebx
+ .LVL11:
+ movl -4(%ebp), %esi
+@@ -178,59 +178,59 @@
+ .type f3, @function
+ f3:
+ .LFB3:
+- # pieces.c:56
+- .loc 1 56 0
++ # pieces.c:57
++ .loc 1 57 0
+ .LVL13:
+ # basic block 2
+ pushl %ebp
+ .LCFI17:
+- # pieces.c:58
+- .loc 1 58 0
++ # pieces.c:59
++ .loc 1 59 0
+ movl $4, %edx
+- # pieces.c:56
+- .loc 1 56 0
++ # pieces.c:57
++ .loc 1 57 0
+ movl %esp, %ebp
+ .LCFI18:
+ .LVL14:
+ subl $12, %esp
+ .LCFI19:
+- # pieces.c:58
+- .loc 1 58 0
++ # pieces.c:59
++ .loc 1 59 0
+ .LVL15:
+- # pieces.c:56
+- .loc 1 56 0
++ # pieces.c:57
++ .loc 1 57 0
+ movl %esi, -4(%ebp)
+ .LCFI20:
+- # pieces.c:60
+- .loc 1 60 0
++ # pieces.c:61
++ .loc 1 61 0
+ movswl %dx, %esi
+- # pieces.c:56
+- .loc 1 56 0
++ # pieces.c:57
++ .loc 1 57 0
+ movl %ebx, -8(%ebp)
+ .LCFI21:
+- # pieces.c:60
+- .loc 1 60 0
++ # pieces.c:61
++ .loc 1 61 0
+ movl %esi, (%esp)
+ call bar
+ .LVL16:
+- # pieces.c:57
+- .loc 1 57 0
++ # pieces.c:58
++ .loc 1 58 0
+ movl 8(%ebp), %edx
+ sall $4, %edx
+- # pieces.c:59
+- .loc 1 59 0
++ # pieces.c:60
++ .loc 1 60 0
+ addl $112, %edx
+ sarw $4, %dx
+- # pieces.c:61
+- .loc 1 61 0
++ # pieces.c:62
++ .loc 1 62 0
+ movswl %dx, %ebx
+ movl %ebx, (%esp)
+ call bar
+- # pieces.c:62
+- .loc 1 62 0
+- leal (%esi,%ebx), %eax
+ # pieces.c:63
+ .loc 1 63 0
++ leal (%esi,%ebx), %eax
++ # pieces.c:64
++ .loc 1 64 0
+ movl -8(%ebp), %ebx
+ movl -4(%ebp), %esi
+ .LVL17:
+@@ -246,8 +246,8 @@
+ .type f4, @function
+ f4:
+ .LFB4:
+- # pieces.c:67
+- .loc 1 67 0
++ # pieces.c:68
++ .loc 1 68 0
+ .LVL18:
+ # basic block 2
+ pushl %ebp
+@@ -262,28 +262,28 @@
+ .LVL19:
+ movl %ebx, -8(%ebp)
+ .LCFI28:
+- # pieces.c:69
+- .loc 1 69 0
+- movl %esi, %ebx
+ # pieces.c:70
+ .loc 1 70 0
+- addl $1, %esi
+- # pieces.c:69
+- .loc 1 69 0
+-.LVL20:
++ movl %esi, %ebx
+ # pieces.c:71
+ .loc 1 71 0
+- movl %ebx, (%esp)
+- call bar
++ addl $1, %esi
++ # pieces.c:70
++ .loc 1 70 0
++.LVL20:
+ # pieces.c:72
+ .loc 1 72 0
+- movl %esi, (%esp)
++ movl %ebx, (%esp)
+ call bar
+ # pieces.c:73
+ .loc 1 73 0
+- leal (%ebx,%esi), %eax
++ movl %esi, (%esp)
++ call bar
+ # pieces.c:74
+ .loc 1 74 0
++ leal (%ebx,%esi), %eax
++ # pieces.c:75
++ .loc 1 75 0
+ movl -8(%ebp), %ebx
+ .LVL21:
+ movl -4(%ebp), %esi
+@@ -300,8 +300,8 @@
+ .type f5, @function
+ f5:
+ .LFB5:
+- # pieces.c:78
+- .loc 1 78 0
++ # pieces.c:79
++ .loc 1 79 0
+ .LVL23:
+ # basic block 2
+ pushl %ebp
+@@ -316,28 +316,28 @@
+ .LVL24:
+ movl %ebx, -8(%ebp)
+ .LCFI35:
+- # pieces.c:80
+- .loc 1 80 0
+- movl %esi, %ebx
+ # pieces.c:81
+ .loc 1 81 0
+- addl $1, %esi
+- # pieces.c:80
+- .loc 1 80 0
+-.LVL25:
++ movl %esi, %ebx
+ # pieces.c:82
+ .loc 1 82 0
+- movl %ebx, (%esp)
+- call bar
++ addl $1, %esi
++ # pieces.c:81
++ .loc 1 81 0
++.LVL25:
+ # pieces.c:83
+ .loc 1 83 0
+- movl %esi, (%esp)
++ movl %ebx, (%esp)
+ call bar
+ # pieces.c:84
+ .loc 1 84 0
+- leal (%ebx,%esi), %eax
++ movl %esi, (%esp)
++ call bar
+ # pieces.c:85
+ .loc 1 85 0
++ leal (%ebx,%esi), %eax
++ # pieces.c:86
++ .loc 1 86 0
+ movl -8(%ebp), %ebx
+ .LVL26:
+ movl -4(%ebp), %esi
+@@ -350,60 +350,118 @@
+ .LFE5:
+ .size f5, .-f5
+ .p2align 4,,15
+-.globl main
+- .type main, @function
+-main:
++.globl f6
++ .type f6, @function
++f6:
+ .LFB6:
+- # pieces.c:89
+- .loc 1 89 0
++ # pieces.c:90
++ .loc 1 90 0
++.LVL28:
+ # basic block 2
+ pushl %ebp
+ .LCFI38:
+ movl %esp, %ebp
+ .LCFI39:
+- pushl %ebx
++ subl $12, %esp
+ .LCFI40:
+- # pieces.c:91
+- .loc 1 91 0
+- movl $7, %ebx
+- # pieces.c:89
+- .loc 1 89 0
+- subl $4, %esp
++ movl %esi, -4(%ebp)
+ .LCFI41:
+- # pieces.c:91
+- .loc 1 91 0
+-.LVL28:
+- # pieces.c:92
+- .loc 1 92 0
+- movl %ebx, (%esp)
+- call f1
++ movl 8(%ebp), %esi
++.LVL29:
++ movl %ebx, -8(%ebp)
++.LCFI42:
+ # pieces.c:93
+ .loc 1 93 0
+- movl %ebx, (%esp)
+- call f2
++ movl %esi, %ebx
+ # pieces.c:94
+ .loc 1 94 0
+- movl %ebx, (%esp)
+- call f3
++ addl $1, %esi
++ # pieces.c:93
++ .loc 1 93 0
++.LVL30:
+ # pieces.c:95
+ .loc 1 95 0
+ movl %ebx, (%esp)
+- call f4
++ call bar
+ # pieces.c:96
+ .loc 1 96 0
+- movl %ebx, (%esp)
+- call f5
++ movl %esi, (%esp)
++ call bar
++ # pieces.c:97
++ .loc 1 97 0
++ leal (%ebx,%esi), %eax
+ # pieces.c:98
+ .loc 1 98 0
++ movl -8(%ebp), %ebx
++.LVL31:
++ movl -4(%ebp), %esi
++.LVL32:
++ movl %ebp, %esp
++.LCFI43:
++ popl %ebp
++.LCFI44:
++ ret
++.LFE6:
++ .size f6, .-f6
++ .p2align 4,,15
++.globl main
++ .type main, @function
++main:
++.LFB7:
++ # pieces.c:102
++ .loc 1 102 0
++ # basic block 2
++ pushl %ebp
++.LCFI45:
++ movl %esp, %ebp
++.LCFI46:
++ pushl %ebx
++.LCFI47:
++ # pieces.c:104
++ .loc 1 104 0
++ movl $7, %ebx
++ # pieces.c:102
++ .loc 1 102 0
++ subl $4, %esp
++.LCFI48:
++ # pieces.c:104
++ .loc 1 104 0
++.LVL33:
++ # pieces.c:105
++ .loc 1 105 0
++ movl %ebx, (%esp)
++ call f1
++ # pieces.c:106
++ .loc 1 106 0
++ movl %ebx, (%esp)
++ call f2
++ # pieces.c:107
++ .loc 1 107 0
++ movl %ebx, (%esp)
++ call f3
++ # pieces.c:108
++ .loc 1 108 0
++ movl %ebx, (%esp)
++ call f4
++ # pieces.c:109
++ .loc 1 109 0
++ movl %ebx, (%esp)
++ call f5
++ # pieces.c:110
++ .loc 1 110 0
++ movl %ebx, (%esp)
++ call f6
++ # pieces.c:112
++ .loc 1 112 0
+ addl $4, %esp
+ xorl %eax, %eax
+ popl %ebx
+-.LCFI42:
+-.LVL29:
++.LCFI49:
++.LVL34:
+ popl %ebp
+-.LCFI43:
++.LCFI50:
+ ret
+-.LFE6:
++.LFE7:
+ .size main, .-main
+ #APP
+ .section .debug_frame,"",@progbits
+@@ -649,20 +707,57 @@
+ .byte 0xd # DW_CFA_def_cfa_register
+ .uleb128 0x5
+ .byte 0x4 # DW_CFA_advance_loc4
+- .long .LCFI40-.LCFI39
++ .long .LCFI41-.LCFI39
++ .byte 0x86 # DW_CFA_offset, column 0x6
++ .uleb128 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI42-.LCFI41
++ .byte 0x83 # DW_CFA_offset, column 0x3
++ .uleb128 0x4
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI43-.LCFI42
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x4
++ .byte 0xc6 # DW_CFA_restore, column 0x6
++ .byte 0xc3 # DW_CFA_restore, column 0x3
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI44-.LCFI43
++ .byte 0xc5 # DW_CFA_restore, column 0x5
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x4
++ .align 4
++.LEFDE12:
++.LSFDE14:
++ .long .LEFDE14-.LASFDE14 # FDE Length
++.LASFDE14:
++ .long .Lframe0 # FDE CIE offset
++ .long .LFB7 # FDE initial location
++ .long .LFE7-.LFB7 # FDE address range
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI45-.LFB7
++ .byte 0xe # DW_CFA_def_cfa_offset
++ .uleb128 0x8
++ .byte 0x85 # DW_CFA_offset, column 0x5
++ .uleb128 0x2
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI46-.LCFI45
++ .byte 0xd # DW_CFA_def_cfa_register
++ .uleb128 0x5
++ .byte 0x4 # DW_CFA_advance_loc4
++ .long .LCFI47-.LCFI46
+ .byte 0x83 # DW_CFA_offset, column 0x3
+ .uleb128 0x3
+ .byte 0x4 # DW_CFA_advance_loc4
+- .long .LCFI42-.LCFI40
++ .long .LCFI49-.LCFI47
+ .byte 0xc3 # DW_CFA_restore, column 0x3
+ .byte 0x4 # DW_CFA_advance_loc4
+- .long .LCFI43-.LCFI42
++ .long .LCFI50-.LCFI49
+ .byte 0xc5 # DW_CFA_restore, column 0x5
+ .byte 0xc # DW_CFA_def_cfa
+ .uleb128 0x4
+ .uleb128 0x4
+ .align 4
+-.LEFDE12:
++.LEFDE14:
+ #NO_APP
+ .text
+ .Letext0:
+@@ -1130,6 +1225,11 @@
+ .byte 0x75 # DW_OP_breg5
+ .sleb128 8
+ .long .LCFI43-.Ltext0 # Location list begin address (*.LLST11)
++ .long .LCFI44-.Ltext0 # Location list end address (*.LLST11)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI44-.Ltext0 # Location list begin address (*.LLST11)
+ .long .LFE6-.Ltext0 # Location list end address (*.LLST11)
+ .value 0x2 # Location expression size
+ .byte 0x74 # DW_OP_breg4
+@@ -1137,14 +1237,74 @@
+ .long 0 # Location list terminator begin (*.LLST11)
+ .long 0 # Location list terminator end (*.LLST11)
+ .LLST12:
+- .long .LVL28-.Ltext0 # Location list begin address (*.LLST12)
+- .long .LVL29-.Ltext0 # Location list end address (*.LLST12)
+- .value 0x1 # Location expression size
++ .long .LVL29-.Ltext0 # Location list begin address (*.LLST12)
++ .long .LVL30-.Ltext0 # Location list end address (*.LLST12)
++ .value 0xa # Location expression size
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL30-.Ltext0 # Location list begin address (*.LLST12)
++ .long .LVL31-.Ltext0 # Location list end address (*.LLST12)
++ .value 0x8 # Location expression size
+ .byte 0x53 # DW_OP_reg3
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x56 # DW_OP_reg6
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .long .LVL31-.Ltext0 # Location list begin address (*.LLST12)
++ .long .LVL32-.Ltext0 # Location list end address (*.LLST12)
++ .value 0x7 # Location expression size
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x56 # DW_OP_reg6
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x4
+ .long 0 # Location list terminator begin (*.LLST12)
+ .long 0 # Location list terminator end (*.LLST12)
++.LLST13:
++ .long .LFB7-.Ltext0 # Location list begin address (*.LLST13)
++ .long .LCFI45-.Ltext0 # Location list end address (*.LLST13)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long .LCFI45-.Ltext0 # Location list begin address (*.LLST13)
++ .long .LCFI46-.Ltext0 # Location list end address (*.LLST13)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 8
++ .long .LCFI46-.Ltext0 # Location list begin address (*.LLST13)
++ .long .LCFI50-.Ltext0 # Location list end address (*.LLST13)
++ .value 0x2 # Location expression size
++ .byte 0x75 # DW_OP_breg5
++ .sleb128 8
++ .long .LCFI50-.Ltext0 # Location list begin address (*.LLST13)
++ .long .LFE7-.Ltext0 # Location list end address (*.LLST13)
++ .value 0x2 # Location expression size
++ .byte 0x74 # DW_OP_breg4
++ .sleb128 4
++ .long 0 # Location list terminator begin (*.LLST13)
++ .long 0 # Location list terminator end (*.LLST13)
++.LLST14:
++ .long .LVL33-.Ltext0 # Location list begin address (*.LLST14)
++ .long .LVL34-.Ltext0 # Location list end address (*.LLST14)
++ .value 0x1 # Location expression size
++ .byte 0x53 # DW_OP_reg3
++ .long 0 # Location list terminator begin (*.LLST14)
++ .long 0 # Location list terminator end (*.LLST14)
+ .section .debug_info
+- .long 0x1e3 # Length of Compilation Unit Info
++ .long 0x252 # Length of Compilation Unit Info
+ .value 0x2 # DWARF version number
+ .long .Ldebug_abbrev0 # Offset Into Abbrev. Section
+ .byte 0x4 # Pointer Size (in bytes)
+@@ -1212,182 +1372,245 @@
+ .byte 0x23 # DW_OP_plus_uconst
+ .uleb128 0
+ .byte 0 # end of children of DIE 0x4f
+- .uleb128 0x6 # (DIE (0x78) DW_TAG_subprogram)
++ .uleb128 0x2 # (DIE (0x78) DW_TAG_structure_type)
++ .ascii "C\0" # DW_AT_name
++ .byte 0xc # DW_AT_byte_size
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x19 # DW_AT_decl_line
++ .long 0xa7 # DW_AT_sibling
++ .uleb128 0x3 # (DIE (0x82) DW_TAG_member)
++ .ascii "i\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x19 # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x2 # DW_AT_data_member_location
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0
++ .uleb128 0x3 # (DIE (0x8e) DW_TAG_member)
++ .ascii "j\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x19 # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x2 # DW_AT_data_member_location
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0x4
++ .uleb128 0x3 # (DIE (0x9a) DW_TAG_member)
++ .ascii "q\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x19 # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x2 # DW_AT_data_member_location
++ .byte 0x23 # DW_OP_plus_uconst
++ .uleb128 0x8
++ .byte 0 # end of children of DIE 0x78
++ .uleb128 0x6 # (DIE (0xa7) DW_TAG_subprogram)
+ .byte 0x1 # DW_AT_external
+ .ascii "bar\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x1b # DW_AT_decl_line
++ .byte 0x1c # DW_AT_decl_line
+ .byte 0x1 # DW_AT_prototyped
+ .long .LFB0 # DW_AT_low_pc
+ .long .LFE0 # DW_AT_high_pc
+ .long .LLST0 # DW_AT_frame_base
+- .long 0x9e # DW_AT_sibling
+- .uleb128 0x7 # (DIE (0x91) DW_TAG_formal_parameter)
++ .long 0xcd # DW_AT_sibling
++ .uleb128 0x7 # (DIE (0xc0) DW_TAG_formal_parameter)
+ .ascii "x\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x1b # DW_AT_decl_line
++ .byte 0x1c # DW_AT_decl_line
+ .long 0x48 # DW_AT_type
+ .byte 0x2 # DW_AT_location
+ .byte 0x91 # DW_OP_fbreg
+ .sleb128 0
+- .byte 0 # end of children of DIE 0x78
+- .uleb128 0x8 # (DIE (0x9e) DW_TAG_subprogram)
++ .byte 0 # end of children of DIE 0xa7
++ .uleb128 0x8 # (DIE (0xcd) DW_TAG_subprogram)
+ .byte 0x1 # DW_AT_external
+ .ascii "f1\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x21 # DW_AT_decl_line
++ .byte 0x22 # DW_AT_decl_line
+ .byte 0x1 # DW_AT_prototyped
+ .long 0x48 # DW_AT_type
+ .long .LFB1 # DW_AT_low_pc
+ .long .LFE1 # DW_AT_high_pc
+ .long .LLST1 # DW_AT_frame_base
+- .long 0xd4 # DW_AT_sibling
+- .uleb128 0x7 # (DIE (0xba) DW_TAG_formal_parameter)
++ .long 0x103 # DW_AT_sibling
++ .uleb128 0x7 # (DIE (0xe9) DW_TAG_formal_parameter)
+ .ascii "k\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x21 # DW_AT_decl_line
++ .byte 0x22 # DW_AT_decl_line
+ .long 0x48 # DW_AT_type
+ .byte 0x2 # DW_AT_location
+ .byte 0x91 # DW_OP_fbreg
+ .sleb128 0
+- .uleb128 0x9 # (DIE (0xc6) DW_TAG_variable)
++ .uleb128 0x9 # (DIE (0xf5) DW_TAG_variable)
+ .ascii "a\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x23 # DW_AT_decl_line
++ .byte 0x24 # DW_AT_decl_line
+ .long 0x25 # DW_AT_type
+ .long .LLST2 # DW_AT_location
+- .byte 0 # end of children of DIE 0x9e
+- .uleb128 0x8 # (DIE (0xd4) DW_TAG_subprogram)
++ .byte 0 # end of children of DIE 0xcd
++ .uleb128 0x8 # (DIE (0x103) DW_TAG_subprogram)
+ .byte 0x1 # DW_AT_external
+ .ascii "f2\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x2c # DW_AT_decl_line
++ .byte 0x2d # DW_AT_decl_line
+ .byte 0x1 # DW_AT_prototyped
+ .long 0x48 # DW_AT_type
+ .long .LFB2 # DW_AT_low_pc
+ .long .LFE2 # DW_AT_high_pc
+ .long .LLST3 # DW_AT_frame_base
+- .long 0x10a # DW_AT_sibling
+- .uleb128 0x7 # (DIE (0xf0) DW_TAG_formal_parameter)
++ .long 0x139 # DW_AT_sibling
++ .uleb128 0x7 # (DIE (0x11f) DW_TAG_formal_parameter)
+ .ascii "k\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x2c # DW_AT_decl_line
++ .byte 0x2d # DW_AT_decl_line
+ .long 0x48 # DW_AT_type
+ .byte 0x2 # DW_AT_location
+ .byte 0x91 # DW_OP_fbreg
+ .sleb128 0
+- .uleb128 0x9 # (DIE (0xfc) DW_TAG_variable)
++ .uleb128 0x9 # (DIE (0x12b) DW_TAG_variable)
+ .ascii "a\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x2e # DW_AT_decl_line
+- .long 0x10a # DW_AT_type
++ .byte 0x2f # DW_AT_decl_line
++ .long 0x139 # DW_AT_type
+ .long .LLST4 # DW_AT_location
+- .byte 0 # end of children of DIE 0xd4
+- .uleb128 0xa # (DIE (0x10a) DW_TAG_array_type)
++ .byte 0 # end of children of DIE 0x103
++ .uleb128 0xa # (DIE (0x139) DW_TAG_array_type)
+ .long 0x48 # DW_AT_type
+- .long 0x11a # DW_AT_sibling
+- .uleb128 0xb # (DIE (0x113) DW_TAG_subrange_type)
+- .long 0x11a # DW_AT_type
++ .long 0x149 # DW_AT_sibling
++ .uleb128 0xb # (DIE (0x142) DW_TAG_subrange_type)
++ .long 0x149 # DW_AT_type
+ .byte 0x1 # DW_AT_upper_bound
+- .byte 0 # end of children of DIE 0x10a
+- .uleb128 0xc # (DIE (0x11a) DW_TAG_base_type)
++ .byte 0 # end of children of DIE 0x139
++ .uleb128 0xc # (DIE (0x149) DW_TAG_base_type)
+ .byte 0x4 # DW_AT_byte_size
+ .byte 0x7 # DW_AT_encoding
+- .uleb128 0x8 # (DIE (0x11d) DW_TAG_subprogram)
++ .uleb128 0x8 # (DIE (0x14c) DW_TAG_subprogram)
+ .byte 0x1 # DW_AT_external
+ .ascii "f3\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x37 # DW_AT_decl_line
++ .byte 0x38 # DW_AT_decl_line
+ .byte 0x1 # DW_AT_prototyped
+ .long 0x48 # DW_AT_type
+ .long .LFB3 # DW_AT_low_pc
+ .long .LFE3 # DW_AT_high_pc
+ .long .LLST5 # DW_AT_frame_base
+- .long 0x153 # DW_AT_sibling
+- .uleb128 0x7 # (DIE (0x139) DW_TAG_formal_parameter)
++ .long 0x182 # DW_AT_sibling
++ .uleb128 0x7 # (DIE (0x168) DW_TAG_formal_parameter)
+ .ascii "k\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x37 # DW_AT_decl_line
++ .byte 0x38 # DW_AT_decl_line
+ .long 0x48 # DW_AT_type
+ .byte 0x2 # DW_AT_location
+ .byte 0x91 # DW_OP_fbreg
+ .sleb128 0
+- .uleb128 0x9 # (DIE (0x145) DW_TAG_variable)
++ .uleb128 0x9 # (DIE (0x174) DW_TAG_variable)
+ .ascii "a\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x39 # DW_AT_decl_line
++ .byte 0x3a # DW_AT_decl_line
+ .long 0x4f # DW_AT_type
+ .long .LLST6 # DW_AT_location
+- .byte 0 # end of children of DIE 0x11d
+- .uleb128 0x8 # (DIE (0x153) DW_TAG_subprogram)
++ .byte 0 # end of children of DIE 0x14c
++ .uleb128 0x8 # (DIE (0x182) DW_TAG_subprogram)
+ .byte 0x1 # DW_AT_external
+ .ascii "f4\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x42 # DW_AT_decl_line
++ .byte 0x43 # DW_AT_decl_line
+ .byte 0x1 # DW_AT_prototyped
+ .long 0x48 # DW_AT_type
+ .long .LFB4 # DW_AT_low_pc
+ .long .LFE4 # DW_AT_high_pc
+ .long .LLST7 # DW_AT_frame_base
+- .long 0x189 # DW_AT_sibling
+- .uleb128 0x7 # (DIE (0x16f) DW_TAG_formal_parameter)
++ .long 0x1b8 # DW_AT_sibling
++ .uleb128 0x7 # (DIE (0x19e) DW_TAG_formal_parameter)
+ .ascii "k\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x42 # DW_AT_decl_line
++ .byte 0x43 # DW_AT_decl_line
+ .long 0x48 # DW_AT_type
+ .byte 0x2 # DW_AT_location
+ .byte 0x91 # DW_OP_fbreg
+ .sleb128 0
+- .uleb128 0x9 # (DIE (0x17b) DW_TAG_variable)
++ .uleb128 0x9 # (DIE (0x1aa) DW_TAG_variable)
+ .ascii "a\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x44 # DW_AT_decl_line
+- .long 0x10a # DW_AT_type
++ .byte 0x45 # DW_AT_decl_line
++ .long 0x139 # DW_AT_type
+ .long .LLST8 # DW_AT_location
+- .byte 0 # end of children of DIE 0x153
+- .uleb128 0x8 # (DIE (0x189) DW_TAG_subprogram)
++ .byte 0 # end of children of DIE 0x182
++ .uleb128 0x8 # (DIE (0x1b8) DW_TAG_subprogram)
+ .byte 0x1 # DW_AT_external
+ .ascii "f5\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x4d # DW_AT_decl_line
++ .byte 0x4e # DW_AT_decl_line
+ .byte 0x1 # DW_AT_prototyped
+ .long 0x48 # DW_AT_type
+ .long .LFB5 # DW_AT_low_pc
+ .long .LFE5 # DW_AT_high_pc
+ .long .LLST9 # DW_AT_frame_base
+- .long 0x1bf # DW_AT_sibling
+- .uleb128 0x7 # (DIE (0x1a5) DW_TAG_formal_parameter)
++ .long 0x1ee # DW_AT_sibling
++ .uleb128 0x7 # (DIE (0x1d4) DW_TAG_formal_parameter)
+ .ascii "k\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x4d # DW_AT_decl_line
++ .byte 0x4e # DW_AT_decl_line
+ .long 0x48 # DW_AT_type
+ .byte 0x2 # DW_AT_location
+ .byte 0x91 # DW_OP_fbreg
+ .sleb128 0
+- .uleb128 0x9 # (DIE (0x1b1) DW_TAG_variable)
++ .uleb128 0x9 # (DIE (0x1e0) DW_TAG_variable)
+ .ascii "a\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x4f # DW_AT_decl_line
++ .byte 0x50 # DW_AT_decl_line
+ .long 0x25 # DW_AT_type
+ .long .LLST10 # DW_AT_location
+- .byte 0 # end of children of DIE 0x189
+- .uleb128 0xd # (DIE (0x1bf) DW_TAG_subprogram)
++ .byte 0 # end of children of DIE 0x1b8
++ .uleb128 0x8 # (DIE (0x1ee) DW_TAG_subprogram)
+ .byte 0x1 # DW_AT_external
+- .long .LASF0 # DW_AT_name: "main"
++ .ascii "f6\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x58 # DW_AT_decl_line
++ .byte 0x59 # DW_AT_decl_line
+ .byte 0x1 # DW_AT_prototyped
+ .long 0x48 # DW_AT_type
+ .long .LFB6 # DW_AT_low_pc
+ .long .LFE6 # DW_AT_high_pc
+ .long .LLST11 # DW_AT_frame_base
+- .uleb128 0x9 # (DIE (0x1d8) DW_TAG_variable)
++ .long 0x22e # DW_AT_sibling
++ .uleb128 0x7 # (DIE (0x20a) DW_TAG_formal_parameter)
+ .ascii "k\0" # DW_AT_name
+ .byte 0x1 # DW_AT_decl_file (pieces.c)
+- .byte 0x5a # DW_AT_decl_line
++ .byte 0x59 # DW_AT_decl_line
+ .long 0x48 # DW_AT_type
++ .byte 0x2 # DW_AT_location
++ .byte 0x91 # DW_OP_fbreg
++ .sleb128 0
++ .uleb128 0xd # (DIE (0x216) DW_TAG_variable)
++ .ascii "z\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x5b # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .byte 0x17 # DW_AT_const_value
++ .uleb128 0x9 # (DIE (0x220) DW_TAG_variable)
++ .ascii "a\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x5c # DW_AT_decl_line
++ .long 0x78 # DW_AT_type
+ .long .LLST12 # DW_AT_location
+- .byte 0 # end of children of DIE 0x1bf
++ .byte 0 # end of children of DIE 0x1ee
++ .uleb128 0xe # (DIE (0x22e) DW_TAG_subprogram)
++ .byte 0x1 # DW_AT_external
++ .long .LASF0 # DW_AT_name: "main"
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x65 # DW_AT_decl_line
++ .byte 0x1 # DW_AT_prototyped
++ .long 0x48 # DW_AT_type
++ .long .LFB7 # DW_AT_low_pc
++ .long .LFE7 # DW_AT_high_pc
++ .long .LLST13 # DW_AT_frame_base
++ .uleb128 0x9 # (DIE (0x247) DW_TAG_variable)
++ .ascii "k\0" # DW_AT_name
++ .byte 0x1 # DW_AT_decl_file (pieces.c)
++ .byte 0x67 # DW_AT_decl_line
++ .long 0x48 # DW_AT_type
++ .long .LLST14 # DW_AT_location
++ .byte 0 # end of children of DIE 0x22e
+ .byte 0 # end of children of DIE 0xb
+ .section .debug_abbrev
+ .uleb128 0x1 # (abbrev code)
+@@ -1577,6 +1800,21 @@
+ .byte 0
+ .byte 0
+ .uleb128 0xd # (abbrev code)
++ .uleb128 0x34 # (TAG: DW_TAG_variable)
++ .byte 0 # DW_children_no
++ .uleb128 0x3 # (DW_AT_name)
++ .uleb128 0x8 # (DW_FORM_string)
++ .uleb128 0x3a # (DW_AT_decl_file)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x3b # (DW_AT_decl_line)
++ .uleb128 0xb # (DW_FORM_data1)
++ .uleb128 0x49 # (DW_AT_type)
++ .uleb128 0x13 # (DW_FORM_ref4)
++ .uleb128 0x1c # (DW_AT_const_value)
++ .uleb128 0xb # (DW_FORM_data1)
++ .byte 0
++ .byte 0
++ .uleb128 0xe # (abbrev code)
+ .uleb128 0x2e # (TAG: DW_TAG_subprogram)
+ .byte 0x1 # DW_children_yes
+ .uleb128 0x3f # (DW_AT_external)
+@@ -1601,34 +1839,38 @@
+ .byte 0
+ .byte 0
+ .section .debug_pubnames,"",@progbits
+- .long 0x42 # Length of Public Names Info
++ .long 0x49 # Length of Public Names Info
+ .value 0x2 # DWARF Version
+ .long .Ldebug_info0 # Offset of Compilation Unit Info
+- .long 0x1e7 # Compilation Unit Length
+- .long 0x78 # DIE offset
++ .long 0x256 # Compilation Unit Length
++ .long 0xa7 # DIE offset
+ .ascii "bar\0" # external name
+- .long 0x9e # DIE offset
++ .long 0xcd # DIE offset
+ .ascii "f1\0" # external name
+- .long 0xd4 # DIE offset
++ .long 0x103 # DIE offset
+ .ascii "f2\0" # external name
+- .long 0x11d # DIE offset
++ .long 0x14c # DIE offset
+ .ascii "f3\0" # external name
+- .long 0x153 # DIE offset
++ .long 0x182 # DIE offset
+ .ascii "f4\0" # external name
+- .long 0x189 # DIE offset
++ .long 0x1b8 # DIE offset
+ .ascii "f5\0" # external name
+- .long 0x1bf # DIE offset
++ .long 0x1ee # DIE offset
++ .ascii "f6\0" # external name
++ .long 0x22e # DIE offset
+ .ascii "main\0" # external name
+ .long 0
+ .section .debug_pubtypes,"",@progbits
+- .long 0x1a # Length of Public Type Names Info
++ .long 0x20 # Length of Public Type Names Info
+ .value 0x2 # DWARF Version
+ .long .Ldebug_info0 # Offset of Compilation Unit Info
+- .long 0x1e7 # Compilation Unit Length
++ .long 0x256 # Compilation Unit Length
+ .long 0x25 # DIE offset
+ .ascii "A\0" # external name
+ .long 0x4f # DIE offset
+ .ascii "B\0" # external name
++ .long 0x78 # DIE offset
++ .ascii "C\0" # external name
+ .long 0
+ .section .debug_aranges,"",@progbits
+ .long 0x1c # Length of Address Ranges Info
+--- src/gdb/testsuite/gdb.dwarf2/pieces.c 2010/05/21 20:39:50 1.1
++++ src/gdb/testsuite/gdb.dwarf2/pieces.c 2010/05/21 21:01:46 1.2
+@@ -22,6 +22,7 @@
+
+ struct A { int i; int j; };
+ struct B { int : 4; int i : 12; int j : 12; int : 4; };
++struct C { int i; int j; int q; };
+
+ __attribute__((noinline)) void
+ bar (int x)
+@@ -84,6 +85,18 @@
+ return a.i + a.j; /* f5 breakpoint */
+ }
+
++__attribute__((noinline)) int
++f6 (int k)
++{
++ int z = 23;
++ struct C a = { k, k, z};
++ asm ("" : "+r" (a.i));
++ a.j++;
++ bar (a.i);
++ bar (a.j);
++ return a.i + a.j; /* f6 breakpoint */
++}
++
+ int
+ main (void)
+ {
+@@ -94,5 +107,6 @@
+ f3 (k);
+ f4 (k);
+ f5 (k);
++ f6 (k);
+ return 0;
+ }
+--- src/gdb/testsuite/gdb.dwarf2/pieces.exp 2010/05/21 21:00:27 1.2
++++ src/gdb/testsuite/gdb.dwarf2/pieces.exp 2010/05/21 21:01:46 1.3
+@@ -67,5 +67,28 @@
+ gdb_test "print a\[1\]" " = 14" "print a\[1\] in pieces:f2"
+ }
+
++# Function f6 tests for an empty DW_OP_piece.
++proc pieces_test_f6 {} {
++ global csrcfile
++ set line [gdb_get_line_number "f6 breakpoint" $csrcfile]
++ gdb_test "break pieces.c:$line" "Breakpoint 4.*" \
++ "set f6 breakpoint for pieces"
++ gdb_continue_to_breakpoint "continue to f6 breakpoint for pieces"
++ gdb_test "print a" \
++ "warning: bytes .* in computed object were.* = {i = 7, j = 8, q = 0}" \
++ "print a with optimized out piece"
++ # Note: no warning for this case.
++ gdb_test_multiple "print a.i" \
++ "print a.i with optimized out piece" {
++ -re "warning: some bits in computed object" {
++ fail "print a.i with optimized out piece"
++ }
++ -re " = 7" {
++ pass "print a.i with optimized out piece"
++ }
++ }
++}
++
+ pieces_test_f1
+ pieces_test_f2
++pieces_test_f6
diff --git a/gdb-bz589467-pieces4of4.patch b/gdb-bz589467-pieces4of4.patch
new file mode 100644
index 0000000..42ffb41
--- /dev/null
+++ b/gdb-bz589467-pieces4of4.patch
@@ -0,0 +1,820 @@
+http://sourceware.org/ml/gdb-cvs/2010-05/msg00191.html
+
+### src/gdb/ChangeLog 2010/05/21 21:01:46 1.11832
+### src/gdb/ChangeLog 2010/05/21 21:13:10 1.11833
+## -1,5 +1,20 @@
+ 2010-05-21 Tom Tromey
+
++ * dwarf2loc.c (extract_bits_primitive): New function.
++ (extract_bits): Likewise.
++ (insert_bits): Likewise.
++ (copy_bitwise): Likewise.
++ (read_pieced_value): Do all operations in bits.
++ (write_pieced_value): Likewise.
++ * dwarf2expr.h (struct dwarf_expr_piece) : New field.
++ * dwarf2expr.c (add_piece): New arguments bit_piece, offset.
++ Always use xrealloc to resize piece array.
++ (execute_stack_op) : Handle DW_OP_bit_piece.
++ : Update.
++ : New case.
++
+### src/gdb/testsuite/ChangeLog 2010/05/21 21:01:46 1.2275
+### src/gdb/testsuite/ChangeLog 2010/05/21 21:13:13 1.2276
+## -1,5 +1,12 @@
+ 2010-05-21 Tom Tromey
+
++ * gdb.dwarf2/pieces.exp (pieces_test_f3): New proc.
++ Call it.
++ * gdb.dwarf2/pieces.S: Update.
++ * gdb.dwarf2/pieces.c (struct B): Remove initial field.
++
+--- src/gdb/dwarf2expr.c 2010/05/21 21:01:46 1.43
++++ src/gdb/dwarf2expr.c 2010/05/21 21:13:10 1.44
+@@ -153,23 +153,21 @@
+
+ /* Add a new piece to CTX's piece list. */
+ static void
+-add_piece (struct dwarf_expr_context *ctx, ULONGEST size)
++add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset)
+ {
+ struct dwarf_expr_piece *p;
+
+ ctx->num_pieces++;
+
+- if (ctx->pieces)
+- ctx->pieces = xrealloc (ctx->pieces,
+- (ctx->num_pieces
+- * sizeof (struct dwarf_expr_piece)));
+- else
+- ctx->pieces = xmalloc (ctx->num_pieces
+- * sizeof (struct dwarf_expr_piece));
++ ctx->pieces = xrealloc (ctx->pieces,
++ (ctx->num_pieces
++ * sizeof (struct dwarf_expr_piece)));
+
+ p = &ctx->pieces[ctx->num_pieces - 1];
+ p->location = ctx->location;
+ p->size = size;
++ p->offset = offset;
++
+ if (p->location == DWARF_VALUE_LITERAL)
+ {
+ p->v.literal.data = ctx->data;
+@@ -499,9 +497,11 @@
+ case DW_OP_reg31:
+ if (op_ptr != op_end
+ && *op_ptr != DW_OP_piece
++ && *op_ptr != DW_OP_bit_piece
+ && *op_ptr != DW_OP_GNU_uninit)
+ error (_("DWARF-2 expression error: DW_OP_reg operations must be "
+- "used either alone or in conjuction with DW_OP_piece."));
++ "used either alone or in conjuction with DW_OP_piece "
++ "or DW_OP_bit_piece."));
+
+ result = op - DW_OP_reg0;
+ ctx->location = DWARF_VALUE_REGISTER;
+@@ -872,7 +872,7 @@
+
+ /* Record the piece. */
+ op_ptr = read_uleb128 (op_ptr, op_end, &size);
+- add_piece (ctx, size);
++ add_piece (ctx, 8 * size, 0);
+
+ /* Pop off the address/regnum, and reset the location
+ type. */
+@@ -883,6 +883,24 @@
+ }
+ goto no_push;
+
++ case DW_OP_bit_piece:
++ {
++ ULONGEST size, offset;
++
++ /* Record the piece. */
++ op_ptr = read_uleb128 (op_ptr, op_end, &size);
++ op_ptr = read_uleb128 (op_ptr, op_end, &offset);
++ add_piece (ctx, size, offset);
++
++ /* Pop off the address/regnum, and reset the location
++ type. */
++ if (ctx->location != DWARF_VALUE_LITERAL
++ && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
++ dwarf_expr_pop (ctx);
++ ctx->location = DWARF_VALUE_MEMORY;
++ }
++ goto no_push;
++
+ case DW_OP_GNU_uninit:
+ if (op_ptr != op_end)
+ error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
+--- src/gdb/dwarf2expr.h 2010/05/21 21:01:46 1.21
++++ src/gdb/dwarf2expr.h 2010/05/21 21:13:11 1.22
+@@ -155,7 +155,7 @@
+ };
+
+
+-/* A piece of an object, as recorded by DW_OP_piece. */
++/* A piece of an object, as recorded by DW_OP_piece or DW_OP_bit_piece. */
+ struct dwarf_expr_piece
+ {
+ enum dwarf_value_location location;
+@@ -181,8 +181,10 @@
+ } literal;
+ } v;
+
+- /* The length of the piece, in bytes. */
++ /* The length of the piece, in bits. */
+ ULONGEST size;
++ /* The piece offset, in bits. */
++ ULONGEST offset;
+ };
+
+ struct dwarf_expr_context *new_dwarf_expr_context (void);
+--- src/gdb/dwarf2loc.c 2010/05/21 21:01:46 1.80
++++ src/gdb/dwarf2loc.c 2010/05/21 21:13:11 1.81
+@@ -259,52 +259,245 @@
+ return c;
+ }
+
++/* The lowest-level function to extract bits from a byte buffer.
++ SOURCE is the buffer. It is updated if we read to the end of a
++ byte.
++ SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
++ updated to reflect the number of bits actually read.
++ NBITS is the number of bits we want to read. It is updated to
++ reflect the number of bits actually read. This function may read
++ fewer bits.
++ BITS_BIG_ENDIAN is taken directly from gdbarch.
++ This function returns the extracted bits. */
++
++static unsigned int
++extract_bits_primitive (const gdb_byte **source,
++ unsigned int *source_offset_bits,
++ int *nbits, int bits_big_endian)
++{
++ unsigned int avail, mask, datum;
++
++ gdb_assert (*source_offset_bits < 8);
++
++ avail = 8 - *source_offset_bits;
++ if (avail > *nbits)
++ avail = *nbits;
++
++ mask = (1 << avail) - 1;
++ datum = **source;
++ if (bits_big_endian)
++ datum >>= 8 - (*source_offset_bits + *nbits);
++ else
++ datum >>= *source_offset_bits;
++ datum &= mask;
++
++ *nbits -= avail;
++ *source_offset_bits += avail;
++ if (*source_offset_bits >= 8)
++ {
++ *source_offset_bits -= 8;
++ ++*source;
++ }
++
++ return datum;
++}
++
++/* Extract some bits from a source buffer and move forward in the
++ buffer.
++
++ SOURCE is the source buffer. It is updated as bytes are read.
++ SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
++ bits are read.
++ NBITS is the number of bits to read.
++ BITS_BIG_ENDIAN is taken directly from gdbarch.
++
++ This function returns the bits that were read. */
++
++static unsigned int
++extract_bits (const gdb_byte **source, unsigned int *source_offset_bits,
++ int nbits, int bits_big_endian)
++{
++ unsigned int datum;
++
++ gdb_assert (nbits > 0 && nbits <= 8);
++
++ datum = extract_bits_primitive (source, source_offset_bits, &nbits,
++ bits_big_endian);
++ if (nbits > 0)
++ {
++ unsigned int more;
++
++ more = extract_bits_primitive (source, source_offset_bits, &nbits,
++ bits_big_endian);
++ if (bits_big_endian)
++ datum <<= nbits;
++ else
++ more <<= nbits;
++ datum |= more;
++ }
++
++ return datum;
++}
++
++/* Write some bits into a buffer and move forward in the buffer.
++
++ DATUM is the bits to write. The low-order bits of DATUM are used.
++ DEST is the destination buffer. It is updated as bytes are
++ written.
++ DEST_OFFSET_BITS is the bit offset in DEST at which writing is
++ done.
++ NBITS is the number of valid bits in DATUM.
++ BITS_BIG_ENDIAN is taken directly from gdbarch. */
++
++static void
++insert_bits (unsigned int datum,
++ gdb_byte *dest, unsigned int dest_offset_bits,
++ int nbits, int bits_big_endian)
++{
++ unsigned int mask;
++
++ gdb_assert (dest_offset_bits >= 0 && dest_offset_bits + nbits <= 8);
++
++ mask = (1 << nbits) - 1;
++ if (bits_big_endian)
++ {
++ datum <<= 8 - (dest_offset_bits + nbits);
++ mask <<= 8 - (dest_offset_bits + nbits);
++ }
++ else
++ {
++ datum <<= dest_offset_bits;
++ mask <<= dest_offset_bits;
++ }
++
++ gdb_assert ((datum & ~mask) == 0);
++
++ *dest = (*dest & ~mask) | datum;
++}
++
++/* Copy bits from a source to a destination.
++
++ DEST is where the bits should be written.
++ DEST_OFFSET_BITS is the bit offset into DEST.
++ SOURCE is the source of bits.
++ SOURCE_OFFSET_BITS is the bit offset into SOURCE.
++ BIT_COUNT is the number of bits to copy.
++ BITS_BIG_ENDIAN is taken directly from gdbarch. */
++
++static void
++copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
++ const gdb_byte *source, unsigned int source_offset_bits,
++ unsigned int bit_count,
++ int bits_big_endian)
++{
++ unsigned int dest_avail;
++ int datum;
++
++ /* Reduce everything to byte-size pieces. */
++ dest += dest_offset_bits / 8;
++ dest_offset_bits %= 8;
++ source += source_offset_bits / 8;
++ source_offset_bits %= 8;
++
++ dest_avail = 8 - dest_offset_bits % 8;
++
++ /* See if we can fill the first destination byte. */
++ if (dest_avail < bit_count)
++ {
++ datum = extract_bits (&source, &source_offset_bits, dest_avail,
++ bits_big_endian);
++ insert_bits (datum, dest, dest_offset_bits, dest_avail, bits_big_endian);
++ ++dest;
++ dest_offset_bits = 0;
++ bit_count -= dest_avail;
++ }
++
++ /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
++ than 8 bits remaining. */
++ gdb_assert (dest_offset_bits % 8 == 0 || bit_count < 8);
++ for (; bit_count >= 8; bit_count -= 8)
++ {
++ datum = extract_bits (&source, &source_offset_bits, 8, bits_big_endian);
++ *dest++ = (gdb_byte) datum;
++ }
++
++ /* Finally, we may have a few leftover bits. */
++ gdb_assert (bit_count <= 8 - dest_offset_bits % 8);
++ if (bit_count > 0)
++ {
++ datum = extract_bits (&source, &source_offset_bits, bit_count,
++ bits_big_endian);
++ insert_bits (datum, dest, dest_offset_bits, bit_count, bits_big_endian);
++ }
++}
++
+ static void
+ read_pieced_value (struct value *v)
+ {
+ int i;
+ long offset = 0;
+- ULONGEST bytes_to_skip;
++ ULONGEST bits_to_skip;
+ gdb_byte *contents;
+ struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
+ struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
+ size_t type_len;
++ size_t buffer_size = 0;
++ char *buffer = NULL;
++ struct cleanup *cleanup;
++ int bits_big_endian
++ = gdbarch_bits_big_endian (get_type_arch (value_type (v)));
+
+ if (value_type (v) != value_enclosing_type (v))
+ internal_error (__FILE__, __LINE__,
+ _("Should not be able to create a lazy value with "
+ "an enclosing type"));
+
++ cleanup = make_cleanup (free_current_contents, &buffer);
++
+ contents = value_contents_raw (v);
+- bytes_to_skip = value_offset (v);
+- type_len = TYPE_LENGTH (value_type (v));
++ bits_to_skip = 8 * value_offset (v);
++ type_len = 8 * TYPE_LENGTH (value_type (v));
++
+ for (i = 0; i < c->n_pieces && offset < type_len; i++)
+ {
+ struct dwarf_expr_piece *p = &c->pieces[i];
+- size_t this_size;
+- long dest_offset, source_offset;
+-
+- if (bytes_to_skip > 0 && bytes_to_skip >= p->size)
++ size_t this_size, this_size_bits;
++ long dest_offset_bits, source_offset_bits, source_offset;
++ gdb_byte *intermediate_buffer;
++
++ /* Compute size, source, and destination offsets for copying, in
++ bits. */
++ this_size_bits = p->size;
++ if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
+ {
+- bytes_to_skip -= p->size;
++ bits_to_skip -= this_size_bits;
+ continue;
+ }
+- this_size = p->size;
+- if (this_size > type_len - offset)
+- this_size = type_len - offset;
+- if (bytes_to_skip > 0)
+- {
+- dest_offset = 0;
+- source_offset = bytes_to_skip;
+- this_size -= bytes_to_skip;
+- bytes_to_skip = 0;
++ if (this_size_bits > type_len - offset)
++ this_size_bits = type_len - offset;
++ if (bits_to_skip > 0)
++ {
++ dest_offset_bits = 0;
++ source_offset_bits = bits_to_skip;
++ this_size_bits -= bits_to_skip;
++ bits_to_skip = 0;
+ }
+ else
+ {
+- dest_offset = offset;
+- source_offset = 0;
++ dest_offset_bits = offset;
++ source_offset_bits = 0;
++ }
++
++ this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
++ source_offset = source_offset_bits / 8;
++ if (buffer_size < this_size)
++ {
++ buffer_size = this_size;
++ buffer = xrealloc (buffer, buffer_size);
+ }
++ intermediate_buffer = buffer;
+
++ /* Copy from the source to DEST_BUFFER. */
+ switch (p->location)
+ {
+ case DWARF_VALUE_REGISTER:
+@@ -316,13 +509,18 @@
+
+ if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
+ && this_size < register_size (arch, gdb_regnum))
+- /* Big-endian, and we want less than full size. */
+- reg_offset = register_size (arch, gdb_regnum) - this_size;
++ {
++ /* Big-endian, and we want less than full size. */
++ reg_offset = register_size (arch, gdb_regnum) - this_size;
++ /* We want the lower-order THIS_SIZE_BITS of the bytes
++ we extract from the register. */
++ source_offset_bits += 8 * this_size - this_size_bits;
++ }
+
+ if (gdb_regnum != -1)
+ {
+ get_frame_register_bytes (frame, gdb_regnum, reg_offset,
+- this_size, contents + dest_offset);
++ this_size, buffer);
+ }
+ else
+ {
+@@ -334,11 +532,9 @@
+
+ case DWARF_VALUE_MEMORY:
+ if (p->v.expr.in_stack_memory)
+- read_stack (p->v.expr.value + source_offset,
+- contents + dest_offset, this_size);
++ read_stack (p->v.expr.value + source_offset, buffer, this_size);
+ else
+- read_memory (p->v.expr.value + source_offset,
+- contents + dest_offset, this_size);
++ read_memory (p->v.expr.value + source_offset, buffer, this_size);
+ break;
+
+ case DWARF_VALUE_STACK:
+@@ -355,7 +551,7 @@
+ /* Nothing. */
+ }
+ else if (source_offset == 0)
+- store_unsigned_integer (contents + dest_offset, n,
++ store_unsigned_integer (buffer, n,
+ gdbarch_byte_order (gdbarch),
+ p->v.expr.value);
+ else
+@@ -365,7 +561,7 @@
+ store_unsigned_integer (bytes, n + source_offset,
+ gdbarch_byte_order (gdbarch),
+ p->v.expr.value);
+- memcpy (contents + dest_offset, bytes + source_offset, n);
++ memcpy (buffer, bytes + source_offset, n);
+ }
+ }
+ break;
+@@ -379,8 +575,7 @@
+ ? p->v.literal.length - source_offset
+ : 0);
+ if (n != 0)
+- memcpy (contents + dest_offset,
+- p->v.literal.data + source_offset, n);
++ intermediate_buffer = p->v.literal.data + source_offset;
+ }
+ break;
+
+@@ -388,17 +583,25 @@
+ /* We just leave the bits empty for now. This is not ideal
+ but gdb currently does not have a nice way to represent
+ optimized-out pieces. */
+- warning (_("bytes %ld-%ld in computed object were optimized out; "
++ warning (_("bits %ld-%ld in computed object were optimized out; "
+ "replacing with zeroes"),
+ offset,
+- offset + (long) this_size);
++ offset + (long) this_size_bits);
+ break;
+
+ default:
+ internal_error (__FILE__, __LINE__, _("invalid location type"));
+ }
+- offset += this_size;
++
++ if (p->location != DWARF_VALUE_OPTIMIZED_OUT)
++ copy_bitwise (contents, dest_offset_bits,
++ intermediate_buffer, source_offset_bits % 8,
++ this_size_bits, bits_big_endian);
++
++ offset += this_size_bits;
+ }
++
++ do_cleanups (cleanup);
+ }
+
+ static void
+@@ -406,11 +609,16 @@
+ {
+ int i;
+ long offset = 0;
+- ULONGEST bytes_to_skip;
++ ULONGEST bits_to_skip;
+ const gdb_byte *contents;
+ struct piece_closure *c = (struct piece_closure *) value_computed_closure (to);
+ struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
+ size_t type_len;
++ size_t buffer_size = 0;
++ char *buffer = NULL;
++ struct cleanup *cleanup;
++ int bits_big_endian
++ = gdbarch_bits_big_endian (get_type_arch (value_type (to)));
+
+ if (frame == NULL)
+ {
+@@ -418,34 +626,57 @@
+ return;
+ }
+
++ cleanup = make_cleanup (free_current_contents, &buffer);
++
+ contents = value_contents (from);
+- bytes_to_skip = value_offset (to);
+- type_len = TYPE_LENGTH (value_type (to));
++ bits_to_skip = 8 * value_offset (to);
++ type_len = 8 * TYPE_LENGTH (value_type (to));
+ for (i = 0; i < c->n_pieces && offset < type_len; i++)
+ {
+ struct dwarf_expr_piece *p = &c->pieces[i];
+- size_t this_size;
+- long dest_offset, source_offset;
++ size_t this_size_bits, this_size;
++ long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
++ int need_bitwise;
++ const gdb_byte *source_buffer;
+
+- if (bytes_to_skip > 0 && bytes_to_skip >= p->size)
++ this_size_bits = p->size;
++ if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
+ {
+- bytes_to_skip -= p->size;
++ bits_to_skip -= this_size_bits;
+ continue;
+ }
+- this_size = p->size;
+- if (this_size > type_len - offset)
+- this_size = type_len - offset;
+- if (bytes_to_skip > 0)
+- {
+- dest_offset = bytes_to_skip;
+- source_offset = 0;
+- this_size -= bytes_to_skip;
+- bytes_to_skip = 0;
++ if (this_size_bits > type_len - offset)
++ this_size_bits = type_len - offset;
++ if (bits_to_skip > 0)
++ {
++ dest_offset_bits = bits_to_skip;
++ source_offset_bits = 0;
++ this_size_bits -= bits_to_skip;
++ bits_to_skip = 0;
++ }
++ else
++ {
++ dest_offset_bits = 0;
++ source_offset_bits = offset;
++ }
++
++ this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
++ source_offset = source_offset_bits / 8;
++ dest_offset = dest_offset_bits / 8;
++ if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0)
++ {
++ source_buffer = contents + source_offset;
++ need_bitwise = 0;
+ }
+ else
+ {
+- dest_offset = 0;
+- source_offset = offset;
++ if (buffer_size < this_size)
++ {
++ buffer_size = this_size;
++ buffer = xrealloc (buffer, buffer_size);
++ }
++ source_buffer = buffer;
++ need_bitwise = 1;
+ }
+
+ switch (p->location)
+@@ -463,8 +694,18 @@
+
+ if (gdb_regnum != -1)
+ {
++ if (need_bitwise)
++ {
++ get_frame_register_bytes (frame, gdb_regnum, reg_offset,
++ this_size, buffer);
++ copy_bitwise (buffer, dest_offset_bits,
++ contents, source_offset_bits,
++ this_size_bits,
++ bits_big_endian);
++ }
++
+ put_frame_register_bytes (frame, gdb_regnum, reg_offset,
+- this_size, contents + source_offset);
++ this_size, source_buffer);
+ }
+ else
+ {
+@@ -474,15 +715,31 @@
+ }
+ break;
+ case DWARF_VALUE_MEMORY:
++ if (need_bitwise)
++ {
++ /* Only the first and last bytes can possibly have any
++ bits reused. */
++ read_memory (p->v.expr.value + dest_offset, buffer, 1);
++ read_memory (p->v.expr.value + dest_offset + this_size - 1,
++ buffer + this_size - 1, 1);
++ copy_bitwise (buffer, dest_offset_bits,
++ contents, source_offset_bits,
++ this_size_bits,
++ bits_big_endian);
++ }
++
+ write_memory (p->v.expr.value + dest_offset,
+- contents + source_offset, this_size);
++ source_buffer, this_size);
+ break;
+ default:
+ set_value_optimized_out (to, 1);
+- return;
++ goto done;
+ }
+- offset += this_size;
++ offset += this_size_bits;
+ }
++
++ done:
++ do_cleanups (cleanup);
+ }
+
+ static void *
+--- src/gdb/testsuite/gdb.dwarf2/pieces.S 2010/05/21 21:01:46 1.2
++++ src/gdb/testsuite/gdb.dwarf2/pieces.S 2010/05/21 21:13:13 1.3
+@@ -989,23 +989,18 @@
+ .LLST6:
+ .long .LVL13-.Ltext0 # Location list begin address (*.LLST6)
+ .long .LVL14-.Ltext0 # Location list end address (*.LLST6)
+- .value 0xa # Location expression size
+- .byte 0x9d # DW_OP_bit_piece
+- .uleb128 0x4
+- .uleb128 0
++ .value 0x8 # Location expression size
+ .byte 0x34 # DW_OP_lit4
+ .byte 0x9f # DW_OP_stack_value
+ .byte 0x9d # DW_OP_bit_piece
+ .uleb128 0xc
+ .uleb128 0
+- .byte 0x93 # DW_OP_piece
+- .uleb128 0x2
+- .long .LVL14-.Ltext0 # Location list begin address (*.LLST6)
+- .long .LVL15-.Ltext0 # Location list end address (*.LLST6)
+- .value 0x15 # Location expression size
+ .byte 0x9d # DW_OP_bit_piece
+- .uleb128 0x4
++ .uleb128 0x14
+ .uleb128 0
++ .long .LVL14-.Ltext0 # Location list begin address (*.LLST6)
++ .long .LVL15-.Ltext0 # Location list end address (*.LLST6)
++ .value 0x11 # Location expression size
+ .byte 0x34 # DW_OP_lit4
+ .byte 0x9f # DW_OP_stack_value
+ .byte 0x9d # DW_OP_bit_piece
+@@ -1021,15 +1016,11 @@
+ .byte 0x9d # DW_OP_bit_piece
+ .uleb128 0xc
+ .uleb128 0
+- .byte 0x9d # DW_OP_bit_piece
+- .uleb128 0x4
+- .uleb128 0
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x1
+ .long .LVL15-.Ltext0 # Location list begin address (*.LLST6)
+ .long .LVL16-1-.Ltext0 # Location list end address (*.LLST6)
+- .value 0x14 # Location expression size
+- .byte 0x9d # DW_OP_bit_piece
+- .uleb128 0x4
+- .uleb128 0
++ .value 0x10 # Location expression size
+ .byte 0x52 # DW_OP_reg2
+ .byte 0x9d # DW_OP_bit_piece
+ .uleb128 0xc
+@@ -1044,15 +1035,11 @@
+ .byte 0x9d # DW_OP_bit_piece
+ .uleb128 0xc
+ .uleb128 0
+- .byte 0x9d # DW_OP_bit_piece
+- .uleb128 0x4
+- .uleb128 0
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x1
+ .long .LVL16-1-.Ltext0 # Location list begin address (*.LLST6)
+ .long .LVL17-.Ltext0 # Location list end address (*.LLST6)
+- .value 0x14 # Location expression size
+- .byte 0x9d # DW_OP_bit_piece
+- .uleb128 0x4
+- .uleb128 0
++ .value 0x10 # Location expression size
+ .byte 0x56 # DW_OP_reg6
+ .byte 0x9d # DW_OP_bit_piece
+ .uleb128 0xc
+@@ -1067,14 +1054,14 @@
+ .byte 0x9d # DW_OP_bit_piece
+ .uleb128 0xc
+ .uleb128 0
+- .byte 0x9d # DW_OP_bit_piece
+- .uleb128 0x4
+- .uleb128 0
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x1
+ .long .LVL17-.Ltext0 # Location list begin address (*.LLST6)
+ .long .LFE3-.Ltext0 # Location list end address (*.LLST6)
+ .value 0xf # Location expression size
+- .byte 0x93 # DW_OP_piece
+- .uleb128 0x2
++ .byte 0x9d # DW_OP_bit_piece
++ .uleb128 0xc
++ .uleb128 0
+ .byte 0x91 # DW_OP_fbreg
+ .sleb128 0
+ .byte 0x94 # DW_OP_deref_size
+@@ -1085,9 +1072,8 @@
+ .byte 0x9d # DW_OP_bit_piece
+ .uleb128 0xc
+ .uleb128 0
+- .byte 0x9d # DW_OP_bit_piece
+- .uleb128 0x4
+- .uleb128 0
++ .byte 0x93 # DW_OP_piece
++ .uleb128 0x1
+ .long 0 # Location list terminator begin (*.LLST6)
+ .long 0 # Location list terminator end (*.LLST6)
+ .LLST7:
+@@ -1356,7 +1342,7 @@
+ .long 0x48 # DW_AT_type
+ .byte 0x4 # DW_AT_byte_size
+ .byte 0xc # DW_AT_bit_size
+- .byte 0x10 # DW_AT_bit_offset
++ .byte 0x14 # DW_AT_bit_offset
+ .byte 0x2 # DW_AT_data_member_location
+ .byte 0x23 # DW_OP_plus_uconst
+ .uleb128 0
+@@ -1367,7 +1353,7 @@
+ .long 0x48 # DW_AT_type
+ .byte 0x4 # DW_AT_byte_size
+ .byte 0xc # DW_AT_bit_size
+- .byte 0x4 # DW_AT_bit_offset
++ .byte 0x8 # DW_AT_bit_offset
+ .byte 0x2 # DW_AT_data_member_location
+ .byte 0x23 # DW_OP_plus_uconst
+ .uleb128 0
+--- src/gdb/testsuite/gdb.dwarf2/pieces.c 2010/05/21 21:01:46 1.2
++++ src/gdb/testsuite/gdb.dwarf2/pieces.c 2010/05/21 21:13:13 1.3
+@@ -21,7 +21,7 @@
+ However, it is used to extract breakpoint line numbers. */
+
+ struct A { int i; int j; };
+-struct B { int : 4; int i : 12; int j : 12; int : 4; };
++struct B { int i : 12; int j : 12; int : 4; };
+ struct C { int i; int j; int q; };
+
+ __attribute__((noinline)) void
+@@ -89,7 +89,7 @@
+ f6 (int k)
+ {
+ int z = 23;
+- struct C a = { k, k, z};
++ struct C a = { k, k, z };
+ asm ("" : "+r" (a.i));
+ a.j++;
+ bar (a.i);
+--- src/gdb/testsuite/gdb.dwarf2/pieces.exp 2010/05/21 21:01:46 1.3
++++ src/gdb/testsuite/gdb.dwarf2/pieces.exp 2010/05/21 21:13:13 1.4
+@@ -67,15 +67,30 @@
+ gdb_test "print a\[1\]" " = 14" "print a\[1\] in pieces:f2"
+ }
+
++# Function f3 tests DW_OP_bit_piece.
++proc pieces_test_f3 {} {
++ global csrcfile
++ set line [gdb_get_line_number "f3 breakpoint" $csrcfile]
++ gdb_test "break pieces.c:$line" "Breakpoint 4.*" \
++ "set f3 breakpoint for pieces"
++ gdb_continue_to_breakpoint "continue to f3 breakpoint for pieces"
++ gdb_test "print a.i" " = 4" "print a.i in pieces:f3"
++ gdb_test "print a.j" " = 14" "print a.j in pieces:f3"
++ # Right now gdb says "value optimized out" here, but that is wrong.
++ setup_kfail "no bug yet" *-*-*
++ gdb_test "print a.i = 7" " = 7" "set a.i in pieces:f3"
++ gdb_test "print a.i" " = 7" "print new a.i in pieces:f3"
++}
++
+ # Function f6 tests for an empty DW_OP_piece.
+ proc pieces_test_f6 {} {
+ global csrcfile
+ set line [gdb_get_line_number "f6 breakpoint" $csrcfile]
+- gdb_test "break pieces.c:$line" "Breakpoint 4.*" \
++ gdb_test "break pieces.c:$line" "Breakpoint 5.*" \
+ "set f6 breakpoint for pieces"
+ gdb_continue_to_breakpoint "continue to f6 breakpoint for pieces"
+ gdb_test "print a" \
+- "warning: bytes .* in computed object were.* = {i = 7, j = 8, q = 0}" \
++ "warning: bits .* in computed object were.* = {i = 7, j = 8, q = 0}" \
+ "print a with optimized out piece"
+ # Note: no warning for this case.
+ gdb_test_multiple "print a.i" \
+@@ -91,4 +106,5 @@
+
+ pieces_test_f1
+ pieces_test_f2
++pieces_test_f3
+ pieces_test_f6
diff --git a/gdb.spec b/gdb.spec
index dc8f132..cfb04c7 100644
--- a/gdb.spec
+++ b/gdb.spec
@@ -36,7 +36,7 @@ Version: 7.1
# The release always contains a leading reserved number, start it at 1.
# `upstream' is not a part of `name' to stay fully rpm dependencies compatible for the testing.
-Release: 22%{?_with_upstream:.upstream}%{dist}
+Release: 23%{?_with_upstream:.upstream}%{dist}
License: GPLv3+ and GPLv3+ with exceptions and GPLv2+ and GPLv2+ with exceptions and GPL+ and LGPLv2+ and GFDL and BSD and Public Domain
Group: Development/Debuggers
@@ -486,6 +486,19 @@ Patch461: gdb-bz594560-core-vs-process.patch
# Import fix of TUI layout internal error (BZ 595475).
Patch462: gdb-bz595475-tui-layout.patch
+# Fix and support DW_OP_*piece (Tom Tromey, BZ 589467).
+Patch463: gdb-bz589467-pieces01of4.patch
+Patch464: gdb-bz589467-pieces02of4.patch
+Patch465: gdb-bz589467-pieces03of4.patch
+Patch466: gdb-bz589467-pieces1of4.patch
+Patch467: gdb-bz589467-pieces2of4.patch
+Patch468: gdb-bz589467-pieces3of4.patch
+Patch469: gdb-bz589467-pieces4of4.patch
+Patch471: gdb-bz589467-pieces-vla-compat.patch
+
+# Fix follow-exec for C++ programs (bugreported by Martin Stransky).
+Patch470: gdb-archer-next-over-throw-cxx-exec.patch
+
BuildRequires: ncurses-devel%{?_isa} texinfo gettext flex bison expat-devel%{?_isa}
Requires: readline%{?_isa}
BuildRequires: readline-devel%{?_isa}
@@ -763,6 +776,15 @@ rm -f gdb/jv-exp.c gdb/m2-exp.c gdb/objc-exp.c gdb/p-exp.c
%patch460 -p1
%patch461 -p1
%patch462 -p1
+%patch463 -p1
+%patch464 -p1
+%patch465 -p1
+%patch466 -p1
+%patch467 -p1
+%patch468 -p1
+%patch469 -p1
+%patch471 -p1
+%patch470 -p1
%patch415 -p1
%patch393 -p1
@@ -1095,6 +1117,10 @@ fi
%endif
%changelog
+* Sun May 30 2010 Jan Kratochvil - 7.1-23.fc13
+- Fix and support DW_OP_*piece (Tom Tromey, BZ 589467).
+- Fix follow-exec for C++ programs (bugreported by Martin Stransky).
+
* Mon May 24 2010 Jan Kratochvil - 7.1-22.fc13
- Remove core file when starting a process (BZ 594560).
- Fix lock up on loops in the solib chain (BZ 593926).