From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 23290 invoked by alias); 19 Dec 2013 16:45:47 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 21646 invoked by uid 89); 19 Dec 2013 16:45:32 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-3.3 required=5.0 tests=AWL,BAYES_00,RP_MATCHES_RCVD autolearn=ham version=3.3.2 X-HELO: mga01.intel.com Received: from mga01.intel.com (HELO mga01.intel.com) (192.55.52.88) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 19 Dec 2013 16:45:28 +0000 Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by fmsmga101.fm.intel.com with ESMTP; 19 Dec 2013 08:45:16 -0800 X-ExtLoop1: 1 Received: from irvmail001.ir.intel.com ([163.33.26.43]) by fmsmga002.fm.intel.com with ESMTP; 19 Dec 2013 08:45:02 -0800 Received: from ulvlx001.iul.intel.com (ulvlx001.iul.intel.com [172.28.207.17]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id rBJGj2XK026087; Thu, 19 Dec 2013 16:45:02 GMT Received: from ulvlx001.iul.intel.com (localhost [127.0.0.1]) by ulvlx001.iul.intel.com with ESMTP id rBJGj2dV029907; Thu, 19 Dec 2013 17:45:02 +0100 Received: (from mmetzger@localhost) by ulvlx001.iul.intel.com with œ id rBJGj2uC029903; Thu, 19 Dec 2013 17:45:02 +0100 From: Markus Metzger To: jan.kratochvil@redhat.com, palves@redhat.com Cc: gdb-patches@sourceware.org Subject: [PATCH v9 24/29] record-btrace: add record goto target methods Date: Thu, 19 Dec 2013 16:45:00 -0000 Message-Id: <1387471499-29444-25-git-send-email-markus.t.metzger@intel.com> In-Reply-To: <1387471499-29444-1-git-send-email-markus.t.metzger@intel.com> References: <1387471499-29444-1-git-send-email-markus.t.metzger@intel.com> X-IsSubscribed: yes X-SW-Source: 2013-12/txt/msg00775.txt.bz2 Reviewed-by: Eli Zaretskii 2013-12-19 Markus Metzger * record-btrace.c (record_btrace_set_replay) (record_btrace_goto_begin, record_btrace_goto_end) (record_btrace_goto): New. (init_record_btrace_ops): Initialize them. * NEWS: Announce it. testsuite/ * gdb.btrace/Makefile.in (EXECUTABLES): Add record_goto. * gdb.btrace/record_goto.c: New. * gdb.btrace/record_goto.exp: New. * gdb.btrace/x86-record_goto.S: New. --- gdb/NEWS | 2 + gdb/record-btrace.c | 124 +++++++++- gdb/testsuite/gdb.btrace/Makefile.in | 2 +- gdb/testsuite/gdb.btrace/record_goto.c | 51 +++++ gdb/testsuite/gdb.btrace/record_goto.exp | 170 ++++++++++++++ gdb/testsuite/gdb.btrace/x86-record_goto.S | 355 +++++++++++++++++++++++++++++ 6 files changed, 699 insertions(+), 5 deletions(-) create mode 100644 gdb/testsuite/gdb.btrace/record_goto.c create mode 100644 gdb/testsuite/gdb.btrace/record_goto.exp create mode 100644 gdb/testsuite/gdb.btrace/x86-record_goto.S diff --git a/gdb/NEWS b/gdb/NEWS index da7f97b..1ff2b5a 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -106,6 +106,8 @@ info exceptions REGEXP debugged. If provided, only the exceptions whose names match REGEXP are listed. +* The btrace record target now supports the 'record goto' command. + * New options set debug symfile off|on diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c index f6272b4..1d090e7 100644 --- a/gdb/record-btrace.c +++ b/gdb/record-btrace.c @@ -58,13 +58,13 @@ static int record_btrace_allow_memory_access; /* Update the branch trace for the current thread and return a pointer to its - branch trace information struct. + thread_info. Throws an error if there is no thread or no trace. This function never returns NULL. */ -static struct btrace_thread_info * -require_btrace (void) +static struct thread_info * +require_btrace_thread (void) { struct thread_info *tp; struct btrace_thread_info *btinfo; @@ -82,7 +82,23 @@ require_btrace (void) if (btinfo->begin == NULL) error (_("No trace.")); - return btinfo; + return tp; +} + +/* Update the branch trace for the current thread and return a pointer to its + branch trace information struct. + + Throws an error if there is no thread or no trace. This function never + returns NULL. */ + +static struct btrace_thread_info * +require_btrace (void) +{ + struct thread_info *tp; + + tp = require_btrace_thread (); + + return &tp->btrace; } /* Enable branch tracing for one thread. Warn on errors. */ @@ -1073,6 +1089,103 @@ record_btrace_find_new_threads (struct target_ops *ops) } } +/* Set the replay branch trace instruction iterator. If IT is NULL, replay + is stopped. */ + +static void +record_btrace_set_replay (struct thread_info *tp, + const struct btrace_insn_iterator *it) +{ + struct btrace_thread_info *btinfo; + + btinfo = &tp->btrace; + + if (it == NULL || it->function == NULL) + { + if (btinfo->replay == NULL) + return; + + xfree (btinfo->replay); + btinfo->replay = NULL; + } + else + { + if (btinfo->replay == NULL) + btinfo->replay = xmalloc (sizeof (*btinfo->replay)); + else if (btrace_insn_cmp (btinfo->replay, it) == 0) + return; + + *btinfo->replay = *it; + } + + /* Clear the function call and instruction histories so we start anew + from the new replay position. */ + xfree (btinfo->insn_history); + xfree (btinfo->call_history); + + btinfo->insn_history = NULL; + btinfo->call_history = NULL; + + registers_changed_ptid (tp->ptid); +} + +/* The to_goto_record_begin method of target record-btrace. */ + +static void +record_btrace_goto_begin (void) +{ + struct thread_info *tp; + struct btrace_insn_iterator begin; + + tp = require_btrace_thread (); + + btrace_insn_begin (&begin, &tp->btrace); + record_btrace_set_replay (tp, &begin); + + print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1); +} + +/* The to_goto_record_end method of target record-btrace. */ + +static void +record_btrace_goto_end (void) +{ + struct thread_info *tp; + + tp = require_btrace_thread (); + + record_btrace_set_replay (tp, NULL); + + print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1); +} + +/* The to_goto_record method of target record-btrace. */ + +static void +record_btrace_goto (ULONGEST insn) +{ + struct thread_info *tp; + struct btrace_insn_iterator it; + unsigned int number; + int found; + + number = insn; + + /* Check for wrap-arounds. */ + if (number != insn) + error (_("Instruction number out of range.")); + + tp = require_btrace_thread (); + + found = btrace_find_insn_by_number (&it, &tp->btrace, number); + if (found == 0) + error (_("No such instruction.")); + + record_btrace_set_replay (tp, &it); + + print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1); +} + /* Initialize the record-btrace target ops. */ static void @@ -1110,6 +1223,9 @@ init_record_btrace_ops (void) ops->to_resume = record_btrace_resume; ops->to_wait = record_btrace_wait; ops->to_find_new_threads = record_btrace_find_new_threads; + ops->to_goto_record_begin = record_btrace_goto_begin; + ops->to_goto_record_end = record_btrace_goto_end; + ops->to_goto_record = record_btrace_goto; ops->to_stratum = record_stratum; ops->to_magic = OPS_MAGIC; } diff --git a/gdb/testsuite/gdb.btrace/Makefile.in b/gdb/testsuite/gdb.btrace/Makefile.in index 606de6e..8311cba 100644 --- a/gdb/testsuite/gdb.btrace/Makefile.in +++ b/gdb/testsuite/gdb.btrace/Makefile.in @@ -2,7 +2,7 @@ VPATH = @srcdir@ srcdir = @srcdir@ EXECUTABLES = enable function_call_history instruction_history tailcall \ - exception unknown_functions + exception unknown_functions record_goto MISCELLANEOUS = diff --git a/gdb/testsuite/gdb.btrace/record_goto.c b/gdb/testsuite/gdb.btrace/record_goto.c new file mode 100644 index 0000000..1250708 --- /dev/null +++ b/gdb/testsuite/gdb.btrace/record_goto.c @@ -0,0 +1,51 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2013 Free Software Foundation, Inc. + + Contributed by Intel Corp. + + 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 . */ + +void +fun1 (void) +{ +} + +void +fun2 (void) +{ + fun1 (); +} + +void +fun3 (void) +{ + fun1 (); + fun2 (); +} + +void +fun4 (void) +{ + fun1 (); + fun2 (); + fun3 (); +} + +int +main (void) +{ + fun4 (); + return 0; +} diff --git a/gdb/testsuite/gdb.btrace/record_goto.exp b/gdb/testsuite/gdb.btrace/record_goto.exp new file mode 100644 index 0000000..3775be2 --- /dev/null +++ b/gdb/testsuite/gdb.btrace/record_goto.exp @@ -0,0 +1,170 @@ +# This testcase is part of GDB, the GNU debugger. +# +# Copyright 2013 Free Software Foundation, Inc. +# +# Contributed by Intel Corp. +# +# 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 . + +# check for btrace support +if { [skip_btrace_tests] } { return -1 } + +# start inferior +standard_testfile x86-record_goto.S + +set opts {} +if [info exists COMPILE] { + # make check RUNTESTFLAGS="gdb.btrace/record_goto.exp COMPILE=1" + standard_testfile record_goto.c + lappend opts debug +} elseif { ![istarget x86_64-*-* ] || ![is_lp64_target] } { + verbose "Skipping ${testfile}." + return +} + +if [prepare_for_testing record_goto.exp $testfile $srcfile $opts] { + return -1 +} +if ![runto_main] { + return -1 +} + +# we want a small context sizes to simplify the test +gdb_test_no_output "set record instruction-history-size 3" +gdb_test_no_output "set record function-call-history-size 3" + +# trace the call to the test function +gdb_test_no_output "record btrace" +gdb_test "next" + +# start by listing all functions +gdb_test "record function-call-history /ci 1, +20" [join [list \ + "1\t fun4\tinst 1,3" \ + "2\t fun1\tinst 4,7" \ + "3\t fun4\tinst 8,8" \ + "4\t fun2\tinst 9,11" \ + "5\t fun1\tinst 12,15" \ + "6\t fun2\tinst 16,17" \ + "7\t fun4\tinst 18,18" \ + "8\t fun3\tinst 19,21" \ + "9\t fun1\tinst 22,25" \ + "10\t fun3\tinst 26,26" \ + "11\t fun2\tinst 27,29" \ + "12\t fun1\tinst 30,33" \ + "13\t fun2\tinst 34,35" \ + "14\t fun3\tinst 36,37" \ + "15\t fun4\tinst 38,39" \ + ] "\r\n"] + +# let's see if we can go back in history +gdb_test "record goto 18" ".*fun4 \\(\\) at record_goto.c:43.*" + +# the function call history should start at the new location +gdb_test "record function-call-history /ci" [join [list \ + "7\t fun4\tinst 18,18" \ + "8\t fun3\tinst 19,21" \ + "9\t fun1\tinst 22,25" \ + ] "\r\n"] "function-call-history from 18 forwards" + +# the instruction history should start at the new location +gdb_test "record instruction-history" [join [list \ + "18.*" \ + "19.*" \ + "20.*" \ + ] "\r\n"] "instruction-history from 18 forwards" + +# let's go to another place in the history +gdb_test "record goto 26" ".*fun3 \\(\\) at record_goto.c:35.*" + +# the function call history should start at the new location +gdb_test "record function-call-history /ci -" [join [list \ + "8\t fun3\tinst 19,21" \ + "9\t fun1\tinst 22,25" \ + "10\t fun3\tinst 26,26\r" \ + ] "\r\n"] "function-call-history from 26 backwards" + +# the instruction history should start at the new location +gdb_test "record instruction-history -" [join [list \ + "24.*" \ + "25.*" \ + "26.*\r" \ + ] "\r\n"] "instruction-history from 26 backwards" + +# test that we can go to the begin of the trace +gdb_test "record goto begin" ".*fun4 \\(\\) at record_goto.c:40.*" + +# check that we're filling up the context correctly +gdb_test "record function-call-history /ci -" [join [list \ + "1\t fun4\tinst 1,3" \ + "2\t fun1\tinst 4,7" \ + "3\t fun4\tinst 8,8" \ + ] "\r\n"] "function-call-history from begin backwards" + +# check that we're filling up the context correctly +gdb_test "record instruction-history -" [join [list \ + "1.*" \ + "2.*" \ + "3.*" \ + ] "\r\n"] "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.*" + +# check that we're filling up the context correctly +gdb_test "record function-call-history /ci -" [join [list \ + "1\t fun4\tinst 1,3" \ + "2\t fun1\tinst 4,7" \ + "3\t fun4\tinst 8,8" \ + ] "\r\n"] "function-call-history from 2 backwards" + +# check that we're filling up the context correctly +gdb_test "record instruction-history -" [join [list \ + "1.*" \ + "2.*" \ + "3.*" \ + ] "\r\n"] "instruction-history from 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" [join [list \ + "13\t fun2\tinst 34,35" \ + "14\t fun3\tinst 36,37" \ + "15\t fun4\tinst 38,39" \ + ] "\r\n"] "function-call-history from end forwards" + +# check that we're filling up the context correctly +gdb_test "record instruction-history" [join [list \ + "37.*" \ + "38.*" \ + "39.*" \ + ] "\r\n"] "instruction-history from end forwards" + +# we should get the exact same history from the second to last instruction +gdb_test "record goto 38" ".*fun4 \\(\\) at record_goto.c:44.*" + +# check that we're filling up the context correctly +gdb_test "record function-call-history /ci" [join [list \ + "13\t fun2\tinst 34,35" \ + "14\t fun3\tinst 36,37" \ + "15\t fun4\tinst 38,39" \ + ] "\r\n"] "function-call-history from 38 forwards" + +# check that we're filling up the context correctly +gdb_test "record instruction-history" [join [list \ + "37.*" \ + "38.*" \ + "39.*" \ + ] "\r\n"] "instruction-history from 38 forwards" diff --git a/gdb/testsuite/gdb.btrace/x86-record_goto.S b/gdb/testsuite/gdb.btrace/x86-record_goto.S new file mode 100644 index 0000000..08d1ce7 --- /dev/null +++ b/gdb/testsuite/gdb.btrace/x86-record_goto.S @@ -0,0 +1,355 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2013 Free Software Foundation, Inc. + + Contributed by Intel Corp. + + 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 file has been generated using: + gcc -S -dA -g record_goto.c -o x86-record_goto.S */ + + .file "record_goto.c" + .section .debug_abbrev,"",@progbits +.Ldebug_abbrev0: + .section .debug_info,"",@progbits +.Ldebug_info0: + .section .debug_line,"",@progbits +.Ldebug_line0: + .text +.Ltext0: +.globl fun1 + .type fun1, @function +fun1: +.LFB0: + .file 1 "record_goto.c" + # record_goto.c:22 + .loc 1 22 0 + .cfi_startproc + # basic block 2 + pushq %rbp + .cfi_def_cfa_offset 16 + movq %rsp, %rbp + .cfi_offset 6, -16 + .cfi_def_cfa_register 6 + # record_goto.c:23 + .loc 1 23 0 + leave + .cfi_def_cfa 7, 8 + ret + .cfi_endproc +.LFE0: + .size fun1, .-fun1 +.globl fun2 + .type fun2, @function +fun2: +.LFB1: + # record_goto.c:27 + .loc 1 27 0 + .cfi_startproc + # basic block 2 + pushq %rbp + .cfi_def_cfa_offset 16 + movq %rsp, %rbp + .cfi_offset 6, -16 + .cfi_def_cfa_register 6 + # record_goto.c:28 + .loc 1 28 0 + call fun1 + # record_goto.c:29 + .loc 1 29 0 + leave + .cfi_def_cfa 7, 8 + ret + .cfi_endproc +.LFE1: + .size fun2, .-fun2 +.globl fun3 + .type fun3, @function +fun3: +.LFB2: + # record_goto.c:33 + .loc 1 33 0 + .cfi_startproc + # basic block 2 + pushq %rbp + .cfi_def_cfa_offset 16 + movq %rsp, %rbp + .cfi_offset 6, -16 + .cfi_def_cfa_register 6 + # record_goto.c:34 + .loc 1 34 0 + call fun1 + # record_goto.c:35 + .loc 1 35 0 + call fun2 + # record_goto.c:36 + .loc 1 36 0 + leave + .cfi_def_cfa 7, 8 + ret + .cfi_endproc +.LFE2: + .size fun3, .-fun3 +.globl fun4 + .type fun4, @function +fun4: +.LFB3: + # record_goto.c:40 + .loc 1 40 0 + .cfi_startproc + # basic block 2 + pushq %rbp + .cfi_def_cfa_offset 16 + movq %rsp, %rbp + .cfi_offset 6, -16 + .cfi_def_cfa_register 6 + # record_goto.c:41 + .loc 1 41 0 + call fun1 + # record_goto.c:42 + .loc 1 42 0 + call fun2 + # record_goto.c:43 + .loc 1 43 0 + call fun3 + # record_goto.c:44 + .loc 1 44 0 + leave + .cfi_def_cfa 7, 8 + ret + .cfi_endproc +.LFE3: + .size fun4, .-fun4 +.globl main + .type main, @function +main: +.LFB4: + # record_goto.c:48 + .loc 1 48 0 + .cfi_startproc + # basic block 2 + pushq %rbp + .cfi_def_cfa_offset 16 + movq %rsp, %rbp + .cfi_offset 6, -16 + .cfi_def_cfa_register 6 + # record_goto.c:49 + .loc 1 49 0 + call fun4 + # record_goto.c:50 + .loc 1 50 0 + movl $0, %eax + # record_goto.c:51 + .loc 1 51 0 + leave + .cfi_def_cfa 7, 8 + ret + .cfi_endproc +.LFE4: + .size main, .-main +.Letext0: + .section .debug_info + .long 0xbc # Length of Compilation Unit Info + .value 0x3 # DWARF version number + .long .Ldebug_abbrev0 # Offset Into Abbrev. Section + .byte 0x8 # Pointer Size (in bytes) + .uleb128 0x1 # (DIE (0xb) DW_TAG_compile_unit) + .long .LASF4 # DW_AT_producer: "GNU C 4.4.4 20100726 (Red Hat 4.4.4-13)" + .byte 0x1 # DW_AT_language + .long .LASF5 # DW_AT_name: "record_goto.c" + .long .LASF6 # DW_AT_comp_dir: "" + .quad .Ltext0 # DW_AT_low_pc + .quad .Letext0 # DW_AT_high_pc + .long .Ldebug_line0 # DW_AT_stmt_list + .uleb128 0x2 # (DIE (0x2d) DW_TAG_subprogram) + .byte 0x1 # DW_AT_external + .long .LASF0 # DW_AT_name: "fun1" + .byte 0x1 # DW_AT_decl_file (record_goto.c) + .byte 0x15 # DW_AT_decl_line + .byte 0x1 # DW_AT_prototyped + .quad .LFB0 # DW_AT_low_pc + .quad .LFE0 # DW_AT_high_pc + .byte 0x1 # DW_AT_frame_base + .byte 0x9c # DW_OP_call_frame_cfa + .uleb128 0x2 # (DIE (0x48) DW_TAG_subprogram) + .byte 0x1 # DW_AT_external + .long .LASF1 # DW_AT_name: "fun2" + .byte 0x1 # DW_AT_decl_file (record_goto.c) + .byte 0x1a # DW_AT_decl_line + .byte 0x1 # DW_AT_prototyped + .quad .LFB1 # DW_AT_low_pc + .quad .LFE1 # DW_AT_high_pc + .byte 0x1 # DW_AT_frame_base + .byte 0x9c # DW_OP_call_frame_cfa + .uleb128 0x2 # (DIE (0x63) DW_TAG_subprogram) + .byte 0x1 # DW_AT_external + .long .LASF2 # DW_AT_name: "fun3" + .byte 0x1 # DW_AT_decl_file (record_goto.c) + .byte 0x20 # DW_AT_decl_line + .byte 0x1 # DW_AT_prototyped + .quad .LFB2 # DW_AT_low_pc + .quad .LFE2 # DW_AT_high_pc + .byte 0x1 # DW_AT_frame_base + .byte 0x9c # DW_OP_call_frame_cfa + .uleb128 0x2 # (DIE (0x7e) DW_TAG_subprogram) + .byte 0x1 # DW_AT_external + .long .LASF3 # DW_AT_name: "fun4" + .byte 0x1 # DW_AT_decl_file (record_goto.c) + .byte 0x27 # DW_AT_decl_line + .byte 0x1 # DW_AT_prototyped + .quad .LFB3 # DW_AT_low_pc + .quad .LFE3 # DW_AT_high_pc + .byte 0x1 # DW_AT_frame_base + .byte 0x9c # DW_OP_call_frame_cfa + .uleb128 0x3 # (DIE (0x99) DW_TAG_subprogram) + .byte 0x1 # DW_AT_external + .long .LASF7 # DW_AT_name: "main" + .byte 0x1 # DW_AT_decl_file (record_goto.c) + .byte 0x2f # DW_AT_decl_line + .byte 0x1 # DW_AT_prototyped + .long 0xb8 # DW_AT_type + .quad .LFB4 # DW_AT_low_pc + .quad .LFE4 # DW_AT_high_pc + .byte 0x1 # DW_AT_frame_base + .byte 0x9c # DW_OP_call_frame_cfa + .uleb128 0x4 # (DIE (0xb8) DW_TAG_base_type) + .byte 0x4 # DW_AT_byte_size + .byte 0x5 # DW_AT_encoding + .ascii "int\0" # DW_AT_name + .byte 0x0 # 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 0x0 + .byte 0x0 + .uleb128 0x2 # (abbrev code) + .uleb128 0x2e # (TAG: DW_TAG_subprogram) + .byte 0x0 # DW_children_no + .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 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 0xa # (DW_FORM_block1) + .byte 0x0 + .byte 0x0 + .uleb128 0x3 # (abbrev code) + .uleb128 0x2e # (TAG: DW_TAG_subprogram) + .byte 0x0 # DW_children_no + .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 0xa # (DW_FORM_block1) + .byte 0x0 + .byte 0x0 + .uleb128 0x4 # (abbrev code) + .uleb128 0x24 # (TAG: DW_TAG_base_type) + .byte 0x0 # 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 0x0 + .byte 0x0 + .byte 0x0 + .section .debug_pubnames,"",@progbits + .long 0x3b # Length of Public Names Info + .value 0x2 # DWARF Version + .long .Ldebug_info0 # Offset of Compilation Unit Info + .long 0xc0 # Compilation Unit Length + .long 0x2d # DIE offset + .ascii "fun1\0" # external name + .long 0x48 # DIE offset + .ascii "fun2\0" # external name + .long 0x63 # DIE offset + .ascii "fun3\0" # external name + .long 0x7e # DIE offset + .ascii "fun4\0" # external name + .long 0x99 # DIE offset + .ascii "main\0" # external name + .long 0x0 + .section .debug_aranges,"",@progbits + .long 0x2c # Length of Address Ranges Info + .value 0x2 # DWARF Version + .long .Ldebug_info0 # Offset of Compilation Unit Info + .byte 0x8 # Size of Address + .byte 0x0 # Size of Segment Descriptor + .value 0x0 # Pad to 16 byte boundary + .value 0x0 + .quad .Ltext0 # Address + .quad .Letext0-.Ltext0 # Length + .quad 0x0 + .quad 0x0 + .section .debug_str,"MS",@progbits,1 +.LASF3: + .string "fun4" +.LASF5: + .string "record_goto.c" +.LASF4: + .string "GNU C 4.4.4 20100726 (Red Hat 4.4.4-13)" +.LASF7: + .string "main" +.LASF1: + .string "fun2" +.LASF0: + .string "fun1" +.LASF6: + .string "" +.LASF2: + .string "fun3" + .ident "GCC: (GNU) 4.4.4 20100726 (Red Hat 4.4.4-13)" + .section .note.GNU-stack,"",@progbits -- 1.8.3.1