[PATCH] Compute the function length instead of hard coding it

[PATCH] Compute the function length instead of hard coding it

[Yao Qi]

In Dwarf::assemble in dwz.exp, 10 is hard-coded in it,

 	    subprogram {
 		{name main}
 		{low_pc main addr}
		{high_pc "main + 10" addr}
 	    }

however, the length of main function varies on architectures.  The
hard-coded 10 here causes dwz.exp fails on some targets, such as
nios2.

This patch is to add some code to compute the length of function main,
which is similar to what we are doing in entry-values.exp.

gdb/testsuite:

2014-04-24  Yao Qi  <yao@codesourcery.com>

	* gdb.dwarf2/dwz.exp: Compile main.c to object.  Restart GDB
	and compute the length of function main.  Save it in
	$main_length.
	(Dwarf::assemble): Use $main_length instead of hard-coded 10.
	(top-level): Use gdb_compile to compile objects into
	executable and restart GDB.  Remove invocation to
	prepare_for_testing.
---
 gdb/testsuite/gdb.dwarf2/dwz.exp | 61 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 58 insertions(+), 3 deletions(-)

diff --git a/gdb/testsuite/gdb.dwarf2/dwz.exp b/gdb/testsuite/gdb.dwarf2/dwz.exp
index aa0ea7d..c19735f 100644
--- a/gdb/testsuite/gdb.dwarf2/dwz.exp
+++ b/gdb/testsuite/gdb.dwarf2/dwz.exp
@@ -22,10 +22,59 @@ if {![dwarf2_support]} {
 
 standard_testfile main.c dwz.S
 
+if  {[gdb_compile ${srcdir}/${subdir}/${srcfile} ${binfile}1.o \
+	  object {nodebug}] != ""} {
+    return -1
+}
+
+# Start GDB and load object file, compute the function length which is
+# needed in the Dwarf Assembler below.
+
+gdb_exit
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+gdb_load ${binfile}1.o
+
+set main_length ""
+set test "disassemble main"
+gdb_test_multiple $test $test {
+    -re ".*$hex <\\+($decimal)>:\[^\r\n\]+\r\nEnd of assembler dump\.\r\n$gdb_prompt $" {
+	set main_length $expect_out(1,string)
+	pass $test
+    }
+    -re ".*$gdb_prompt $" {
+	fail $test
+	# Bail out here, because we can't do the following tests if
+	# $main_length is unknown.
+	return -1
+    }
+}
+# Calculate the size of the last instruction.  Single instruction
+# shouldn't be longer than 10 bytes.
+
+set test "disassemble main+$main_length,+10"
+gdb_test_multiple $test $test {
+    -re ".*($hex) <main\\+$main_length>:\[^\r\n\]+\r\n\[ \]+($hex).*\.\r\n$gdb_prompt $" {
+	set start $expect_out(1,string)
+	set end $expect_out(2,string)
+
+	set main_length [expr $main_length + $end - $start]
+	pass $test
+    }
+    -re ".*$gdb_prompt $" {
+	fail $test
+	# Bail out here, because we can't do the following tests if
+	# $main_length is unknown.
+	return -1
+    }
+}
+gdb_exit
+
 # Create the DWARF.
 set asm_file [standard_output_file $srcfile2]
 Dwarf::assemble $asm_file {
     declare_labels partial_label int_label int_label2
+    global main_length
 
     extern main
 
@@ -34,7 +83,7 @@ Dwarf::assemble $asm_file {
 	    subprogram {
 		{name main}
 		{low_pc main addr}
-		{high_pc "main + 10" addr}
+		{high_pc "main + $main_length" addr}
 	    }
 	}
     }
@@ -82,11 +131,17 @@ Dwarf::assemble $asm_file {
     }
 }
 
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
-	  [list $srcfile $asm_file] {nodebug}] } {
+if  {[gdb_compile $asm_file ${binfile}2.o object {nodebug}] != ""} {
     return -1
 }
 
+if  {[gdb_compile [list ${binfile}1.o ${binfile}2.o] \
+	  "${binfile}" executable {}] != ""} {
+    return -1
+}
+
+clean_restart ${testfile}
+
 if ![runto_main] {
     return -1
 }
-- 
1.9.0

Re: [PATCH] Compute the function length instead of hard coding it

[Pedro Alves]

(Is there really no way to query GDB for the function's size
directly?  Seems like something that "info symbol main" should
be spit out.)

On 04/24/2014 01:43 PM, Yao Qi wrote:

> +set main_length ""
> +set test "disassemble main"
> +gdb_test_multiple $test $test {
> +    -re ".*$hex <\\+($decimal)>:\[^\r\n\]+\r\nEnd of assembler dump\.\r\n$gdb_prompt $" {
> +	set main_length $expect_out(1,string)
> +	pass $test
> +    }
> +    -re ".*$gdb_prompt $" {
> +	fail $test
> +	# Bail out here, because we can't do the following tests if
> +	# $main_length is unknown.
> +	return -1
> +    }

Instead of this -re, best do

if { $main_length == "" } {
  return -1
}

after gdb_test_multiple, as $main_length is unknown on e.g., internal
error or timeout too.

> +}
> +# Calculate the size of the last instruction.  Single instruction
> +# shouldn't be longer than 10 bytes.

x86 has instructions longer than that, though it's not likely
we'll see them as last instruction.  You want to disassemble two
instructions.  So instead of having to hard code some number and
having to explain it in a comment, how about just asking GDB what
we want, with x/i ?  That is:

(gdb) x /2i main+72
   0x45d854 <main+72>:  retq
   0x45d855:    nopl   (%rax)

> +
> +set test "disassemble main+$main_length,+10"
> +gdb_test_multiple $test $test {
> +    -re ".*($hex) <main\\+$main_length>:\[^\r\n\]+\r\n\[ \]+($hex).*\.\r\n$gdb_prompt $" {
> +	set start $expect_out(1,string)
> +	set end $expect_out(2,string)
> +
> +	set main_length [expr $main_length + $end - $start]
> +	pass $test
> +    }
> +    -re ".*$gdb_prompt $" {
> +	fail $test
> +	# Bail out here, because we can't do the following tests if
> +	# $main_length is unknown.
> +	return -1

Same comment here as above.

-- 
Pedro Alves

Re: [PATCH] Compute the function length instead of hard coding it

[Yao Qi]

On 04/24/2014 10:04 PM, Pedro Alves wrote:
> if { $main_length == "" } {
>   return -1
> }
> 
> after gdb_test_multiple, as $main_length is unknown on e.g., internal
> error or timeout too.

OK, let's do the check like this.

> 
>> > +}
>> > +# Calculate the size of the last instruction.  Single instruction
>> > +# shouldn't be longer than 10 bytes.
> x86 has instructions longer than that, though it's not likely
> we'll see them as last instruction.  You want to disassemble two
> instructions.  So instead of having to hard code some number and
> having to explain it in a comment, how about just asking GDB what
> we want, with x/i ?  That is:
> 
> (gdb) x /2i main+72
>    0x45d854 <main+72>:  retq
>    0x45d855:    nopl   (%rax)
> 

"x /2i" is good to me.  Here is the updated patch.

-- 
Yao (齐尧)

gdb/testsuite:

2014-04-25  Yao Qi  <yao@codesourcery.com>

	* gdb.dwarf2/dwz.exp: Compile main.c to object.  Restart GDB
	and compute the length of function main.  Save it in
	$main_length.
	(Dwarf::assemble): Use $main_length instead of hard-coded 10.
	(top-level): Use gdb_compile to compile objects into
	executable and restart GDB.  Remove invocation to
	prepare_for_testing.
---
 gdb/testsuite/gdb.dwarf2/dwz.exp | 62 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 59 insertions(+), 3 deletions(-)

diff --git a/gdb/testsuite/gdb.dwarf2/dwz.exp b/gdb/testsuite/gdb.dwarf2/dwz.exp
index aa0ea7d..6872bde 100644
--- a/gdb/testsuite/gdb.dwarf2/dwz.exp
+++ b/gdb/testsuite/gdb.dwarf2/dwz.exp
@@ -22,10 +22,60 @@ if {![dwarf2_support]} {
 
 standard_testfile main.c dwz.S
 
+if  {[gdb_compile ${srcdir}/${subdir}/${srcfile} ${binfile}1.o \
+	  object {nodebug}] != ""} {
+    return -1
+}
+
+# Start GDB and load object file, compute the function length which is
+# needed in the Dwarf Assembler below.
+
+gdb_exit
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+gdb_load ${binfile}1.o
+
+set main_length ""
+set test "disassemble main"
+gdb_test_multiple $test $test {
+    -re ".*$hex <\\+($decimal)>:\[^\r\n\]+\r\nEnd of assembler dump\.\r\n$gdb_prompt $" {
+	set main_length $expect_out(1,string)
+	pass $test
+    }
+}
+
+if { $main_length == "" } {
+    # Bail out here, because we can't do the following tests if
+    # $main_length is unknown.
+    return -1
+}
+
+# Compute the size of the last instruction.
+
+set test "x/2i main+$main_length"
+gdb_test_multiple $test $test {
+    -re ".*($hex) <main\\+$main_length>:\[^\r\n\]+\r\n\[ \]+($hex).*\.\r\n$gdb_prompt $" {
+	set start $expect_out(1,string)
+	set end $expect_out(2,string)
+
+	set main_length [expr $main_length + $end - $start]
+	pass $test
+    }
+}
+
+if { $main_length == "" } {
+    # Bail out here, because we can't do the following tests if
+    # $main_length is unknown.
+    return -1
+}
+
+gdb_exit
+
 # Create the DWARF.
 set asm_file [standard_output_file $srcfile2]
 Dwarf::assemble $asm_file {
     declare_labels partial_label int_label int_label2
+    global main_length
 
     extern main
 
@@ -34,7 +84,7 @@ Dwarf::assemble $asm_file {
 	    subprogram {
 		{name main}
 		{low_pc main addr}
-		{high_pc "main + 10" addr}
+		{high_pc "main + $main_length" addr}
 	    }
 	}
     }
@@ -82,11 +132,17 @@ Dwarf::assemble $asm_file {
     }
 }
 
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
-	  [list $srcfile $asm_file] {nodebug}] } {
+if  {[gdb_compile $asm_file ${binfile}2.o object {nodebug}] != ""} {
+    return -1
+}
+
+if  {[gdb_compile [list ${binfile}1.o ${binfile}2.o] \
+	  "${binfile}" executable {}] != ""} {
     return -1
 }
 
+clean_restart ${testfile}
+
 if ![runto_main] {
     return -1
 }
-- 
1.9.0

Re: [PATCH] Compute the function length instead of hard coding it

[Pedro Alves]

On 04/25/2014 02:33 AM, Yao Qi wrote:

> 	* gdb.dwarf2/dwz.exp: Compile main.c to object.  Restart GDB
> 	and compute the length of function main.  Save it in
> 	$main_length.
> 	(Dwarf::assemble): Use $main_length instead of hard-coded 10.
> 	(top-level): Use gdb_compile to compile objects into
> 	executable and restart GDB.  Remove invocation to
> 	prepare_for_testing.

OK, with ...

> +# Start GDB and load object file, compute the function length which is
> +# needed in the Dwarf Assembler below.
> +
> +gdb_exit
> +gdb_start
> +gdb_reinitialize_dir $srcdir/$subdir
> +gdb_load ${binfile}1.o

I think this instead should work:

 clean_restart ${testfile}1.o

-- 
Pedro Alves

Re: [PATCH] Compute the function length instead of hard coding it

[Yao Qi]

On 04/25/2014 06:37 PM, Pedro Alves wrote:
> I think this instead should work:
> 
>  clean_restart ${testfile}1.o

Fixed.

Thanks, Pedro.  Patch is pushed in.

-- 
Yao (齐尧)