gdb/testsuite/gdb.mi/mi-disassemble.exp - binutils-gdb - Git at Google

 # Copyright 1999-2021 Free Software Foundation, Inc.

 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.

 #
 # Test Machine interface (MI) operations for disassembly.
 #
 # The goal is not to test gdb functionality, which is done by other tests,
 # but to verify the correct output response to MI operations.
 #

 load_lib mi-support.exp
 set MIFLAGS "-i=mi"

 standard_testfile basics.c

 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
      untested "failed to compile"
      return -1
 }

 proc test_disassembly_only {} {
     global mi_gdb_prompt
     global hex
     global decimal

     set line_main_head [gdb_get_line_number "main ("]
     set line_main_body [expr $line_main_head + 2]

     # Test disassembly more only for the current function.
     # Tests:
     # -data-disassemble -s $pc -e "$pc+8" -- 0
     # -data-disassemble -a $pc -- 0
     # -data-disassemble -a callee4 -- 0
     # -data-disassembly -f basics.c -l $line_main_body -- 0


     mi_gdb_test "print/x \$pc" "" ""
     mi_gdb_test "111-data-disassemble -s \$pc -e \"\$pc + 12\" -- 0" \
 	    "111\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\},\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\}.*\]" \
              "data-disassemble from pc to pc+12 assembly only"

     mi_gdb_test "112-data-disassemble -a \$pc -- 0" \
 	    "112\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\},\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\}.*\]" \
              "data-disassemble function around pc assembly only"

     mi_gdb_test "113-data-disassemble -a callee4 -- 0" \
 	    "113\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"callee4\",offset=\"$decimal\",inst=\".*\"\},\{address=\"$hex\",func-name=\"callee4\",offset=\"$decimal\",inst=\".*\"\}.*\]" \
              "data-disassemble function callee4 assembly only"

     mi_gdb_test "222-data-disassemble  -f basics.c -l $line_main_body -- 0" \
 	    "222\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"0\",inst=\".*\"\},.*,\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\}\\\]" \
               "data-disassemble file & line, assembly only"
 }

 proc test_disassembly_with_opcodes {} {
     global mi_gdb_prompt
     global hex
     global decimal

     set line_main_head [gdb_get_line_number "main ("]
     set line_main_body [expr $line_main_head + 2]

     # Test disassembly with opcodes for the current function.
     # Tests:
     # -data-disassemble -s $pc -e "$pc+8" -- 2
     # -data-disassembly -f basics.c -l $line_main_body -- 2

     mi_gdb_test "print/x \$pc" "" ""
     mi_gdb_test "111-data-disassemble -s \$pc -e \"\$pc + 12\" -- 2" \
            "111\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",opcodes=\".*\",inst=\".*\"\},\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",opcodes=\".*\",inst=\".*\"\}.*\]" \
              "data-disassemble from pc to pc+12 assembly with opcodes"

     mi_gdb_test "222-data-disassemble  -f basics.c -l $line_main_body -- 2" \
            "222\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"0\",opcodes=\".*\",inst=\".*\"\},.*,\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",opcodes=\".*\",inst=\".*\"\}\\\]" \
               "data-disassemble file & line, assembly with opcodes"
 }

 proc test_disassembly_lines_limit {} {
     global mi_gdb_prompt
     global hex
     global decimal

     set line_main_head [gdb_get_line_number "main ("]
     set line_main_body [expr $line_main_head + 2]

     # Test disassembly more only for the current function.
     # Tests:
     # -data-disassembly -f basics.c -l $line_main_body -n 20 -- 0
     # -data-disassembly -f basics.c -l $line_main_body -n 0 -- 0
     # -data-disassembly -f basics.c -l $line_main_body -n 50 -- 0

     mi_gdb_test "print/x \$pc" "" ""
     mi_gdb_test "222-data-disassemble  -f basics.c -l $line_main_body -n 20 -- 0" \
 	    "222\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"0\",inst=\".*\"\},.*,\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\}\\\]" \
               "data-disassemble file, line, number assembly only"

     mi_gdb_test "222-data-disassemble  -f basics.c -l $line_main_body -n 0 -- 0" \
 	    "222\\^done,asm_insns=\\\[\\\]" \
               "data-disassemble file, line, number (zero lines) assembly only"

     mi_gdb_test "222-data-disassemble  -f basics.c -l $line_main_body -n 50 -- 0" \
 	    "222\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"0\",inst=\".*\"\},.*,\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\}\\\]" \
               "data-disassemble file, line, number (more than main lines) assembly only"
 }


 proc test_disassembly_mixed {} {
     global mi_gdb_prompt
     global hex
     global decimal
     global fullname_syntax

     set line_callee2_head       [gdb_get_line_number "callee2 ("]
     set line_callee2_open_brace [expr $line_callee2_head + 1]

     # Test disassembly more only for the current function.
     # Tests:
     # -data-disassembly -f basics.c -l $line_callee2_open_brace -- 1
     # -data-disassembly -s $pc -e "$pc+8" -- 1

     mi_gdb_test "002-data-disassemble -f basics.c -l $line_callee2_open_brace -- 1" \
 	    "002\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$line_callee2_open_brace\",file=\".*basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\{address=\"$hex\",func-name=\"callee2\",offset=\"0\",inst=\".*\"\}.*\\\]\}.*,src_and_asm_line=\{line=\"$decimal\",file=\".*basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[.*\{address=\"$hex\",func-name=\"callee2\",offset=\"$decimal\",inst=\".*\"\}\\\]\}\\\]" \
              "data-disassemble file, line assembly mixed"

     #
     # In mixed mode, the lowest level of granularity is the source line.
     # So we are going to get the disassembly for the source line at
     # which we are now, even if we have specified that the range is only 2 insns.
     #
     mi_gdb_test "003-data-disassemble -s \$pc -e \"\$pc+4\" -- 1" \
 	    "003\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$decimal\",file=\".*basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\}.*\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\}\\\]\}\\\]" \
              "data-disassemble range assembly mixed"
 }

 proc test_disassembly_mixed_with_opcodes {} {
     global mi_gdb_prompt
     global hex
     global decimal
     global fullname_syntax

     set line_callee2_head       [gdb_get_line_number "callee2 ("]
     set line_callee2_open_brace [expr $line_callee2_head + 1]

     # Test disassembly mixed with opcodes for the current function.
     # Tests:
     # -data-disassembly -f basics.c -l $line_callee2_open_brace -- 3
     # -data-disassembly -s $pc -e "$pc+8" -- 3

     mi_gdb_test "002-data-disassemble -f basics.c -l $line_callee2_open_brace -- 3" \
            "002\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$line_callee2_open_brace\",file=\".*basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\{address=\"$hex\",func-name=\"callee2\",offset=\"0\",opcodes=\".*\",inst=\".*\"\}.*\\\]\}.*,src_and_asm_line=\{line=\"$decimal\",file=\".*basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[.*\{address=\"$hex\",func-name=\"callee2\",offset=\"$decimal\",opcodes=\".*\",inst=\".*\"\}\\\]\}\\\]" \
              "data-disassemble file, line assembly mixed with opcodes"

     #
     # In mixed mode, the lowest level of granularity is the source line.
     # So we are going to get the disassembly for the source line at
     # which we are now, even if we have specified that the range is only 2 insns.
     #
     mi_gdb_test "003-data-disassemble -s \$pc -e \"\$pc+4\" -- 3" \
            "003\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$decimal\",file=\".*basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",opcodes=\".*\",inst=\".*\"\}.*\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",opcodes=\".*\",inst=\".*\"\}\\\]\}\\\]" \
              "data-disassemble range assembly mixed with opcodes"
 }

 proc test_disassembly_mixed_lines_limit {} {
     global mi_gdb_prompt
     global hex
     global decimal
     global fullname_syntax

     set line_main_head       [gdb_get_line_number "main ("]
     set line_main_open_brace [expr $line_main_head + 1]
     set line_main_body       [expr $line_main_head + 2]

     # Test disassembly more only for the current function.
     # Tests:
     # -data-disassembly -f basics.c -l $line_main_body -n 20 -- 1
     # -data-disassembly -f basics.c -l $line_main_body -n 0 -- 1
     # -data-disassembly -f basics.c -l $line_main_body -n 50 -- 1

     mi_gdb_test "print/x \$pc" "" ""
     mi_gdb_test "222-data-disassemble  -f basics.c -l $line_main_body -n 20 -- 1" \
 	    "222\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$decimal\",file=\".*basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"0\",inst=\".*\"\},.*,\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\}\\\]\}\]" \
               "data-disassemble file, line, number assembly mixed"

     mi_gdb_test "222-data-disassemble  -f basics.c -l $line_main_body -n 0 -- 1" \
 	    "222\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$line_main_open_brace\",file=\".*basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\\\]\}\\\]" \
               "data-disassemble file, line, number (zero lines) assembly mixed"

     mi_gdb_test "222-data-disassemble  -f basics.c -l $line_main_body -n 50 -- 1" \
 	    "222\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$decimal\",file=\".*basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"0\",inst=\".*\"\}.*,\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\}\\\]\}\]" \
               "data-disassemble file, line, number (more than main lines) assembly mixed"
 }

 proc test_disassembly_bogus_args {} {
     global mi_gdb_prompt
     global hex

     set line_main_head [gdb_get_line_number "main ("]
     set line_main_body [expr $line_main_head + 2]

     # Test that bogus input to disassembly command is rejected.
     # Tests:
     # -data-disassembly -f foo -l abc -n 0 -- 0
     # -data-disassembly -s foo -e bar -- 0
     # -data-disassembly -a foo -- 0
     # -data-disassembly -s $pc -f basics.c -- 0
     # -data-disassembly -f basics.c -l 32 -- 9

     mi_gdb_test "123-data-disassemble -f foo -l abc -n 0 -- 0" \
              "123\\^error,msg=\"-data-disassemble: Invalid filename.\"" \
              "data-disassemble bogus filename"

     mi_gdb_test "321-data-disassemble -s foo -e bar -- 0" \
              "321\\^error,msg=\"No symbol \\\\\"foo\\\\\" in current context.\"" \
              "data-disassemble bogus address, -s -e"

     mi_gdb_test "322-data-disassemble -a foo -- 0" \
              "322\\^error,msg=\"No symbol \\\\\"foo\\\\\" in current context.\"" \
              "data-disassemble bogus address, -a"

     mi_gdb_test "456-data-disassemble -s \$pc -f basics.c -- 0" \
              "456\\^error,msg=\"-data-disassemble: Usage: \\( .-f filename -l linenum .-n howmany.. \\| .-s startaddr -e endaddr. \\| .-a addr. \\) .--. mode.\"" \
              "data-disassemble mix different args"

     mi_gdb_test "789-data-disassemble -f basics.c -l $line_main_body -- 9" \
              "789\\^error,msg=\"-data-disassemble: Mode argument must be in the range 0-5.\"" \
              "data-disassemble wrong mode arg"

 }

 mi_clean_restart $binfile
 mi_runto_main
 test_disassembly_only
 test_disassembly_with_opcodes
 test_disassembly_mixed
 test_disassembly_mixed_with_opcodes
 test_disassembly_bogus_args
 test_disassembly_lines_limit
 test_disassembly_mixed_lines_limit

 mi_gdb_exit
 return 0
	# Copyright 1999-2021 Free Software Foundation, Inc.

	# This program is free software; you can redistribute it and/or modify
	# it under the terms of the GNU General Public License as published by
	# the Free Software Foundation; either version 3 of the License, or
	# (at your option) any later version.
	#
	# This program is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License
	# along with this program. If not, see <http://www.gnu.org/licenses/>.

	#
	# Test Machine interface (MI) operations for disassembly.
	#
	# The goal is not to test gdb functionality, which is done by other tests,
	# but to verify the correct output response to MI operations.
	#

	load_lib mi-support.exp
	set MIFLAGS "-i=mi"

	standard_testfile basics.c

	if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
	untested "failed to compile"
	return -1
	}

	proc test_disassembly_only {} {
	global mi_gdb_prompt
	global hex
	global decimal

	set line_main_head [gdb_get_line_number "main ("]
	set line_main_body [expr $line_main_head + 2]

	# Test disassembly more only for the current function.
	# Tests:
	# -data-disassemble -s $pc -e "$pc+8" -- 0
	# -data-disassemble -a $pc -- 0
	# -data-disassemble -a callee4 -- 0
	# -data-disassembly -f basics.c -l $line_main_body -- 0


	mi_gdb_test "print/x \$pc" "" ""
	mi_gdb_test "111-data-disassemble -s \$pc -e \"\$pc + 12\" -- 0" \
	"111\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".\"\},\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".\"\}.*\]" \
	"data-disassemble from pc to pc+12 assembly only"

	mi_gdb_test "112-data-disassemble -a \$pc -- 0" \
	"112\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".\"\},\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".\"\}.*\]" \
	"data-disassemble function around pc assembly only"

	mi_gdb_test "113-data-disassemble -a callee4 -- 0" \
	"113\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"callee4\",offset=\"$decimal\",inst=\".\"\},\{address=\"$hex\",func-name=\"callee4\",offset=\"$decimal\",inst=\".\"\}.*\]" \
	"data-disassemble function callee4 assembly only"

	mi_gdb_test "222-data-disassemble -f basics.c -l $line_main_body -- 0" \
	"222\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"0\",inst=\".\"\},.,\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\}\\\]" \
	"data-disassemble file & line, assembly only"
	}

	proc test_disassembly_with_opcodes {} {
	global mi_gdb_prompt
	global hex
	global decimal

	set line_main_head [gdb_get_line_number "main ("]
	set line_main_body [expr $line_main_head + 2]

	# Test disassembly with opcodes for the current function.
	# Tests:
	# -data-disassemble -s $pc -e "$pc+8" -- 2
	# -data-disassembly -f basics.c -l $line_main_body -- 2

	mi_gdb_test "print/x \$pc" "" ""
	mi_gdb_test "111-data-disassemble -s \$pc -e \"\$pc + 12\" -- 2" \
	"111\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",opcodes=\".\",inst=\".\"\},\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",opcodes=\".\",inst=\".\"\}.*\]" \
	"data-disassemble from pc to pc+12 assembly with opcodes"

	mi_gdb_test "222-data-disassemble -f basics.c -l $line_main_body -- 2" \
	"222\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"0\",opcodes=\".\",inst=\".\"\},.,\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",opcodes=\".\",inst=\".*\"\}\\\]" \
	"data-disassemble file & line, assembly with opcodes"
	}

	proc test_disassembly_lines_limit {} {
	global mi_gdb_prompt
	global hex
	global decimal

	set line_main_head [gdb_get_line_number "main ("]
	set line_main_body [expr $line_main_head + 2]

	# Test disassembly more only for the current function.
	# Tests:
	# -data-disassembly -f basics.c -l $line_main_body -n 20 -- 0
	# -data-disassembly -f basics.c -l $line_main_body -n 0 -- 0
	# -data-disassembly -f basics.c -l $line_main_body -n 50 -- 0

	mi_gdb_test "print/x \$pc" "" ""
	mi_gdb_test "222-data-disassemble -f basics.c -l $line_main_body -n 20 -- 0" \
	"222\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"0\",inst=\".\"\},.,\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\}\\\]" \
	"data-disassemble file, line, number assembly only"

	mi_gdb_test "222-data-disassemble -f basics.c -l $line_main_body -n 0 -- 0" \
	"222\\^done,asm_insns=\\\[\\\]" \
	"data-disassemble file, line, number (zero lines) assembly only"

	mi_gdb_test "222-data-disassemble -f basics.c -l $line_main_body -n 50 -- 0" \
	"222\\^done,asm_insns=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"0\",inst=\".\"\},.,\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".*\"\}\\\]" \
	"data-disassemble file, line, number (more than main lines) assembly only"
	}


	proc test_disassembly_mixed {} {
	global mi_gdb_prompt
	global hex
	global decimal
	global fullname_syntax

	set line_callee2_head [gdb_get_line_number "callee2 ("]
	set line_callee2_open_brace [expr $line_callee2_head + 1]

	# Test disassembly more only for the current function.
	# Tests:
	# -data-disassembly -f basics.c -l $line_callee2_open_brace -- 1
	# -data-disassembly -s $pc -e "$pc+8" -- 1

	mi_gdb_test "002-data-disassemble -f basics.c -l $line_callee2_open_brace -- 1" \
	"002\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$line_callee2_open_brace\",file=\".basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\{address=\"$hex\",func-name=\"callee2\",offset=\"0\",inst=\".\"\}.\\\]\}.,src_and_asm_line=\{line=\"$decimal\",file=\".basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[.\{address=\"$hex\",func-name=\"callee2\",offset=\"$decimal\",inst=\".*\"\}\\\]\}\\\]" \
	"data-disassemble file, line assembly mixed"

	#
	# In mixed mode, the lowest level of granularity is the source line.
	# So we are going to get the disassembly for the source line at
	# which we are now, even if we have specified that the range is only 2 insns.
	#
	mi_gdb_test "003-data-disassemble -s \$pc -e \"\$pc+4\" -- 1" \
	"003\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$decimal\",file=\".basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".\"\}.\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".\"\}\\\]\}\\\]" \
	"data-disassemble range assembly mixed"
	}

	proc test_disassembly_mixed_with_opcodes {} {
	global mi_gdb_prompt
	global hex
	global decimal
	global fullname_syntax

	set line_callee2_head [gdb_get_line_number "callee2 ("]
	set line_callee2_open_brace [expr $line_callee2_head + 1]

	# Test disassembly mixed with opcodes for the current function.
	# Tests:
	# -data-disassembly -f basics.c -l $line_callee2_open_brace -- 3
	# -data-disassembly -s $pc -e "$pc+8" -- 3

	mi_gdb_test "002-data-disassemble -f basics.c -l $line_callee2_open_brace -- 3" \
	"002\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$line_callee2_open_brace\",file=\".basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\{address=\"$hex\",func-name=\"callee2\",offset=\"0\",opcodes=\".\",inst=\".\"\}.\\\]\}.,src_and_asm_line=\{line=\"$decimal\",file=\".basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[.\{address=\"$hex\",func-name=\"callee2\",offset=\"$decimal\",opcodes=\".\",inst=\".*\"\}\\\]\}\\\]" \
	"data-disassemble file, line assembly mixed with opcodes"

	#
	# In mixed mode, the lowest level of granularity is the source line.
	# So we are going to get the disassembly for the source line at
	# which we are now, even if we have specified that the range is only 2 insns.
	#
	mi_gdb_test "003-data-disassemble -s \$pc -e \"\$pc+4\" -- 3" \
	"003\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$decimal\",file=\".basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",opcodes=\".\",inst=\".\"\}.\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",opcodes=\".\",inst=\".\"\}\\\]\}\\\]" \
	"data-disassemble range assembly mixed with opcodes"
	}

	proc test_disassembly_mixed_lines_limit {} {
	global mi_gdb_prompt
	global hex
	global decimal
	global fullname_syntax

	set line_main_head [gdb_get_line_number "main ("]
	set line_main_open_brace [expr $line_main_head + 1]
	set line_main_body [expr $line_main_head + 2]

	# Test disassembly more only for the current function.
	# Tests:
	# -data-disassembly -f basics.c -l $line_main_body -n 20 -- 1
	# -data-disassembly -f basics.c -l $line_main_body -n 0 -- 1
	# -data-disassembly -f basics.c -l $line_main_body -n 50 -- 1

	mi_gdb_test "print/x \$pc" "" ""
	mi_gdb_test "222-data-disassemble -f basics.c -l $line_main_body -n 20 -- 1" \
	"222\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$decimal\",file=\".basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"0\",inst=\".\"\},.,\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".\"\}\\\]\}\]" \
	"data-disassemble file, line, number assembly mixed"

	mi_gdb_test "222-data-disassemble -f basics.c -l $line_main_body -n 0 -- 1" \
	"222\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$line_main_open_brace\",file=\".*basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\\\]\}\\\]" \
	"data-disassemble file, line, number (zero lines) assembly mixed"

	mi_gdb_test "222-data-disassemble -f basics.c -l $line_main_body -n 50 -- 1" \
	"222\\^done,asm_insns=\\\[src_and_asm_line=\{line=\"$decimal\",file=\".basics.c\",fullname=\"${fullname_syntax}basics.c\",line_asm_insn=\\\[\{address=\"$hex\",func-name=\"main\",offset=\"0\",inst=\".\"\}.,\{address=\"$hex\",func-name=\"main\",offset=\"$decimal\",inst=\".\"\}\\\]\}\]" \
	"data-disassemble file, line, number (more than main lines) assembly mixed"
	}

	proc test_disassembly_bogus_args {} {
	global mi_gdb_prompt
	global hex

	set line_main_head [gdb_get_line_number "main ("]
	set line_main_body [expr $line_main_head + 2]

	# Test that bogus input to disassembly command is rejected.
	# Tests:
	# -data-disassembly -f foo -l abc -n 0 -- 0
	# -data-disassembly -s foo -e bar -- 0
	# -data-disassembly -a foo -- 0
	# -data-disassembly -s $pc -f basics.c -- 0
	# -data-disassembly -f basics.c -l 32 -- 9

	mi_gdb_test "123-data-disassemble -f foo -l abc -n 0 -- 0" \
	"123\\^error,msg=\"-data-disassemble: Invalid filename.\"" \
	"data-disassemble bogus filename"

	mi_gdb_test "321-data-disassemble -s foo -e bar -- 0" \
	"321\\^error,msg=\"No symbol \\\\\"foo\\\\\" in current context.\"" \
	"data-disassemble bogus address, -s -e"

	mi_gdb_test "322-data-disassemble -a foo -- 0" \
	"322\\^error,msg=\"No symbol \\\\\"foo\\\\\" in current context.\"" \
	"data-disassemble bogus address, -a"

	mi_gdb_test "456-data-disassemble -s \$pc -f basics.c -- 0" \
	"456\\^error,msg=\"-data-disassemble: Usage: \\( .-f filename -l linenum .-n howmany.. \\\| .-s startaddr -e endaddr. \\\| .-a addr. \\) .--. mode.\"" \
	"data-disassemble mix different args"

	mi_gdb_test "789-data-disassemble -f basics.c -l $line_main_body -- 9" \
	"789\\^error,msg=\"-data-disassemble: Mode argument must be in the range 0-5.\"" \
	"data-disassemble wrong mode arg"

	}

	mi_clean_restart $binfile
	mi_runto_main
	test_disassembly_only
	test_disassembly_with_opcodes
	test_disassembly_mixed
	test_disassembly_mixed_with_opcodes
	test_disassembly_bogus_args
	test_disassembly_lines_limit
	test_disassembly_mixed_lines_limit

	mi_gdb_exit
	return 0