From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from nx227.node02.secure-mailgate.com (nx227.node02.secure-mailgate.com [192.162.87.227]) by sourceware.org (Postfix) with ESMTPS id 25D383851C0B for ; Fri, 9 Apr 2021 19:34:35 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 25D383851C0B Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=trande.de Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=zied.guermazi@trande.de Received: from host202.checkdomain.de ([185.137.168.148]) by node02.secure-mailgate.com with esmtps (TLSv1.2:AES128-GCM-SHA256:128) (Exim 4.92) (envelope-from ) id 1lUwtk-003OQP-Dj; Fri, 09 Apr 2021 21:34:33 +0200 X-SecureMailgate-Identity: zied.guermazi@trande.de;host202.checkdomain.de Received: from [192.168.178.48] (x4db99630.dyn.telefonica.de [77.185.150.48]) (Authenticated sender: zied.guermazi@trande.de) by host202.checkdomain.de (Postfix) with ESMTPSA id A044A2A3821; Fri, 9 Apr 2021 21:34:29 +0200 (CEST) X-SecureMailgate-Identity: zied.guermazi@trande.de;host202.checkdomain.de Subject: Re: [PATCH v3 7/7] adapt btrace testcases for arm target To: Luis Machado , gdb-patches@sourceware.org References: <20210331025234.518688-1-zied.guermazi@trande.de> <20210331025234.518688-8-zied.guermazi@trande.de> From: Zied Guermazi Message-ID: <05cce6bf-63ed-e399-5a86-888e5e77eaa1@trande.de> Date: Fri, 9 Apr 2021 21:34:28 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: Content-Language: en-US X-PPP-Message-ID: <20210409193430.3488619.92369@host202.checkdomain.de> X-PPP-Vhost: trande.de X-Originating-IP: 185.137.168.148 X-SecureMailgate-Domain: host202.checkdomain.de X-SecureMailgate-Username: 185.137.168.148 Authentication-Results: secure-mailgate.com; auth=pass smtp.auth=185.137.168.148@host202.checkdomain.de X-SecureMailgate-Outgoing-Class: ham X-SecureMailgate-Outgoing-Evidence: SB/global_tokens (0.00198215529636) X-Recommended-Action: accept X-Filter-ID: Pt3MvcO5N4iKaDQ5O6lkdGlMVN6RH8bjRMzItlySaT/xkhgR+OcTUkCHc5cjoQPuPUtbdvnXkggZ 3YnVId/Y5jcf0yeVQAvfjHznO7+bT5wqBcSGeVWq1E9YWZbsmhKMTlod1WpdzSJAbIL3qp5JunYf gJ55pDnOxWzxymfhhAUcEJUqtZn698k7kZCd7zwAAXDkcXwqI3EzqRI7b1h6dqBrCFQuzrokq72u RaZEQe9TtObPqIqeRAv2CqzEPfjvi0o/CVJc0dIeRwB45LykIMLu9UNzd7b2iRexhj6M6CgrSpDz jEtjfX8+OHl4cyU6Iigw87aa/wTfuDn3L9Gvl+PbtY8iGKpgD7lZ6uvsTVfrP7ksjopbD4QVYOxe Uu3OBrcc33wjWlcqFtYYz7YOWQzYc1X3WAFlD/U9uzx6jrgkLqqGPdiSxZiq1HKePN+Jh2lTU+tO zPZGTRGiEElHIf0IEXAFWRO25xi5QnnsmGlpFk6dm7rPDkt9DXt4Sg+DH9u8bwQR7T6cYAlUQy2v pH/S0BGIotuwG/h4FqtFRE00VScfkx6GFQG7tv50kLLNmJs3ZqOdZ55gH1N/gw5A67/ukR2LocmR rLk878QEzPHcW16QoG4igbAPg3YupmsHTikgkbfRhpbDtlNxzjS2RbnSYHqLeOHt2MdG2gILvLgi 94PWRqqg5f2zj0Czwt/24XdQQ9W+OVoe9sHR20A4zGW2XuA1Eg+8Q0FElU4j8pn691Swor8Z5o5Z c7JHts6r++DuIQUs/5JJj4C/n4CILs9b2DNk4+l+mV75dI3hhQjPw0ElUy6x+SxmYAcSR9X1+upu CY52bqy5mB+4M0xyHWcdnaTSLwLt4vw7Rvavgj1EoKodWkmQVhOhZucDN6ot4HUoD+cIWUzsqPTs oNyo6vdjzQ6YC7Heg3Xf7O1TOd6dyOjbt9sz1Rg5CwID7v/4Skp+OGHtX+PO9ohQIiXCDPFaoSYz nEg8cm3mNj/eQ9Rf8slDFxImJx8HRciQBn5CZuM7jUXIESohoO51xWmU8XmoKv0qWzSPQBdUf5rN cHBPb3MfmjcMAMKa0UD78CwhUcc1CLaKS8FbQYND37q0mVBCFDdxe1OpmDrNi/715+xpsPTUeAEG s8bczOu9BRGTcyi3n1f5XkuzD1amTGkbiwzYc1X3WAFlD/U9uzx6jrhM3CX+EMngeOWzKGDI8fge AFcJHDoC8QjsQbcDGhScKRKTK22PgXx4+M1NIH1Oyn8= X-Report-Abuse-To: spam@node04.secure-mailgate.com X-Spam-Status: No, score=-5.8 required=5.0 tests=BAYES_00, BODY_8BITS, FOREIGN_BODY1, GIT_PATCH_0, HTML_MESSAGE, JMQ_SPF_NEUTRAL, KAM_DMARC_STATUS, NICE_REPLY_A, SPF_HELO_NONE, SPF_PASS, TXREP, T_FILL_THIS_FORM_SHORT autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit X-Content-Filtered-By: Mailman/MimeDel 2.1.29 X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 09 Apr 2021 19:34:45 -0000 hi Luis, here is the status of the updates. Kind Regards Zied Guermazi On 06.04.21 15:09, Luis Machado wrote: > On 4/4/21 4:30 PM, Zied Guermazi wrote: >> hi Luis >> >> thanks for your review comments. Here is the status of the updates. >> The changes will be published in next version of the patch set. >> >> /Zied >> >> On 01.04.21 15:34, Luis Machado wrote: >>> On 3/30/21 11:52 PM, Zied Guermazi wrote: >>>> diff --git a/gdb/testsuite/gdb.btrace/buffer-size.exp >>>> b/gdb/testsuite/gdb.btrace/buffer-size.exp >>>> index ea4e36c1593..77d7b77852a 100644 >>>> --- a/gdb/testsuite/gdb.btrace/buffer-size.exp >>>> +++ b/gdb/testsuite/gdb.btrace/buffer-size.exp >>>> @@ -32,10 +32,17 @@ if ![runto_main] { >>>>       return -1 >>>>   } >>>>   -gdb_test_no_output "set record btrace bts buffer-size 1" >>>> -gdb_test_no_output "set record btrace pt buffer-size 1" >>>> -gdb_test "show record btrace bts buffer-size" "The record/replay >>>> bts buffer size is 1\.\r" >>>> -gdb_test "show record btrace pt buffer-size" "The record/replay pt >>>> buffer size is 1\.\r" >>>> +if { [istarget "i?86-*-*"] || [istarget "x86_64-*-*"]} { >>>> +    gdb_test_no_output "set record btrace bts buffer-size 1" >>>> +    gdb_test_no_output "set record btrace pt buffer-size 1" >>>> +    gdb_test "show record btrace bts buffer-size" "The >>>> record/replay bts buffer size is 1\.\r" >>>> +    gdb_test "show record btrace pt buffer-size" "The >>>> record/replay pt buffer size is 1\.\r" >>>> +} >>>> + >>>> +if {[istarget "arm*-*-*"]|| [istarget "aarch64*-*-*"]} { >>>> +    gdb_test_no_output "set record btrace etm buffer-size 1" >>>> +    gdb_test "show record btrace etm buffer-size" "The >>>> record/replay etm buffer size is 1\.\r" >>>> +} >>> >>> To avoid duplication of code, I think we could simplify this by >>> checking for the architecture and then creating a list of the btrace >>> formats we're dealing with. Something like: >>> >>> set btrace_type "" >>> if { [istarget "i?86-*-*"] || [istarget "x86_64-*-*"]} { >>>     set btrace_type { "bts" "pt" } >>> } elseif {[istarget "arm*-*-*"]|| [istarget "aarch64*-*-*"]} { >>>     set btrace_type { "etm" } >>> >>> Then have a for loop over btrace_type entries and write the tests >>> only once... >>> >>> foreach_with_prefix format $btrace_format { >>>     gdb_test_no_output "set record btrace $format buffer-size 1" >>>     gdb_test "show record btrace $format buffer-size" "The >>> record/replay $format buffer size is 1\.\r" >>> } >>> >> [Zied] done. thanks for the hint. >>> I'd apply this to any other cases where it is possible. That way we >>> avoid duplicated code with hardcoded content on them, which tends to >>> be hard to maintain and update. >> [Zied] I did not find other tests with specific btrace format > > There seems to be other cases in the patch. > >>> >>>>     gdb_test_no_output "record btrace" >>>>   gdb_test "info record" [multi_line \ >>>> diff --git a/gdb/testsuite/gdb.btrace/delta.exp >>>> b/gdb/testsuite/gdb.btrace/delta.exp >>>> index 9f6d741c013..2c8bada2065 100644 >>>> --- a/gdb/testsuite/gdb.btrace/delta.exp >>>> +++ b/gdb/testsuite/gdb.btrace/delta.exp >>>> @@ -58,8 +58,18 @@ proc check_trace {} { >>>>       "Recording format: .*" \ >>>>       "Recorded 1 instructions in 1 functions \\\(0 gaps\\\) for .*" \ >>>>       ] >>>> +  if { [istarget "i?86-*-*"] || [istarget "x86_64-*-*"] } { >>>>       gdb_test "record instruction-history /f 1" \ >>>>         "1\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tmov *\\\$0x0,%eax\r" >>>> +  } >>>> +  if { [istarget "arm*-*-*"] } { >>>> +    gdb_test "record instruction-history /f 1" \ >>>> +      "1\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tmovs\tr3, #0\r" >>>> +  } >>>> +  if { [istarget "aarch64*-*-*"]} { >>>> +    gdb_test "record instruction-history /f 1" \ >>>> +      "1\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tmov\tw0, #0x0.*\r" >>>> +  } >>>>     gdb_test "record function-call-history /c 1" "1\tmain" > > Here, for example. You could avoid duplicating the gdb_test invocation > and, instead, set the expected pattern for each architecture. That way > you only need to modify the expected pattern, leaving the gdb_test > invocation intact. > [Zied] Done >>>>   } >>>>   diff --git a/gdb/testsuite/gdb.btrace/instruction_history.exp >>>> b/gdb/testsuite/gdb.btrace/instruction_history.exp >>>> index 403085c083f..76fcadb9ac2 100644 >>>> --- a/gdb/testsuite/gdb.btrace/instruction_history.exp >>>> +++ b/gdb/testsuite/gdb.btrace/instruction_history.exp >>>> @@ -21,8 +21,14 @@ if { [skip_btrace_tests] } { >>>>       unsupported "target does not support record-btrace" >>>>       return -1 >>>>   } >>>> +if { [istarget "i?86-*-*"] || [istarget "x86_64-*-*"] } { >>>> +  standard_testfile instruction_history.c x86-instruction_history.S >>>> +} elseif { [istarget "arm*-*-*"] } { >>>> +  standard_testfile instruction_history.c arm-instruction_history.S >>>> +} elseif { [istarget "aarch64*-*-*"]} { >>>> +  standard_testfile instruction_history.c >>>> aarch64-instruction_history.S >>> >>> Same here. I'd use the conditional blocks to set the prefix for the >>> source file, then call standard_testfile only once. > > As I mentioned before... You could set the prefix depending on the > architecture (x86/arm/aarch64) and only invoke standard_testfile once. [Zied] done > >>> >>>> +} >>>>   -standard_testfile .c .S >>>>   if [prepare_for_testing "failed to prepare" $testfile "$srcfile >>>> $srcfile2" {debug}] { >>>>       return -1 >>>>   } >>>> @@ -68,39 +74,128 @@ if { $traced != 11 } { >>>>   } >>>>     # test that we see the expected instructions >>>> -gdb_test "record instruction-history 3,7" [multi_line \ >>>> +if { [istarget "i?86-*-*"] || [istarget "x86_64-*-*"] } { >>>> +  gdb_test "record instruction-history 3,7" [multi_line \ >>>>       "3\t   0x\[0-9a-f\]+ :\tje 0x\[0-9a-f\]+ >>>> " \ >>>>       "4\t   0x\[0-9a-f\]+ :\tdec %eax" \ >>>>       "5\t   0x\[0-9a-f\]+ :\tjmp 0x\[0-9a-f\]+ >>>> " \ >>>>       "6\t   0x\[0-9a-f\]+ :\tcmp \\\$0x0,%eax" \ >>>>       "7\t   0x\[0-9a-f\]+ :\tje 0x\[0-9a-f\]+ >>>> \r" \ >>>>       ] >>>> +} >>>> +if { [istarget "arm*-*-*"] } { >>>> +  gdb_test "record instruction-history 3,7" [multi_line \ >>>> +    "3\t   0x\[0-9a-f\]+ :\tbeq\t0x\[0-9a-f\]+ " \ >>>> +    "4\t   0x\[0-9a-f\]+ :\tsubs\tr0, r0, #1" \ >>>> +    "5\t   0x\[0-9a-f\]+ :\tb\t0x\[0-9a-f\]+ " \ >>>> +    "6\t   0x\[0-9a-f\]+ :\tcmp\tr0, #0" \ >>>> +    "7\t   0x\[0-9a-f\]+ :\tbeq\t0x\[0-9a-f\]+ >>>> \r" \ >>>> +    ] >>>> +} >>>> +if { [istarget "aarch64*-*-*"]} { >>>> +  gdb_test "record instruction-history 3,7" [multi_line \ >>>> +    "3\t   0x\[0-9a-f\]+ :\tb\.eq\t0x\[0-9a-f\]+ >>>> .*" \ >>>> +    "4\t   0x\[0-9a-f\]+ :\tsubs\tx0, x0, #0x1.*" \ >>>> +    "5\t   0x\[0-9a-f\]+ :\tb\t0x\[0-9a-f\]+ .*" \ >>>> +    "6\t   0x\[0-9a-f\]+ :\tcmp\tx0, #0x0.*" \ >>>> +    "7\t   0x\[0-9a-f\]+ :\tb\.eq\t0x\[0-9a-f\]+ >>>> .*\r" \ >>>> +    ] >>>> +} > > Here as well. Basically, anywhere where you have to differentiate > between x86/arm/aarch64, if possible, try to set patterns and invoke > the commands only once using the pattern contained in a variable set > conditionally. [Zied] done > >>>>   -gdb_test "record instruction-history /f 3,+5" [multi_line \ >>>> +if { [istarget "i?86-*-*"] || [istarget "x86_64-*-*"] } { >>>> +  gdb_test "record instruction-history /f 3,+5" [multi_line \ >>>>       "3\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tje 0x\[0-9a-f\]+ >>>> " \ >>>>       "4\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tdec %eax" \ >>>>       "5\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tjmp 0x\[0-9a-f\]+ >>>> " \ >>>>       "6\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tcmp \\\$0x0,%eax" \ >>>>       "7\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tje 0x\[0-9a-f\]+ >>>> \r" \ >>>>       ] >>>> +} >>>> +if { [istarget "arm*-*-*"] } { >>>> +  gdb_test "record instruction-history /f 3,+5" [multi_line \ >>>> +    "3\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tbeq\t0x\[0-9a-f\]+ " \ >>>> +    "4\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tsubs\tr0, r0, #1" \ >>>> +    "5\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tb\t0x\[0-9a-f\]+ " \ >>>> +    "6\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tcmp\tr0, #0" \ >>>> +    "7\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tbeq\t0x\[0-9a-f\]+ \r" \ >>>> +    ] >>>> +} >>>> +if { [istarget "aarch64*-*-*"]} { >>>> +  gdb_test "record instruction-history /f 3,+5" [multi_line \ >>>> +    "3\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tb\.eq\t0x\[0-9a-f\]+ >>>> .*" \ >>>> +    "4\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tsubs\tx0, x0, #0x1.*" \ >>>> +    "5\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tb\t0x\[0-9a-f\]+ .*" \ >>>> +    "6\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tcmp\tx0, #0x0.*" \ >>>> +    "7\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tb\.eq\t0x\[0-9a-f\]+ >>>> .*\r" \ >>>> +    ] >>>> +} >>>>   -gdb_test "record instruction-history /p 7,-5" [multi_line \ >>>> +if { [istarget "i?86-*-*"] || [istarget "x86_64-*-*"] } { >>>> +  gdb_test "record instruction-history /p 7,-5" [multi_line \ >>>>       "3\t   0x\[0-9a-f\]+ :\tje 0x\[0-9a-f\]+ >>>> " \ >>>>       "4\t   0x\[0-9a-f\]+ :\tdec %eax" \ >>>>       "5\t   0x\[0-9a-f\]+ :\tjmp 0x\[0-9a-f\]+ >>>> " \ >>>>       "6\t   0x\[0-9a-f\]+ :\tcmp \\\$0x0,%eax" \ >>>>       "7\t   0x\[0-9a-f\]+ :\tje 0x\[0-9a-f\]+ >>>> \r" \ >>>>       ] >>>> +} >>>> +if { [istarget "arm*-*-*"] } { >>>> +  gdb_test "record instruction-history /p 7,-5" [multi_line \ >>>> +    "3\t   0x\[0-9a-f\]+ :\tbeq\t0x\[0-9a-f\]+ " \ >>>> +    "4\t   0x\[0-9a-f\]+ :\tsubs\tr0, r0, #1" \ >>>> +    "5\t   0x\[0-9a-f\]+ :\tb\t0x\[0-9a-f\]+ " \ >>>> +    "6\t   0x\[0-9a-f\]+ :\tcmp\tr0, #0" \ >>>> +    "7\t   0x\[0-9a-f\]+ :\tbeq\t0x\[0-9a-f\]+ >>>> \r" \ >>>> +    ] >>>> +} >>>> +if { [istarget "aarch64*-*-*"]} { >>>> +  gdb_test "record instruction-history /p 7,-5" [multi_line \ >>>> +    "3\t   0x\[0-9a-f\]+ :\tb\.eq\t0x\[0-9a-f\]+ >>>> .*" \ >>>> +    "4\t   0x\[0-9a-f\]+ :\tsubs\tx0, x0, #0x1.*" \ >>>> +    "5\t   0x\[0-9a-f\]+ :\tb\t0x\[0-9a-f\]+ .*" \ >>>> +    "6\t   0x\[0-9a-f\]+ :\tcmp\tx0, #0x0.*" \ >>>> +    "7\t   0x\[0-9a-f\]+ :\tb\.eq\t0x\[0-9a-f\]+ >>>> .*\r" \ >>>> +    ] >>>> +} >>>>   -gdb_test "record instruction-history /pf 3,7" [multi_line \ >>>> + >>>> +if { [istarget "i?86-*-*"] || [istarget "x86_64-*-*"] } { >>>> +  gdb_test "record instruction-history /pf 3,7" [multi_line \ >>>>       "3\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tje 0x\[0-9a-f\]+ >>>> " \ >>>>       "4\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tdec %eax" \ >>>>       "5\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tjmp 0x\[0-9a-f\]+ >>>> " \ >>>>       "6\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tcmp \\\$0x0,%eax" \ >>>>       "7\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tje 0x\[0-9a-f\]+ >>>> \r" \ >>>>       ] >>>> +} >>>> +if { [istarget "arm*-*-*"] } { >>>> +  gdb_test "record instruction-history /pf 3,7" [multi_line \ >>>> +    "3\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tbeq\t0x\[0-9a-f\]+ " \ >>>> +    "4\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tsubs\tr0, r0, #1" \ >>>> +    "5\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tb\t0x\[0-9a-f\]+ " \ >>>> +    "6\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tcmp\tr0, #0" \ >>>> +    "7\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tbeq\t0x\[0-9a-f\]+ \r" \ >>>> +    ] >>>> +} >>>> +if { [istarget "aarch64*-*-*"]} { >>>> +  gdb_test "record instruction-history /pf 3,7" [multi_line \ >>>> +    "3\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tb\\.eq\t0x\[0-9a-f\]+ >>>> .*" \ >>>> +    "4\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tsubs\tx0, x0, #0x1.*" \ >>>> +    "5\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tb\t0x\[0-9a-f\]+ .*" \ >>>> +    "6\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tcmp\tx0, #0x0.*" \ >>>> +    "7\t   0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tb\\.eq\t0x\[0-9a-f\]+ >>>> .*\r" \ >>>> +    ] >>>> +} >>>>   -gdb_test "record instruction-history 3,3" "3\t 0x\[0-9a-f\]+ >>>> :\tje     0x\[0-9a-f\]+ \r" >>>> +if { [istarget "i?86-*-*"] || [istarget "x86_64-*-*"] } { >>>> +  gdb_test "record instruction-history 3,3" "3\t 0x\[0-9a-f\]+ >>>> :\tje     0x\[0-9a-f\]+ \r" >>>> +} >>>> +if { [istarget "arm*-*-*"] } { >>>> +  gdb_test "record instruction-history 3,3" "3\t 0x\[0-9a-f\]+ >>>> :\tbeq\t0x\[0-9a-f\]+ \r" >>>> +} >>>> +if { [istarget "aarch64*-*-*"]} { >>>> +  gdb_test "record instruction-history 3,3" "3\t 0x\[0-9a-f\]+ >>>> :\tb\.eq\t0x\[0-9a-f\]+   // b\.none\r" >>>> +} >>>>     # the following tests are checking the iterators >>>>   # to avoid lots of regexps, we just check the number of lines that >>>> diff --git a/gdb/testsuite/gdb.btrace/non-stop.exp >>>> b/gdb/testsuite/gdb.btrace/non-stop.exp >>>> index 40cced7a8bb..58459de5359 100644 >>>> --- a/gdb/testsuite/gdb.btrace/non-stop.exp >>>> +++ b/gdb/testsuite/gdb.btrace/non-stop.exp >>>> @@ -31,6 +31,12 @@ save_vars { GDBFLAGS } { >>>>       clean_restart $testfile >>>>   } >>>>   +if {[istarget "i?86-*-*"] || [istarget "x86_64-*-*"]} { >>>> +    set loop_position 2 >>>> +} elseif {[istarget "arm*-*-*"] || [istarget "aarch64*-*-*"]} { >>>> +    set loop_position 3 >>>> +} >>>> + >>>>   if ![runto_main] { >>>>       untested "failed to run to main" >>>>       return -1 >>>> @@ -111,87 +117,99 @@ gdb_test "thread apply all info rec" ".*" >>>>   gdb_test "info threads" ".*" >>>>     with_test_prefix "navigate" { >>>> -    gdb_test "thread apply 1 record goto 2" "$loop_line" >>>> -    gdb_test "thread apply 2 record goto 4" "$loop_line" >>>> +    gdb_test "thread apply 1 record goto $loop_position" "$loop_line" >>>> +    gdb_test "thread apply 2 record goto [expr {$loop_position + >>>> 2}]" "$loop_line" >>>>       gdb_test "thread apply 1 info record" \ >>>> -        ".*Replay in progress\.  At instruction 2\." "thread 1 at >>>> insn 2" >>>> +        ".*Replay in progress\.  At instruction $loop_position\." >>>> "thread 1 at insn $loop_position" >>>>       gdb_test "thread apply 2 info record" \ >>>> -        ".*Replay in progress\.  At instruction 4\." "thread 2 at >>>> insn 4" >>>> +        ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 2}]\." "thread 2 at insn [expr {$loop_position + >>>> 2}]" >>>>   -    gdb_test "thread apply all record goto 5" "$loop_line" >>>> +    gdb_test "thread apply all record goto [expr {$loop_position + >>>> 3}]" "$loop_line" >>>>       gdb_test "thread apply 1 info record" \ >>>> -        ".*Replay in progress\.  At instruction 5\." "thread 1 at >>>> insn 5" >>>> +        ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 3}]\." "thread 1 at insn [expr {$loop_position + >>>> 3}]" >>>>       gdb_test "thread apply 2 info record" \ >>>> -        ".*Replay in progress\.  At instruction 5\." "thread 2 at >>>> insn 5" >>>> +        ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 3}]\." "thread 2 at insn [expr {$loop_position + >>>> 3}]" >>>>   } >>>>     with_test_prefix "step" { >>>> +    with_test_prefix "fixture" { >>>> +    gdb_test "thread apply 1 record goto [expr {$loop_position + >>>> 3}]" ".*" >>>> +    gdb_test "thread apply 2 record goto [expr {$loop_position + >>>> 3}]" ".*" >>>> +    } >>>>       with_test_prefix "thread 1" { >>>>           gdb_test "thread apply 1 stepi 2" "$loop_line" >>>>           gdb_test "thread apply 1 info record" \ >>>> -            ".*Replay in progress\.  At instruction 7\." >>>> +            ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 5}]\." >>>>           gdb_test "thread apply 2 info record" \ >>>> -            ".*Replay in progress\.  At instruction 5\." >>>> +            ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 3}]\." >>>>       } >>>>         with_test_prefix "thread 2" { >>>>           gdb_test "thread apply 2 stepi 3" "$loop_line" >>>>           gdb_test "thread apply 1 info record" \ >>>> -            ".*Replay in progress\.  At instruction 7\." >>>> +            ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 5}]\." >>>>           gdb_test "thread apply 2 info record" \ >>>> -            ".*Replay in progress\.  At instruction 8\." >>>> +            ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 6}]\." >>>>       } >>>>         with_test_prefix "all" { >>>>           gdb_cont_to all "stepi 4" "$loop_line" 2 >>>>           gdb_test "thread apply 1 info record" \ >>>> -            ".*Replay in progress\.  At instruction 11\." >>>> +            ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 9}]\." >>>>           gdb_test "thread apply 2 info record" \ >>>> -            ".*Replay in progress\.  At instruction 12\." >>>> +            ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 10}]\." >>>>       } >>>>   } >>>>     with_test_prefix "reverse-step" { >>>> +    with_test_prefix "fixture" { >>>> +        gdb_test "thread apply 1 record goto [expr {$loop_position >>>> + 9}]" ".*" >>>> +        gdb_test "thread apply 2 record goto [expr {$loop_position >>>> + 10}]" ".*" >>>> +    } >>>>       with_test_prefix "thread 1" { >>>>           gdb_test "thread apply 1 reverse-stepi 2" "$loop_line" >>>>           gdb_test "thread apply 1 info record" \ >>>> -            ".*Replay in progress\.  At instruction 9\." >>>> +            ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 7}]\." >>>>           gdb_test "thread apply 2 info record" \ >>>> -            ".*Replay in progress\.  At instruction 12\." >>>> +            ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 10}]\." >>>>       } >>>>         with_test_prefix "thread 2" { >>>>           gdb_test "thread apply 2 reverse-stepi 3" "$loop_line" >>>>           gdb_test "thread apply 1 info record" \ >>>> -            ".*Replay in progress\.  At instruction 9\." >>>> +            ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 7}]\." >>>>           gdb_test "thread apply 2 info record" \ >>>> -            ".*Replay in progress\.  At instruction 9\." >>>> +            ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 7}]\." >>>>       } >>>>         with_test_prefix "all" { >>>>           gdb_cont_to all "reverse-stepi 4" "$loop_line" 2 >>>>           gdb_test "thread apply 1 info record" \ >>>> -            ".*Replay in progress\.  At instruction 5\." >>>> +            ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 3}]\." >>>>           gdb_test "thread apply 2 info record" \ >>>> -            ".*Replay in progress\.  At instruction 5\." >>>> +            ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 3}]\." >>>>       } >>>>   } >>>>     with_test_prefix "continue" { >>>> +    with_test_prefix "fixture" { >>>> +    gdb_test "thread apply 1 record goto [expr {$loop_position + >>>> 3}]" ".*" >>>> +    gdb_test "thread apply 2 record goto [expr {$loop_position + >>>> 3}]" ".*" >>>> +    } >>>>       with_test_prefix "thread 1" { >>>>       with_test_prefix "continue" { >>>>           gdb_cont_to_no_history 1 "continue" 1 >>>>           gdb_test "thread apply 1 info record" \ >>>>           ".*Recorded \[0-9\]+ instructions \[^\\\r\\\n\]*" >>>>           gdb_test "thread apply 2 info record" \ >>>> -        ".*Replay in progress\.  At instruction 5\." >>>> +        ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 3}]\." >>>>       } >>>>       with_test_prefix "reverse-continue" { >>>>           gdb_cont_to_no_history 1 "reverse-continue" 1 >>>>           gdb_test "thread apply 1 info record" \ >>>>           ".*Replay in progress\.  At instruction 1\." >>>>           gdb_test "thread apply 2 info record" \ >>>> -        ".*Replay in progress\.  At instruction 5\." >>>> +        ".*Replay in progress\.  At instruction [expr >>>> {$loop_position + 3}]\." >>>>       } >>>>       } >>>>   diff --git a/gdb/testsuite/gdb.btrace/record_goto.exp >>>> b/gdb/testsuite/gdb.btrace/record_goto.exp >>>> index 75d76da1c7f..a04983a4859 100644 >>>> --- a/gdb/testsuite/gdb.btrace/record_goto.exp >>>> +++ b/gdb/testsuite/gdb.btrace/record_goto.exp >>>> @@ -41,6 +41,10 @@ if [info exists COMPILE] { >>>>       } else { >>>>           standard_testfile i686-record_goto.S >>>>       } >>>> +} elseif {[istarget "arm*-*-*"]} { >>>> +    standard_testfile arm-record_goto.S >>>> +} elseif {[istarget "aarch64*-*-*"]} { >>>> +    standard_testfile aarch64-record_goto.S >>>>   } else { >>>>       unsupported "target architecture not supported" >>>>       return -1 >>>> @@ -50,6 +54,126 @@ if [prepare_for_testing "failed to prepare" >>>> $testfile $srcfile $opts] { >>>>       return -1 >>>>   } >>>>   +if {[istarget "i?86-*-*"] || [istarget "x86_64-*-*"]} { >>>> +    set function_positions(0) 19 >>>> +    set function_positions(1) 27 >>>> +    set function_positions(2) 2 >>>> +    set function_positions(end) 40 >>>> +    set function_positions(3) 39 >>>> + >>>> +    set sequence_begin(1) 1 >>>> +    set sequence_end(1) 1 >>>> +    set sequence_begin(2) 2 >>>> +    set sequence_end(2) 4 >>>> +    set sequence_begin(3) 5 >>>> +    set sequence_end(3) 8 >>>> +    set sequence_begin(4) 9 >>>> +    set sequence_end(4) 9 >>>> +    set sequence_begin(5) 10 >>>> +    set sequence_end(5) 12 >>>> +    set sequence_begin(6) 13 >>>> +    set sequence_end(6) 16 >>>> +    set sequence_begin(7) 17 >>>> +    set sequence_end(7) 18 >>>> +    set sequence_begin(8) 19 >>>> +    set sequence_end(8) 19 >>>> +    set sequence_begin(9) 20 >>>> +    set sequence_end(9) 22 >>>> +    set sequence_begin(10) 23 >>>> +    set sequence_end(10) 26 >>>> +    set sequence_begin(11) 27 >>>> +    set sequence_end(11) 27 >>>> +    set sequence_begin(12) 28 >>>> +    set sequence_end(12) 30 >>>> +    set sequence_begin(13) 31 >>>> +    set sequence_end(13) 34 >>>> +    set sequence_begin(14) 35 >>>> +    set sequence_end(14) 36 >>>> +    set sequence_begin(15) 37 >>>> +    set sequence_end(15) 38 >>>> +    set sequence_begin(16) 39 >>>> +    set sequence_end(16) 40 >>>> + >>>> +} elseif {[istarget "arm*-*-*"]} { >>>> +    set function_positions(0) 23 >>>> +    set function_positions(1) 33 >>>> +    set function_positions(2) 2 >>>> +    set function_positions(end) 48 >>>> +    set function_positions(3) 47 >>>> + >>>> +    set sequence_begin(1) 1 >>>> +    set sequence_end(1) 1 >>>> +    set sequence_begin(2) 2 >>>> +    set sequence_end(2) 4 >>>> +    set sequence_begin(3) 5 >>>> +    set sequence_end(3) 10 >>>> +    set sequence_begin(4) 11 >>>> +    set sequence_end(4) 11 >>>> +    set sequence_begin(5) 12 >>>> +    set sequence_end(5) 14 >>>> +    set sequence_begin(6) 15 >>>> +    set sequence_end(6) 20 >>>> +    set sequence_begin(7) 21 >>>> +    set sequence_end(7) 22 >>>> +    set sequence_begin(8) 23 >>>> +    set sequence_end(8) 23 >>>> +    set sequence_begin(9) 24 >>>> +    set sequence_end(9) 26 >>>> +    set sequence_begin(10) 27 >>>> +    set sequence_end(10) 32 >>>> +    set sequence_begin(11) 33 >>>> +    set sequence_end(11) 33 >>>> +    set sequence_begin(12) 34 >>>> +    set sequence_end(12) 36 >>>> +    set sequence_begin(13) 37 >>>> +    set sequence_end(13) 42 >>>> +    set sequence_begin(14) 43 >>>> +    set sequence_end(14) 44 >>>> +    set sequence_begin(15) 45 >>>> +    set sequence_end(15) 46 >>>> +    set sequence_begin(16) 47 >>>> +    set sequence_end(16) 48 >>>> +} elseif {[istarget "aarch64*-*-*"]} { >>>> +    set function_positions(0) 16 >>>> +    set function_positions(1) 22 >>>> +    set function_positions(2) 2 >>>> +    set function_positions(end) 36 >>>> +    set function_positions(3) 35 >>>> + >>>> +    set sequence_begin(1) 1 >>>> +    set sequence_end(1) 1 >>>> +    set sequence_begin(2) 2 >>>> +    set sequence_end(2) 4 >>>> +    set sequence_begin(3) 5 >>>> +    set sequence_end(3) 6 >>>> +    set sequence_begin(4) 7 >>>> +    set sequence_end(4) 7 >>>> +    set sequence_begin(5) 8 >>>> +    set sequence_end(5) 10 >>>> +    set sequence_begin(6) 11 >>>> +    set sequence_end(6) 12 >>>> +    set sequence_begin(7) 13 >>>> +    set sequence_end(7) 15 >>>> +    set sequence_begin(8) 16 >>>> +    set sequence_end(8) 16 >>>> +    set sequence_begin(9) 17 >>>> +    set sequence_end(9) 19 >>>> +    set sequence_begin(10) 20 >>>> +    set sequence_end(10) 21 >>>> +    set sequence_begin(11) 22 >>>> +    set sequence_end(11) 22 >>>> +    set sequence_begin(12) 23 >>>> +    set sequence_end(12) 25 >>>> +    set sequence_begin(13) 26 >>>> +    set sequence_end(13) 27 >>>> +    set sequence_begin(14) 28 >>>> +    set sequence_end(14) 30 >>>> +    set sequence_begin(15) 31 >>>> +    set sequence_end(15) 33 >>>> +    set sequence_begin(16) 34 >>>> +    set sequence_end(16) 36 >>>> +} >>>> + >>>>   if ![runto_main] { >>>>       untested "failed to run to main" >>>>       return -1 >>>> @@ -65,43 +189,43 @@ gdb_test "next" >>>>     # start by listing all functions >>>>   gdb_test "record function-call-history /ci 1, +20" [multi_line \ >>>> -  "1\tmain\tinst 1,1" \ >>>> -  "2\t  fun4\tinst 2,4" \ >>>> -  "3\t    fun1\tinst 5,8" \ >>>> -  "4\t  fun4\tinst 9,9" \ >>>> -  "5\t    fun2\tinst 10,12" \ >>>> -  "6\t      fun1\tinst 13,16" \ >>>> -  "7\t    fun2\tinst 17,18" \ >>>> -  "8\t  fun4\tinst 19,19" \ >>>> -  "9\t    fun3\tinst 20,22" \ >>>> -  "10\t      fun1\tinst 23,26" \ >>>> -  "11\t    fun3\tinst 27,27" \ >>>> -  "12\t      fun2\tinst 28,30" \ >>>> -  "13\t        fun1\tinst 31,34" \ >>>> -  "14\t      fun2\tinst 35,36" \ >>>> -  "15\t    fun3\tinst 37,38" \ >>>> -  "16\t  fun4\tinst 39,40" \ >>>> +  "1\tmain\tinst $sequence_begin(1),$sequence_end(1)" \ >>>> +  "2\t  fun4\tinst $sequence_begin(2),$sequence_end(2)" \ >>>> +  "3\t    fun1\tinst $sequence_begin(3),$sequence_end(3)" \ >>>> +  "4\t  fun4\tinst $sequence_begin(4),$sequence_end(4)" \ >>>> +  "5\t    fun2\tinst $sequence_begin(5),$sequence_end(5)" \ >>>> +  "6\t      fun1\tinst $sequence_begin(6),$sequence_end(6)" \ >>>> +  "7\t    fun2\tinst $sequence_begin(7),$sequence_end(7)" \ >>>> +  "8\t  fun4\tinst $sequence_begin(8),$sequence_end(8)" \ >>>> +  "9\t    fun3\tinst $sequence_begin(9),$sequence_end(9)" \ >>>> +  "10\t      fun1\tinst $sequence_begin(10),$sequence_end(10)" \ >>>> +  "11\t    fun3\tinst $sequence_begin(11),$sequence_end(11)" \ >>>> +  "12\t      fun2\tinst $sequence_begin(12),$sequence_end(12)" \ >>>> +  "13\t        fun1\tinst $sequence_begin(13),$sequence_end(13)" \ >>>> +  "14\t      fun2\tinst $sequence_begin(14),$sequence_end(14)" \ >>>> +  "15\t    fun3\tinst $sequence_begin(15),$sequence_end(15)" \ >>>> +  "16\t  fun4\tinst $sequence_begin(16),$sequence_end(16)" \ >>>>     ] >>>>     # let's see if we can go back in history >>>> -gdb_test "record goto 19" ".*fun4 \\(\\) at record_goto.c:43.*" >>>> +gdb_test "record goto $function_positions(0)" ".*fun4 \\(\\) at >>>> record_goto.c:43.*" >>>>     # the function call history should start at the new location >>>>   gdb_test "record function-call-history /ci" [multi_line \ >>>> -  "8\t  fun4\tinst 19,19" \ >>>> -  "9\t    fun3\tinst 20,22" \ >>>> -  "10\t      fun1\tinst 23,26" \ >>>> -  ] "function-call-history from 19 forwards" >>>> +  "8\t  fun4\tinst $sequence_begin(8),$sequence_end(8)" \ >>>> +  "9\t    fun3\tinst $sequence_begin(9),$sequence_end(9)" \ >>>> +  "10\t      fun1\tinst $sequence_begin(10),$sequence_end(10)" \ >>>> +  ] "function-call-history from $function_positions(0) forwards" >>>>     # the instruction history should start at the new location >>>>   gdb_test "record instruction-history" [multi_line \ >>>> -  "19.*" \ >>>> -  "20.*" \ >>>> -  "21.*" \ >>>> -  ] "instruction-history from 19 forwards" >>>> +  "$function_positions(0).*" \ >>>> +  "[expr {$function_positions(0) + 1}].*" \ >>>> +  "[expr {$function_positions(0) + 2}].*" \ >>>> +  ] "instruction-history from $function_positions(0) forwards" >>>>     # let's go to another place in the history >>>> -gdb_test "record goto 27" ".*fun3 \\(\\) at record_goto.c:35.*" >>>> +gdb_test "record goto $function_positions(1)" ".*fun3 \\(\\) at >>>> record_goto.c:35.*" >>>>     # check the back trace at that location >>>>   gdb_test "backtrace" [multi_line \ >>>> @@ -117,26 +241,26 @@ gdb_test "up" ".*main.*at record_goto.c:49.*" >>>> "up to main" >>>>     # the function call history should start at the new location >>>>   gdb_test "record function-call-history /ci -" [multi_line \ >>>> -  "9\t    fun3\tinst 20,22" \ >>>> -  "10\t      fun1\tinst 23,26" \ >>>> -  "11\t    fun3\tinst 27,27" \ >>>> -  ] "function-call-history from 27 backwards" >>>> +  "9\t    fun3\tinst $sequence_begin(9),$sequence_end(9)" \ >>>> +  "10\t      fun1\tinst $sequence_begin(10),$sequence_end(10)" \ >>>> +  "11\t    fun3\tinst $sequence_begin(11),$sequence_end(11)" \ >>>> +  ] "function-call-history from $function_positions(1) backwards" >>>>     # the instruction history should start at the new location >>>>   gdb_test "record instruction-history -" [multi_line \ >>>> -  "25.*" \ >>>> -  "26.*" \ >>>> -  "27.*" \ >>>> -  ] "instruction-history from 27 backwards" >>>> +  "[expr {$function_positions(1) - 2}].*" \ >>>> +  "[expr {$function_positions(1) - 1}].*" \ >>>> +  "$function_positions(1).*" \ >>>> +  ] "instruction-history from $function_positions(1) backwards" >>>>     # test that we can go to the begin of the trace >>>>   gdb_test "record goto begin" ".*main \\(\\) at record_goto.c:49.*" >>>>     # check that we're filling up the context correctly >>>>   gdb_test "record function-call-history /ci -" [multi_line \ >>>> -  "1\tmain\tinst 1,1" \ >>>> -  "2\t  fun4\tinst 2,4" \ >>>> -  "3\t    fun1\tinst 5,8" \ >>>> +  "1\tmain\tinst $sequence_begin(1),$sequence_end(1)" \ >>>> +  "2\t  fun4\tinst $sequence_begin(2),$sequence_end(2)" \ >>>> +  "3\t    fun1\tinst $sequence_begin(3),$sequence_end(3)" \ >>>>     ] "function-call-history from begin backwards" >>>>     # check that we're filling up the context correctly >>>> @@ -147,52 +271,53 @@ gdb_test "record instruction-history -" >>>> [multi_line \ >>>>     ] "instruction-history from begin backwards" >>>>     # we should get the exact same history from the first instruction >>>> -gdb_test "record goto 2" ".*fun4 \\(\\) at record_goto.c:40.*" >>>> +gdb_test "record goto $function_positions(2)" ".*fun4 \\(\\) at >>>> record_goto.c:40.*" >>>>     # check that we're filling up the context correctly >>>>   gdb_test "record function-call-history /ci -" [multi_line \ >>>> -  "1\tmain\tinst 1,1" \ >>>> -  "2\t  fun4\tinst 2,4" \ >>>> -  "3\t    fun1\tinst 5,8\r" \ >>>> -  ] "function-call-history from 2 backwards" >>>> +  "1\tmain\tinst $sequence_begin(1),$sequence_end(1)" \ >>>> +  "2\t  fun4\tinst $sequence_begin(2),$sequence_end(2)" \ >>>> +  "3\t    fun1\tinst $sequence_begin(3),$sequence_end(3)\r" \ >>>> +  ] "function-call-history from $function_positions(2) backwards" >>>>     # check that we're filling up the context correctly >>>>   gdb_test "record instruction-history -" [multi_line \ >>>>     "1.*" \ >>>>     "2.*" \ >>>>     "3.*" \ >>>> -  ] "instruction-history from 2 backwards" >>>> +  ] "instruction-history from $function_positions(2) backwards" >>>>     # check that we can go to the end of the trace >>>>   gdb_test "record goto end" ".*main \\(\\) at record_goto.c:50.*" >>>>     # check that we're filling up the context correctly >>>>   gdb_test "record function-call-history /ci" [multi_line \ >>>> -  "14\t      fun2\tinst 35,36" \ >>>> -  "15\t    fun3\tinst 37,38" \ >>>> -  "16\t  fun4\tinst 39,40" \ >>>> +  "14\t    �� fun2\tinst $sequence_begin(14),$sequence_end(14)" \ >>>> +  "15\t    fun3\tinst $sequence_begin(15),$sequence_end(15)" \ >>>> +  "16\t  fun4\tinst $sequence_begin(16),$sequence_end(16)" \ >>>>     ] "function-call-history from end forwards" >>>>     # check that we're filling up the context correctly >>>> +#adapt it for arm, last instruction is  at pos 48 >>>>   gdb_test "record instruction-history" [multi_line \ >>>> -  "38.*" \ >>>> -  "39.*" \ >>>> -  "40.*\r" \ >>>> +  "[expr {$function_positions(end) - 2}].*" \ >>>> +  "[expr {$function_positions(end) - 1}].*" \ >>>> +  "$function_positions(end).*\r" \ >>>>     ] "instruction-history from end forwards" >>>>     # we should get the exact same history from the second to last >>>> instruction >>>> -gdb_test "record goto 39" ".*fun4 \\(\\) at record_goto.c:44.*" >>>> +gdb_test "record goto $function_positions(3)" ".*fun4 \\(\\) at >>>> record_goto.c:44.*" >>>>     # check that we're filling up the context correctly >>>>   gdb_test "record function-call-history /ci" [multi_line \ >>>> -  "14\t      fun2\tinst 35,36" \ >>>> -  "15\t    fun3\tinst 37,38" \ >>>> -  "16\t  fun4\tinst 39,40\r" \ >>>> -  ] "function-call-history from 39 forwards" >>>> +  "14\t      fun2\tinst $sequence_begin(14),$sequence_end(14)" \ >>>> +  "15\t    fun3\tinst $sequence_begin(15),$sequence_end(15)" \ >>>> +  "16\t  fun4\tinst $sequence_begin(16),$sequence_end(16)\r" \ >>>> +  ] "function-call-history from $function_positions(3) forwards" >>>>     # check that we're filling up the context correctly >>>>   gdb_test "record instruction-history" [multi_line \ >>>> -  "38.*" \ >>>> -  "39.*" \ >>>> -  "40.*\r" \ >>>> -  ] "instruction-history from 39 forwards" >>>> +  "[expr {$function_positions(3) - 1}].*" \ >>>> +  "$function_positions(3).*" \ >>>> +  "[expr {$function_positions(3) + 1}].*\r" \ >>>> +  ] "instruction-history from $function_positions(3) forwards" >>>> diff --git a/gdb/testsuite/gdb.btrace/stepi.exp >>>> b/gdb/testsuite/gdb.btrace/stepi.exp >>>> index bfb680bb30d..5b37d17ba0e 100644 >>>> --- a/gdb/testsuite/gdb.btrace/stepi.exp >>>> +++ b/gdb/testsuite/gdb.btrace/stepi.exp >>>> @@ -39,6 +39,10 @@ if [info exists COMPILE] { >>>>       } else { >>>>           standard_testfile i686-record_goto.S >>>>       } >>>> +} elseif {[istarget "arm*-*-*"]} { >>>> +    standard_testfile arm-record_goto.S >>>> +} elseif {[istarget "aarch64*-*-*"]} { >>>> +    standard_testfile aarch64-record_goto.S >>>>   } else { >>>>       unsupported "target architecture not supported" >>>>       return -1 >>>> @@ -48,6 +52,56 @@ if [prepare_for_testing "failed to prepare" >>>> $testfile $srcfile] { >>>>       return -1 >>>>   } >>>>   +if {[istarget "i?86-*-*"] || [istarget "x86_64-*-*"]} { >>>> +    set instructions_count 40 >>>> +    set instruction_position(0) 39 >>>> +    set instruction_position(1) 40 >>>> +    set instruction_position(2) 1 >>>> +    set instruction_position(3) 1 >>>> +    set instruction_position(4) 22 >>>> +    set instruction_position(5) 23 >>>> +    set instruction_position(6) 22 >>>> +    set instruction_position(7) 27 >>>> +    set instruction_position(8) 22 >>>> +    set instruction_position(9) 1 >>>> +    set instruction_position(10) 1 >>>> +    set instruction_position(11) 1 >>>> +    set instruction_position(12) 2 >>>> +    set instruction_position(13) 1 >>>> +} elseif {[istarget "arm*-*-*"]} { >>>> +    set instructions_count 48 >>>> +    set instruction_position(0) 47 >>>> +    set instruction_position(1) 48 >>>> +    set instruction_position(2) 1 >>>> +    set instruction_position(3) 1 >>>> +    set instruction_position(4) 26 >>>> +    set instruction_position(5) 27 >>>> +    set instruction_position(6) 26 >>>> +    set instruction_position(7) 33 >>>> +    set instruction_position(8) 26 >>>> +    set instruction_position(9) 1 >>>> +    set instruction_position(10) 1 >>>> +    set instruction_position(11) 1 >>>> +    set instruction_position(12) 2 >>>> +    set instruction_position(13) 1 >>>> +} elseif {[istarget "aarch64*-*-*"]} { >>>> +    set instructions_count 36 >>>> +    set instruction_position(0) 35 >>>> +    set instruction_position(1) 36 >>>> +    set instruction_position(2) 1 >>>> +    set instruction_position(3) 1 >>>> +    set instruction_position(4) 19 >>>> +    set instruction_position(5) 20 >>>> +    set instruction_position(6) 19 >>>> +    set instruction_position(7) 22 >>>> +    set instruction_position(8) 19 >>>> +    set instruction_position(9) 1 >>>> +    set instruction_position(10) 1 >>>> +    set instruction_position(11) 1 >>>> +    set instruction_position(12) 2 >>>> +    set instruction_position(13) 1 >>>> +} >>>> + >>>>   if ![runto_main] { >>>>       untested "failed to run to main" >>>>       return -1 >>>> @@ -56,10 +110,11 @@ if ![runto_main] { >>>>   global gdb_prompt >>>>     proc check_replay_at { insn } { >>>> +  global instructions_count >>>>     gdb_test "info record" [multi_line \ >>>>       "Active record target: record-btrace" \ >>>>       ".*" \ >>>> -    "Recorded 40 instructions in 16 functions \\\(0 gaps\\\) for >>>> .*" \ >>>> +    "Recorded $instructions_count instructions in 16 functions >>>> \\\(0 gaps\\\) for .*" \ >>>>       "Replay in progress\.  At instruction $insn\." \ >>>>       ] "check replay at $insn" >>>>   } >>>> @@ -74,15 +129,14 @@ with_test_prefix "record" { >>>>   with_test_prefix "fetch" { >>>>       gdb_test "reverse-stepi" ".*fun4\.5.*" "reverse-stepi.1" >>>>       gdb_test "reverse-stepi" ".*fun4\.5.*" "reverse-stepi.2" >>>> - >>>>       # let's check where we are in the trace >>>> -    check_replay_at 39 >>>> +    check_replay_at $instruction_position(0) >>>>   } >>>>     # let's step forward and check again >>>>   with_test_prefix "stepi" { >>>>       gdb_test "stepi" ".*fun4\.5.*" >>>> -    check_replay_at 40 >>>> +    check_replay_at $instruction_position(1) >>>>   } >>>>     # with the next step, we stop replaying >>>> @@ -91,14 +145,17 @@ with_test_prefix "end" { >>>>       gdb_test "info record" [multi_line \ >>>>         "Active record target: record-btrace" \ >>>>         ".*" \ >>>> -      "Recorded 40 instructions in 16 functions \\\(0 gaps\\\) for >>>> \[^\\\r\\\n\]*" \ >>>> +      "Recorded $instructions_count instructions in 16 functions >>>> \\\(0 gaps\\\) for \[^\\\r\\\n\]*" \ >>>>     ] >>>>   } >>>>   +#recover from a missing lr register in arm >>>> +gdb_test "record goto end" >>>> + >>>>   # let's try nexti >>>>   with_test_prefix "reverse-nexti.1" { >>>>       gdb_test "reverse-nexti" ".*main\.2.*" >>>> -    check_replay_at 1 >>>> +    check_replay_at $instruction_position(2) >>>>   } >>>>     # we can't reverse-nexti any further >>>> @@ -106,7 +163,7 @@ with_test_prefix "reverse-nexti.2" { >>>>       gdb_test "reverse-nexti" \ >>>>       "No more reverse-execution history\.\r\n.*main\.2.*" \ >>>>       "reverse-nexti.2" >>>> -    check_replay_at 1 >>>> +    check_replay_at $instruction_position(3) >>>>   } >>>>     # but we can step back again >>>> @@ -115,32 +172,32 @@ with_test_prefix "nexti" { >>>>       gdb_test "info record" [multi_line \ >>>>         "Active record target: record-btrace" \ >>>>         ".*" \ >>>> -      "Recorded 40 instructions in 16 functions \\\(0 gaps\\\) for >>>> \[^\\\r\\\n\]*" \ >>>> +      "Recorded $instructions_count instructions in 16 functions >>>> \\\(0 gaps\\\) for \[^\\\r\\\n\]*" \ >>>>                      ] >>>>   } >>>>     # let's step from a goto position somewhere in the middle >>>>   with_test_prefix "goto" { >>>> -    gdb_test "record goto 22" ".*fun3\.2.*" >>>> -    with_test_prefix "goto 22" { check_replay_at 22 } >>>> +    gdb_test "record goto $instruction_position(4) " ".*fun3\.2.*" >>>> +    with_test_prefix "goto $instruction_position(4) " { >>>> check_replay_at $instruction_position(4)  } >>>>         gdb_test "stepi" ".*fun1\.1.*" "stepi.3" >>>> -    with_test_prefix "stepi to 23" { check_replay_at 23 } >>>> +    with_test_prefix "stepi to $instruction_position(5)" { >>>> check_replay_at $instruction_position(5) } >>>>         gdb_test "reverse-stepi" ".*fun3\.2.*" "reverse-stepi.3" >>>> -    with_test_prefix "reverse-stepi to 22" { check_replay_at 22 } >>>> +    with_test_prefix "reverse-stepi to $instruction_position(6)" { >>>> check_replay_at $instruction_position(6) } >>>>         gdb_test "nexti" ".*fun3\.3.*" >>>> -    with_test_prefix "nexti to 27" { check_replay_at 27 } >>>> +    with_test_prefix "nexti to $instruction_position(7) " { >>>> check_replay_at $instruction_position(7)  } >>>>         gdb_test "reverse-nexti" ".*fun3\.2.*" "reverse-nexti.3" >>>> -    with_test_prefix "reverse-nexti to 22" { check_replay_at 22 } >>>> +    with_test_prefix "reverse-nexti to $instruction_position(8)" { >>>> check_replay_at $instruction_position(8) } >>>>   } >>>>     # let's try to step off the left end >>>>   with_test_prefix "goto begin" { >>>>       gdb_test "record goto begin" ".*main\.2.*" >>>> -    check_replay_at 1 >>>> +    check_replay_at $instruction_position(9) >>>>         with_test_prefix "reverse-stepi" { >>>>       gdb_test "reverse-stepi" \ >>>> @@ -149,7 +206,7 @@ with_test_prefix "goto begin" { >>>>       gdb_test "reverse-stepi" \ >>>>           "No more reverse-execution history\.\r\n.*main\.2.*" \ >>>>           "reverse-stepi.2" >>>> -    check_replay_at 1 >>>> +    check_replay_at $instruction_position(10) >>>>       } >>>>         with_test_prefix "reverse-nexti" { >>>> @@ -159,13 +216,13 @@ with_test_prefix "goto begin" { >>>>       gdb_test "reverse-nexti" \ >>>>           "No more reverse-execution history\.\r\n.*main\.2.*" \ >>>>           "reverse-nexti.2" >>>> -    check_replay_at 1 >>>> +    check_replay_at $instruction_position(11) >>>>       } >>>>         # we can step forward, though >>>>       with_test_prefix "stepi" { >>>>       gdb_test "stepi" ".*fun4\.1.*" >>>> -    check_replay_at 2 >>>> +    check_replay_at $instruction_position(12) >>>>       } >>>>   } >>>>   @@ -178,5 +235,5 @@ with_test_prefix "reverse-stepi" { >>>>       gdb_test "reverse-stepi" \ >>>>       "No more reverse-execution history\.\r\n.*main\.2.*" \ >>>>       "reverse-stepi.3" >>>> -    check_replay_at 1 >>>> +    check_replay_at $instruction_position(13) >>>>   } >>>> diff --git a/gdb/testsuite/gdb.btrace/tailcall-only.exp >>>> b/gdb/testsuite/gdb.btrace/tailcall-only.exp >>>> index 510f90c9d5e..7e449ee38da 100644 >>>> --- a/gdb/testsuite/gdb.btrace/tailcall-only.exp >>>> +++ b/gdb/testsuite/gdb.btrace/tailcall-only.exp >>>> @@ -43,6 +43,10 @@ if [info exists COMPILE] { >>>>       } else { >>>>           standard_testfile i686-tailcall-only.S >>>>       } >>>> +} elseif { [istarget "arm*-*-*"] } { >>>> +  standard_testfile arm-tailcall-only.S >>>> +} elseif {[istarget "aarch64*-*-*"]} { >>>> +  standard_testfile aarch64-tailcall-only.S >>>>   } else { >>>>       unsupported "target architecture not supported" >>>>       return -1 >>>> @@ -62,6 +66,10 @@ gdb_test_no_output "set record >>>> function-call-history-size 0" >>>>     # trace foo >>>>   gdb_test "step" ".*" "prepare for recording" >>>> +# make sure we get out of function epilogue >>>> +if { [istarget "arm*-*-*"] } { >>>> +  gdb_test "stepi" >>>> +} >>>>   gdb_test_no_output "record btrace" >>>>   gdb_test "stepi 4" ".*" "record branch trace" >>>>   diff --git a/gdb/testsuite/gdb.btrace/tailcall.exp >>>> b/gdb/testsuite/gdb.btrace/tailcall.exp >>>> index 07a3ec103f4..602a9ed6fba 100644 >>>> --- a/gdb/testsuite/gdb.btrace/tailcall.exp >>>> +++ b/gdb/testsuite/gdb.btrace/tailcall.exp >>>> @@ -40,6 +40,10 @@ if [info exists COMPILE] { >>>>       } else { >>>>           standard_testfile i686-tailcall.S >>>>       } >>>> +} elseif { [istarget "arm*-*-*"] } { >>>> +  standard_testfile arm-tailcall.S >>>> +} elseif { [istarget "aarch64*-*-*"] } { >>>> +  standard_testfile aarch64-tailcall.S >>>>   } else { >>>>       unsupported "target architecture not supported" >>>>       return -1 >>>> @@ -48,6 +52,20 @@ if [info exists COMPILE] { >>>>   if [prepare_for_testing "failed to prepare" $testfile $srcfile >>>> $opts] { >>>>       return -1 >>>>   } >>>> + >>>> +if {[istarget "i?86-*-*"] || [istarget "x86_64-*-*"]} { >>>> +    set bar_return_line 24 >>>> +    set bar_return_position 4 >>>> +    set main_return_line 38 >>>> +} elseif {[istarget "arm*-*-*"]} { >>>> +    set bar_return_line 24 >>>> +    set bar_return_position 5 >>>> +    set main_return_line 41 >>>> +    } elseif {[istarget "aarch64*-*-*"]} { >>>> +    set bar_return_line 23 >>>> +    set bar_return_position 6 >>>> +    set main_return_line 40 >>>> +} >>> >>> There may be better ways to fetch this information without >>> hardcoding it, through regular expressions and $expect_out. See, for >>> example, gdb.base/step-over-syscall.exp and how it uses $expect_out >>> to extract some bits of information. >>> >>> You could extract this information first and then store it in these >>> variables. If the sources change, then we won't need to update the >>> test again. >>> >>> If it is hardcoded, every time the source changes you need to update >>> the test. >>> >> [Zied] I will appreciate extracting this information from the elf >> file. Problem is that according to the architecture, the last line >> number before the function returns can change slightly. Can you >> please explain further how to use $expect_out to get the line number. > > Extracting from the ELF file is not a good approach. Instead, you > should first run the test, stopping at each of these places of > interest (bar return, main return etc) and record the line number and > position in some way. Using regular expressions you can extract the > line number the program stopped at, for example. Then you do another > run and actually test the btrace functionality. > > If it is not possible to determine some of these fields dynamically, > then using the conditional blocks is an acceptable approach. > > But you should be aware that different compiler versions may generate > different code. So this particular test will only work for this > particular .S file. [Zied] can you please provide an example > >>>>   if ![runto_main] { >>>>       untested "failed to run to main" >>>>       return -1 >>>> @@ -58,7 +76,17 @@ gdb_test_no_output "set record >>>> function-call-history-size 0" >>>>     # trace the call to foo >>>>   gdb_test_no_output "record btrace" >>>> -gdb_test "next 2" >>>> + >>>> +# make sure we get out of function epilogue >>>> +if {[istarget "i?86-*-*"] || [istarget "x86_64-*-*"]} { >>>> +    gdb_test "next 2" >>>> +} elseif {[istarget "arm*-*-*"]} { >>>> +  gdb_test "next 2" >>>> +  gdb_test "stepi" >>>> +} elseif {[istarget "aarch64*-*-*"]} { >>>> +  gdb_test "next" >>>> +  gdb_test "stepi" >>>> +} > > The above will make the test complicated to follow, because it does > something different for different architectures. > > If the program is not stopping at the right location, it is best to > work with breakpoints to force it to stop there instead of playing > with next/stepi calls. > [Zied] it is a bit more complicated. in fact, we should land at the return instruction from the function main (line 41 in tailcall.c). but gdb in aarch64 does not accept to set the breakpoint with following message (gdb) b 41 No line 41 in the current file. Make breakpoint pending on future shared library load? (y or [n]) y Breakpoint 2 (41) pending. >>>>     # show the flat branch trace >>>>   gdb_test "record function-call-history 1" [multi_line \ >>>> @@ -77,11 +105,11 @@ gdb_test "record function-call-history /c 1" >>>> [multi_line \ >>>>     ] "indented" >>>>     # go into bar >>>> -gdb_test "record goto 4" ".*bar \\(\\) at .*tailcall.c:24\r\n.*" >>>> +gdb_test "record goto $bar_return_position" ".*bar \\(\\) at >>>> .*tailcall.c:$bar_return_line\r\n.*" >>>>     # check the backtrace >>>>   gdb_test "backtrace" [multi_line \ >>>> -  "#0.*bar \\(\\) at tailcall.c:24" \ >>>> +  "#0.*bar \\(\\) at tailcall.c:$bar_return_line" \ >>>>     "#1.*foo \\(\\) at tailcall.c:29" \ >>>>     "#2.*main \\(\\) at tailcall.c:37" \ >>>>     "Backtrace stopped: not enough registers or memory available to >>>> unwind further" \ >>>> @@ -93,23 +121,23 @@ gdb_test "up" "#2\[^\r\n\]*main \\(\\) at >>>> tailcall.c:37\r\n.*" "up to main" >>>>   gdb_test "down" "#1\[^\r\n\]*foo \\(\\) at tailcall.c:29\r\n.*" >>>> "down to foo" >>>>     # test stepping into and out of tailcalls. >>>> -gdb_test "finish" "\[^\r\n\]*main \\(\\) at tailcall.c:38\r\n.*" \ >>>> +gdb_test "finish" "\[^\r\n\]*main \\(\\) at >>>> tailcall.c:$main_return_line\r\n.*" \ >>>>       "finish.1" >>>> -gdb_test "reverse-step" "\[^\r\n\]*bar \\(\\) at >>>> tailcall.c:24\r\n.*" \ >>>> +gdb_test "reverse-step" "\[^\r\n\]*bar \\(\\) at >>>> tailcall.c:$bar_return_line\r\n.*" \ >>>>       "reverse-step.1" >>>>   gdb_test "reverse-finish" "\[^\r\n\]*foo \\(\\) at >>>> tailcall.c:29\r\n.*" \ >>>>       "reverse-finish.1" >>>>   gdb_test "reverse-step" "\[^\r\n\]*main \\(\\) at >>>> tailcall.c:37\r\n.*" \ >>>>       "reverse-step.2" >>>> -gdb_test "next" "\[^\r\n\]*38.*" \ >>>> +gdb_test "next" "\[^\r\n\]*$main_return_line.*" \ >>>>       "next.1" >>>>   gdb_test "reverse-next" "\[^\r\n\]*main \\(\\) at >>>> tailcall.c:37\r\n.*" \ >>>>       "reverse-next.1" >>>>   gdb_test "step" "\[^\r\n\]*foo \\(\\) at tailcall.c:29\r\n.*" \ >>>>       "step.1" >>>> -gdb_test "finish" "\[^\r\n\]*main \\(\\) at tailcall.c:38\r\n.*" \ >>>> +gdb_test "finish" "\[^\r\n\]*main \\(\\) at >>>> tailcall.c:$main_return_line\r\n.*" \ >>>>       "finish.2" >>>> -gdb_test "reverse-step" "\[^\r\n\]*bar \\(\\) at >>>> tailcall.c:24\r\n.*" \ >>>> +gdb_test "reverse-step" "\[^\r\n\]*bar \\(\\) at >>>> tailcall.c:$bar_return_line\r\n.*" \ >>>>       "reverse-step.3" >>>> -gdb_test "finish" "\[^\r\n\]*main \\(\\) at tailcall.c:38\r\n.*" \ >>>> +gdb_test "finish" "\[^\r\n\]*main \\(\\) at >>>> tailcall.c:$main_return_line\r\n.*" \ >>>>       "finish.3" >>>> diff --git a/gdb/testsuite/gdb.btrace/instruction_history.S >>>> b/gdb/testsuite/gdb.btrace/x86-instruction_history.S >>>> similarity index 100% >>>> rename from gdb/testsuite/gdb.btrace/instruction_history.S >>>> rename to gdb/testsuite/gdb.btrace/x86-instruction_history.S >>>> diff --git a/gdb/testsuite/lib/gdb.exp b/gdb/testsuite/lib/gdb.exp >>>> index 60f84d22aad..b7b11deab57 100644 >>>> --- a/gdb/testsuite/lib/gdb.exp >>>> +++ b/gdb/testsuite/lib/gdb.exp >>>> @@ -3232,7 +3232,7 @@ gdb_caching_proc skip_btrace_tests { >>>>       global srcdir subdir gdb_prompt inferior_exited_re >>>>         set me "skip_btrace_tests" >>>> -    if { ![istarget "i?86-*-*"] && ![istarget "x86_64-*-*"] } { >>>> +    if { ![istarget "i?86-*-*"] && ![istarget "x86_64-*-*"] && >>>> ![istarget "arm*-*-*"] && ![istarget "aarch64*-*-*"]} { >>>>           verbose "$me:  target does not support btrace, returning >>>> 1" 2 >>>>           return 1 >>>>       } >>>> >>> >> -- *Zied Guermazi* founder Trande UG Leuschnerstraße 2 69469 Weinheim/Germany Mobile: +491722645127 mailto:zied.guermazi@trande.de *Trande UG* Leuschnerstraße 2, D-69469 Weinheim; Telefon: +491722645127 Sitz der Gesellschaft: Weinheim- Registergericht: AG Mannheim HRB 736209 - Geschäftsführung: Zied Guermazi *Confidentiality Note* This message is intended only for the use of the named recipient(s) and may contain confidential and/or privileged information. If you are not the intended recipient, please contact the sender and delete the message. Any unauthorized use of the information contained in this message is prohibited.