From patchwork Sat Aug 12 08:30:09 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Simon Marchi X-Patchwork-Id: 22109 Received: (qmail 106982 invoked by alias); 12 Aug 2017 08:31:30 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 106643 invoked by uid 89); 12 Aug 2017 08:31:04 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.4 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_SORBS_WEB, SPF_PASS autolearn=ham version=3.3.2 spammy=Reporting, 34207, 1458, *status X-HELO: sessmg22.ericsson.net Received: from sessmg22.ericsson.net (HELO sessmg22.ericsson.net) (193.180.251.58) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 12 Aug 2017 08:30:54 +0000 Received: from ESESSHC018.ericsson.se (Unknown_Domain [153.88.183.72]) by sessmg22.ericsson.net (Symantec Mail Security) with SMTP id 04.63.20899.2BCBE895; Sat, 12 Aug 2017 10:30:42 +0200 (CEST) Received: from EUR01-VE1-obe.outbound.protection.outlook.com (153.88.183.145) by oa.msg.ericsson.com (153.88.183.72) with Microsoft SMTP Server (TLS) id 14.3.352.0; Sat, 12 Aug 2017 10:30:21 +0200 Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=simon.marchi@ericsson.com; Received: from elxacz23q12.localdomain (62.119.166.1) by AM3PR07MB308.eurprd07.prod.outlook.com (2a01:111:e400:881b::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P256) id 15.1.1341.9; Sat, 12 Aug 2017 08:30:19 +0000 From: Simon Marchi To: CC: Simon Marchi Subject: [PATCH] Make target_waitstatus_to_string return an std::string Date: Sat, 12 Aug 2017 10:30:09 +0200 Message-ID: <1502526609-31934-1-git-send-email-simon.marchi@ericsson.com> MIME-Version: 1.0 X-ClientProxiedBy: HE1P189CA0025.EURP189.PROD.OUTLOOK.COM (2603:10a6:7:53::38) To AM3PR07MB308.eurprd07.prod.outlook.com (2a01:111:e400:881b::19) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 5dac69a3-2a49-4c28-d509-08d4e15c5de3 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(300000500095)(300135000095)(300000501095)(300135300095)(300000502095)(300135100095)(22001)(2017030254152)(300000503095)(300135400095)(201703131423075)(201703031133081)(201702281549075)(300000504095)(300135200095)(300000505095)(300135600095)(300000506095)(300135500095); SRVR:AM3PR07MB308; X-Microsoft-Exchange-Diagnostics: 1; AM3PR07MB308; 3:1Lg+9JkJR8uG9jQfiW9x6m3Dbf6VQVBRanH77P3deJg52qmbUC0Qtd/qBwh6yk2I4nIcQ229wTBfy+9nB+qhNoTdwzqilPvaqX3qJvetMeWQytEHBIKblfvzDlAJUUikXTzBunDISt5NL84cSDzIHBfFl0IVEn6FlzEyzSFl83A/1U8U/xXTj6bdIFMCTiLux/384QJLK9ESjY0zqoxczkKmGc1a/+MXZ+UDCRIwA2LG7DtZi7ekw2ddx+FBwfnF; 25:hTV6miI+DgD8nE5hpFMK/v382QtBVJpC+XYxlLTOW8BdyZqpdoifiwVbh4PVoTEFaHXHsPudG7GJmFKtnheFPq45tzIWFofahh6hOioHo7nJ+dZbhB4vSRP/ii5gN1S7TzLRYRPr6SbD8Z6byuThtZp5385SjKEwKYCRJ9OK4zSh257hSjs+sN215yeOK7lRnGsMxtPz26oSS2yMpYmZqlOr0GtzFu+Dzn1YQIDMZAPLyewEMbwr8QgA23sme76z/U/56j61HMi/hkicOKEsgBuaj6bQ+JOHsAAbyZmY6B+GNP6N+eT1E9kQtOCaxN/bv4M/Y5L+PKjIvhhxXh1uBQ==; 31:y5v7jAVE1w4BO1nqMD7bgcNKWn8r8LQO0OqAf5Cuhqylx/Xz6ZLcx1cHY/kfRPuByCdXfQ39Wf7aawhF6ptLkTdhbv0lbfNOOkdxh/a6x5p32otHg9O4X+nQLFuYWlpy8+QSeA0guIpueLBW/tFOhY/e2G/4g8RKM/Icy3ShZA2KvQNs3tETCclPAHdLvQwNmSzGMM0aVDr+EYe1ASSgPj2uoFuk55w0WwTn4WH7tOA= X-MS-TrafficTypeDiagnostic: AM3PR07MB308: X-Microsoft-Exchange-Diagnostics: 1; AM3PR07MB308; 20:nvNdHtuDUjchC9ycD4VMAScLIuhBTGyo2elU4PmGA2bXhBzmYb0SPNYIN+gBu19+o8QCfdyO2iA2EGZ+heuSVcN/qencd3xezjmEgLZ69mK5ybsokKaumlDvX4r+1WLcJQJoFJK9U5KFbqj5m39nTJwO5vUGHGodhVb1ccEQ8JJhxCyVwNrjhHW+hFN7oH2J7OWvSyEGyF13FTIJDKPLNh4QG+Q8xCWl5rQ/yGL6FnJrWdM8DQZlQnOPVTusjaJVEi0idOwt3ms3Lj8vTXgRdo7hqCbESPSAHg5e4/iwAzXl0Ru32jd7RLl+ogqmPvneF/ihp9C8Aq5I/c/J7C1ouYVqRPEYVpF3qAh0e/Pz9+3axBiFHnVvxbyDhc7R3iosl7+ks7d37MLtihQ/jWK4miVcA4+tg5nfJ5y/vXTwflL7Dvq2qXqkA3FAwab0y/QvHlMIKeoor65qnIcUuJPyFWPrEsMjADmpCZP4fJdHyVAvDjJ97Cb/Jye9kyOeCsf4; 4:yLG3opkI85zFwBGwvbXoj9mgKiU2HAd3D0qZv6Q5DInAiol9LNi768WJOZJLdR8QEGQ2qcDVXJrdU0DqkiJzJLj/NC5Lu4NqdwmXjDHIqfLkJbjXq3gk8VtJmHgNtxvdDeK34KThc899sOucAW88SnpBmwRcjqlQF6EEaBO3QU77AxtVcYbLUB5K910fW1BXAEoMMIUC4mC7G4BvSFMtqRdcWc5mc7u/JaYfd482lp1bISuU3ZCxmxPLfuzdSh1GR+4dIFKpultXU66rtlrgzcfQ+BPBniQWFsRTBDuiJ0Y= X-Exchange-Antispam-Report-Test: UriScan:(211171220733660); X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(100000700101)(100105000095)(100000701101)(100105300095)(100000702101)(100105100095)(6040450)(601004)(2401047)(5005006)(8121501046)(10201501046)(3002001)(93006095)(93001095)(100000703101)(100105400095)(6041248)(20161123555025)(20161123558100)(201703131423075)(201702281528075)(201703061421075)(201703061406153)(20161123560025)(20161123564025)(20161123562025)(6072148)(201708071742011)(100000704101)(100105200095)(100000705101)(100105500095); SRVR:AM3PR07MB308; BCL:0; PCL:0; RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(100000804101)(100110200095)(100000805101)(100110500095); SRVR:AM3PR07MB308; X-Forefront-PRVS: 039735BC4E X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(4630300001)(7370300001)(6009001)(54534003)(199003)(189002)(50226002)(5660300001)(6666003)(2906002)(66066001)(50986999)(50466002)(48376002)(36756003)(68736007)(86362001)(6916009)(2351001)(6512007)(53936002)(101416001)(47776003)(97736004)(107886003)(33646002)(105586002)(110136004)(2361001)(106356001)(189998001)(7350300001)(5003940100001)(42186005)(3846002)(6116002)(305945005)(7736002)(4326008)(6486002)(478600001)(25786009)(6506006)(81166006)(81156014)(8676002); DIR:OUT; SFP:1101; SCL:1; SRVR:AM3PR07MB308; H:elxacz23q12.localdomain; FPR:; SPF:None; PTR:InfoNoRecords; A:1; MX:1; LANG:en; Received-SPF: None (protection.outlook.com: ericsson.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; AM3PR07MB308; 23:V3nnbe6w9BY9vmXj/qJMyDUy5QnOaflyNxnBf05w7g?= =?us-ascii?Q?Hs5ZvSYprn4TWMJkYdqh27r+PuD6E3Xoy6SEKqkPGxMygMcH3ETvbvjdUFEA?= =?us-ascii?Q?bGIaqr3Mc7iHlEErlpkr9+bHri4rZrYygAMLZUh++LmXB1NHLgBja677XR0n?= =?us-ascii?Q?fpKuYUHZeJpgbrCgYpFFdHFX3JnP8fAluS3Zc4Z3KE+ke5EACHQfJUnKUXeY?= =?us-ascii?Q?NKtJOK5g4dqqsOFNrrl501RJ2uxK2JqsWyrvMGEw3fM50GYTbeGAXzBqa1s1?= =?us-ascii?Q?2vvXzN5sA4paQzH/qLDlCTj4IxMnbbjsnsfY1ESrKjLqIXyO0PAqvF2+Lr2B?= =?us-ascii?Q?3ZJswnNRRYGNnVLEVDEJ/JsIytmkhHkoEvahDkFrE1sOODCH3lPaiwfR/jmK?= =?us-ascii?Q?psUf/cj/mxx+g/ByKTix9t/KMPY0CT8Lw0JxP0bOKedJqCIYuqv+9VwuBvai?= =?us-ascii?Q?jTMoN2XLkIEfLfmVm2r+zAJr5urhcS2vs8NtQfKFLdSUo4HNLw0fmTXNv1j1?= =?us-ascii?Q?VbT6CbwYIijDg2RrohY0mebLEEev1X+JjercGA4s1nxq3XhcCQ6XS+ZyGZYF?= =?us-ascii?Q?6J2S/tp97UImptHxDpg6usgmxprEoulYrMHcLm2W70uvI7mCC7w+so3bLIW7?= =?us-ascii?Q?qhuN2nY5UBtE3BCdllcXOEayQ+3EAUeDaTski6J6iJV0XOkP+sdHAaMBf4xN?= =?us-ascii?Q?h6JYfhY8sWg3XZq5I4Quscaz+erV5ps90LGOxpbIqVKT7hTtgFvzvkfsvLVj?= =?us-ascii?Q?wUT3pSSFdawlF+iwPjPhpSr5FIRSrW2e5jiHkZ6jHGB4Y55uI+tjAmk5dit6?= =?us-ascii?Q?IRQFQsmIxBfjiGqL+/E+VCFvj51HScPnSprKgULjXnVE6erMX1WyMpcGEs5R?= =?us-ascii?Q?UgpBCV3jkASVom+W67Tsz6AosuiLiF6zp+hG94dzXOK3jJFLEDPOjFxnSQ8b?= =?us-ascii?Q?/Uy5CGsgvgL4Z8g52GaDDZ6eYlemtZ6iaU2R3ketKDicPdWBOCWYOq0vJN8+?= =?us-ascii?Q?L5zgnNWqfGt2A7rh11r0slgdnDqA3assW4Iq/v2HRQ5HnsDnx/Lekr3yo9Xn?= =?us-ascii?Q?P6BvSmRfIZYzAnfTQyYehqEQBjFjViNAl6y5kxiW6TJz77dlINB3oOZOe4Ca?= =?us-ascii?Q?RsHl1hmNk=3D?= X-Microsoft-Exchange-Diagnostics: 1; AM3PR07MB308; 6:RgLVfBaAQoAgzpx3mh2b1qUSSZ9ogNXyQcO8ay7lerVqS/nPxMNMKdATzJHaH6n6dQuVE3Q2ukDK966/BXdCRHcZThNNF0cWQrqTU0GRW3r8FTVq7WHjT5F9A6kz+PI5UfpCwBt2bzatvvj7YT0NH0DG0ZvPj+IGgXrzEnG5AnPEOUM46B3c8AtcrjVvdblz0pvqjFN+EyP8RKhV8HXoYriXGNi4Ou+Co/m9wzRGt1OKE9Hq51oLToTC2a8IAjAQ+R/NRGVrW90ah14l/ZocBRvLzKU4/Vgu+1/gF8hoIFviVkhBei7CJdDeBrDoU4Ezr65doHjIJoA7CpRsw3UVqQ==; 5:VzSGh0c2xV3tQphJs6eUUaCkUc0DHOmFsuLz7O1Uoaf+j1ZM1qrV5HPJ2GBfzM+uNh3QxbdDgWXjLBjCHOTcgh1g2ISdhrXPEGavAUG7SUckOrYOr7dfYqEdoWg1TXQfCmh+ipaEDeT6h5MzA3Cong==; 24:G8NkyGSdjw76Keyb0zoSN8MlXFwAUCxm9iUO69t7AY/psJ9PaV/w9cmkDelX6eG+hkm2/BkdyHrIr5mLx2zUMdD3az1g0L2B3FV8dTJ9/PY=; 7:XP8G3cnYMu2vns64RHxjGm1sxxm4sLc1vLG7aUTs6WSh91D1eNGZ68QXmY+ONnExvdvLneQlfsf83ddSdA25gRacWU8qjpnV/72i4JLvjfeKtQ8dGr/Mo7RQm7iqUxI3tDP06wxRXlE6Yf9fBuvSp2J33cBxk7zoWl/8iIVV0bFaqvDhEXrpk+F3s+NHX13tl6K9YsGajymd58H3IahKxIy9gqifgMjL9b2z+Dv9lLY= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-MS-Exchange-CrossTenant-OriginalArrivalTime: 12 Aug 2017 08:30:19.0941 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM3PR07MB308 X-OriginatorOrg: ericsson.com X-IsSubscribed: yes A quite straightforward change. It does "fix" leaks in record-btrace.c, although since this is only used in debug printing code, it has no real world impact. gdb/ChangeLog: * target/waitstatus.h (target_waitstatus_to_string): Change return type to std::string. * target/waitstatus.c (target_waitstatus_to_string): Return std::string. * target.h (target_waitstatus_to_string): Remove declaration. * infrun.c (resume, clear_proceed_status_thread, print_target_wait_results, do_target_wait, save_waitstatus, stop_all_threads): Adjust. * record-btrace.c (record_btrace_wait): Adjust. * target-debug.h (target_debug_print_struct_target_waitstatus_p): Adjust. gdb/gdbserver/ChangeLog: * linux-low.c (linux_wait_1): Adjust. * server.c (queue_stop_reply_callback): Adjust. --- gdb/gdbserver/linux-low.c | 7 +++---- gdb/gdbserver/server.c | 6 ++---- gdb/infrun.c | 43 +++++++++++++++++------------------------- gdb/record-btrace.c | 8 ++++++-- gdb/target-debug.h | 5 ++--- gdb/target.h | 4 ---- gdb/target/waitstatus.c | 48 +++++++++++++++++++++++------------------------ gdb/target/waitstatus.h | 5 ++--- 8 files changed, 56 insertions(+), 70 deletions(-) diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c index fd46d85..6f4b26a 100644 --- a/gdb/gdbserver/linux-low.c +++ b/gdb/gdbserver/linux-low.c @@ -3733,12 +3733,11 @@ linux_wait_1 (ptid_t ptid, { if (event_child->waitstatus.kind != TARGET_WAITKIND_IGNORE) { - char *str; + std::string str + = target_waitstatus_to_string (&event_child->waitstatus); - str = target_waitstatus_to_string (&event_child->waitstatus); debug_printf ("LWP %ld: extended event with waitstatus %s\n", - lwpid_of (get_lwp_thread (event_child)), str); - xfree (str); + lwpid_of (get_lwp_thread (event_child)), str.c_str ()); } if (current_thread->last_resume_kind == resume_step) { diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c index 3838351..283fa8d 100644 --- a/gdb/gdbserver/server.c +++ b/gdb/gdbserver/server.c @@ -3116,14 +3116,12 @@ queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg) { if (debug_threads) { - char *status_string + std::string status_string = target_waitstatus_to_string (&thread->last_status); debug_printf ("Reporting thread %s as already stopped with %s\n", target_pid_to_str (entry->id), - status_string); - - xfree (status_string); + status_string.c_str ()); } gdb_assert (thread->last_status.kind != TARGET_WAITKIND_IGNORE); diff --git a/gdb/infrun.c b/gdb/infrun.c index d6723fd..964f7ff 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -2413,15 +2413,14 @@ resume (enum gdb_signal sig) { if (debug_infrun) { - char *statstr; + std::string statstr + = target_waitstatus_to_string (&tp->suspend.waitstatus); - statstr = target_waitstatus_to_string (&tp->suspend.waitstatus); fprintf_unfiltered (gdb_stdlog, - "infrun: resume: thread %s has pending wait status %s " - "(currently_stepping=%d).\n", - target_pid_to_str (tp->ptid), statstr, + "infrun: resume: thread %s has pending wait " + "status %s (currently_stepping=%d).\n", + target_pid_to_str (tp->ptid), statstr.c_str (), currently_stepping (tp)); - xfree (statstr); } tp->resumed = 1; @@ -2824,16 +2823,15 @@ clear_proceed_status_thread (struct thread_info *tp) } else if (debug_infrun) { - char *statstr; + std::string statstr + = target_waitstatus_to_string (&tp->suspend.waitstatus); - statstr = target_waitstatus_to_string (&tp->suspend.waitstatus); fprintf_unfiltered (gdb_stdlog, "infrun: clear_proceed_status_thread: thread %s " "has pending wait status %s " "(currently_stepping=%d).\n", - target_pid_to_str (tp->ptid), statstr, + target_pid_to_str (tp->ptid), statstr.c_str (), currently_stepping (tp)); - xfree (statstr); } } @@ -3422,7 +3420,7 @@ void print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid, const struct target_waitstatus *ws) { - char *status_string = target_waitstatus_to_string (ws); + std::string status_string = target_waitstatus_to_string (ws); string_file stb; /* The text is split over several lines because it was getting too long. @@ -3442,13 +3440,11 @@ print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid, ptid_get_lwp (result_ptid), ptid_get_tid (result_ptid), target_pid_to_str (result_ptid)); - stb.printf ("infrun: %s\n", status_string); + stb.printf ("infrun: %s\n", status_string.c_str ()); /* This uses %s in part to handle %'s in the text, but also to avoid a gcc error: the format attribute requires a string literal. */ fprintf_unfiltered (gdb_stdlog, "%s", stb.c_str ()); - - xfree (status_string); } /* Select a thread at random, out of those which are resumed and have @@ -3570,14 +3566,13 @@ do_target_wait (ptid_t ptid, struct target_waitstatus *status, int options) { if (debug_infrun) { - char *statstr; + std::string statstr + = target_waitstatus_to_string (&tp->suspend.waitstatus); - statstr = target_waitstatus_to_string (&tp->suspend.waitstatus); fprintf_unfiltered (gdb_stdlog, "infrun: Using pending wait status %s for %s.\n", - statstr, + statstr.c_str (), target_pid_to_str (tp->ptid)); - xfree (statstr); } /* Now that we've selected our final event LWP, un-adjust its PC @@ -4406,16 +4401,14 @@ save_waitstatus (struct thread_info *tp, struct target_waitstatus *ws) if (debug_infrun) { - char *statstr; + std::string statstr = target_waitstatus_to_string (ws); - statstr = target_waitstatus_to_string (ws); fprintf_unfiltered (gdb_stdlog, "infrun: saving status %s for %d.%ld.%ld\n", - statstr, + statstr.c_str (), ptid_get_pid (tp->ptid), ptid_get_lwp (tp->ptid), ptid_get_tid (tp->ptid)); - xfree (statstr); } /* Record for later. */ @@ -4645,17 +4638,15 @@ stop_all_threads (void) if (debug_infrun) { - char *statstr; + std::string statstr = target_waitstatus_to_string (&ws); - statstr = target_waitstatus_to_string (&ws); fprintf_unfiltered (gdb_stdlog, "infrun: target_wait %s, saving " "status for %d.%ld.%ld\n", - statstr, + statstr.c_str (), ptid_get_pid (t->ptid), ptid_get_lwp (t->ptid), ptid_get_tid (t->ptid)); - xfree (statstr); } /* Record for later. */ diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c index b216f1f..414db5f 100644 --- a/gdb/record-btrace.c +++ b/gdb/record-btrace.c @@ -2477,8 +2477,10 @@ record_btrace_wait (struct target_ops *ops, ptid_t ptid, { *status = btrace_step_no_resumed (); + std::string statstr = target_waitstatus_to_string (status); + DEBUG ("wait ended by %s: %s", target_pid_to_str (null_ptid), - target_waitstatus_to_string (status)); + statstr.c_str ()); do_cleanups (cleanups); return null_ptid; @@ -2567,10 +2569,12 @@ record_btrace_wait (struct target_ops *ops, ptid_t ptid, /* We moved the replay position but did not update registers. */ registers_changed_ptid (eventing->ptid); + std::string statstr = target_waitstatus_to_string (status); + DEBUG ("wait ended by thread %s (%s): %s", print_thread_id (eventing), target_pid_to_str (eventing->ptid), - target_waitstatus_to_string (status)); + statstr.c_str ()); do_cleanups (cleanups); return eventing->ptid; diff --git a/gdb/target-debug.h b/gdb/target-debug.h index 6923608..532e98d 100644 --- a/gdb/target-debug.h +++ b/gdb/target-debug.h @@ -166,10 +166,9 @@ static void target_debug_print_struct_target_waitstatus_p (struct target_waitstatus *status) { - char *str = target_waitstatus_to_string (status); + std::string str = target_waitstatus_to_string (status); - fputs_unfiltered (str, gdb_stdlog); - xfree (str); + fputs_unfiltered (str.c_str (), gdb_stdlog); } diff --git a/gdb/target.h b/gdb/target.h index c0155c1..5971151 100644 --- a/gdb/target.h +++ b/gdb/target.h @@ -108,10 +108,6 @@ struct syscall const char *name; }; -/* Return a pretty printed form of target_waitstatus. - Space for the result is malloc'd, caller must free. */ -extern char *target_waitstatus_to_string (const struct target_waitstatus *); - /* Return a pretty printed form of TARGET_OPTIONS. Space for the result is malloc'd, caller must free. */ extern char *target_options_to_string (int target_options); diff --git a/gdb/target/waitstatus.c b/gdb/target/waitstatus.c index c59d1b6..eede2d6 100644 --- a/gdb/target/waitstatus.c +++ b/gdb/target/waitstatus.c @@ -23,7 +23,7 @@ /* Return a pretty printed form of target_waitstatus. Space for the result is malloc'd, caller must free. */ -char * +std::string target_waitstatus_to_string (const struct target_waitstatus *ws) { const char *kind_str = "status->kind = "; @@ -31,44 +31,44 @@ target_waitstatus_to_string (const struct target_waitstatus *ws) switch (ws->kind) { case TARGET_WAITKIND_EXITED: - return xstrprintf ("%sexited, status = %d", - kind_str, ws->value.integer); + return string_printf ("%sexited, status = %d", + kind_str, ws->value.integer); case TARGET_WAITKIND_STOPPED: - return xstrprintf ("%sstopped, signal = %s", - kind_str, - gdb_signal_to_symbol_string (ws->value.sig)); + return string_printf ("%sstopped, signal = %s", + kind_str, + gdb_signal_to_symbol_string (ws->value.sig)); case TARGET_WAITKIND_SIGNALLED: - return xstrprintf ("%ssignalled, signal = %s", - kind_str, - gdb_signal_to_symbol_string (ws->value.sig)); + return string_printf ("%ssignalled, signal = %s", + kind_str, + gdb_signal_to_symbol_string (ws->value.sig)); case TARGET_WAITKIND_LOADED: - return xstrprintf ("%sloaded", kind_str); + return string_printf ("%sloaded", kind_str); case TARGET_WAITKIND_FORKED: - return xstrprintf ("%sforked", kind_str); + return string_printf ("%sforked", kind_str); case TARGET_WAITKIND_VFORKED: - return xstrprintf ("%svforked", kind_str); + return string_printf ("%svforked", kind_str); case TARGET_WAITKIND_EXECD: - return xstrprintf ("%sexecd", kind_str); + return string_printf ("%sexecd", kind_str); case TARGET_WAITKIND_VFORK_DONE: - return xstrprintf ("%svfork-done", kind_str); + return string_printf ("%svfork-done", kind_str); case TARGET_WAITKIND_SYSCALL_ENTRY: - return xstrprintf ("%sentered syscall", kind_str); + return string_printf ("%sentered syscall", kind_str); case TARGET_WAITKIND_SYSCALL_RETURN: - return xstrprintf ("%sexited syscall", kind_str); + return string_printf ("%sexited syscall", kind_str); case TARGET_WAITKIND_SPURIOUS: - return xstrprintf ("%sspurious", kind_str); + return string_printf ("%sspurious", kind_str); case TARGET_WAITKIND_IGNORE: - return xstrprintf ("%signore", kind_str); + return string_printf ("%signore", kind_str); case TARGET_WAITKIND_NO_HISTORY: - return xstrprintf ("%sno-history", kind_str); + return string_printf ("%sno-history", kind_str); case TARGET_WAITKIND_NO_RESUMED: - return xstrprintf ("%sno-resumed", kind_str); + return string_printf ("%sno-resumed", kind_str); case TARGET_WAITKIND_THREAD_CREATED: - return xstrprintf ("%sthread created", kind_str); + return string_printf ("%sthread created", kind_str); case TARGET_WAITKIND_THREAD_EXITED: - return xstrprintf ("%sthread exited, status = %d", - kind_str, ws->value.integer); + return string_printf ("%sthread exited, status = %d", + kind_str, ws->value.integer); default: - return xstrprintf ("%sunknown???", kind_str); + return string_printf ("%sunknown???", kind_str); } } diff --git a/gdb/target/waitstatus.h b/gdb/target/waitstatus.h index 52be390..8eee198 100644 --- a/gdb/target/waitstatus.h +++ b/gdb/target/waitstatus.h @@ -145,8 +145,7 @@ enum target_stop_reason /* Prototypes */ -/* Return a pretty printed form of target_waitstatus. - Space for the result is malloc'd, caller must free. */ -extern char *target_waitstatus_to_string (const struct target_waitstatus *); +/* Return a pretty printed form of target_waitstatus. */ +std::string target_waitstatus_to_string (const struct target_waitstatus *); #endif /* WAITSTATUS_H */