From patchwork Mon Aug 27 21:12:04 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Simon Marchi X-Patchwork-Id: 29081 Received: (qmail 83327 invoked by alias); 27 Aug 2018 21:12:44 -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 83315 invoked by uid 89); 27 Aug 2018 21:12:43 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-25.7 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3 autolearn=ham version=3.3.2 spammy=Stuff, Elements, *string X-HELO: sesbmg22.ericsson.net Received: from sesbmg22.ericsson.net (HELO sesbmg22.ericsson.net) (193.180.251.48) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 27 Aug 2018 21:12:40 +0000 DKIM-Signature: v=1; a=rsa-sha256; d=ericsson.com; s=mailgw201801; c=relaxed/simple; q=dns/txt; i=@ericsson.com; t=1535404358; h=From:Sender:Reply-To:Subject:Date:Message-Id:To:CC:MIME-Version:Content-Type: Content-Transfer-Encoding:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:In-Reply-To:References:List-Id: List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=b2MfCQNjBKsDmYjtH5thwfcgyL6+LhVx9tqsM8NXtVU=; b=Ss9u+d3nPOmpeVcfKFfHSG6SIDFA+Nkk2O3zeOvYBo0uCnhEawrHP8rn84Ffth7O bGjIAPnNAgxfemb0A/D4+Hkyk/V43tNveS1J4MPdKfCPo75zfyby+pZ6NDbvuXrC BBpfAplRElfuM25Q/OgLdvUuLrYz8TBL6jOOzyXlJCU=; Received: from ESESSMB502.ericsson.se (Unknown_Domain [153.88.183.120]) by sesbmg22.ericsson.net (Symantec Mail Security) with SMTP id 91.0A.21978.649648B5; Mon, 27 Aug 2018 23:12:38 +0200 (CEST) Received: from ESESBMB504.ericsson.se (153.88.183.171) by ESESSMB502.ericsson.se (153.88.183.163) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1466.3; Mon, 27 Aug 2018 23:12:18 +0200 Received: from NAM01-BY2-obe.outbound.protection.outlook.com (153.88.183.157) by ESESBMB504.ericsson.se (153.88.183.171) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1466.3 via Frontend Transport; Mon, 27 Aug 2018 23:12:18 +0200 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ericsson.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=0Fzj1z9E0QoskvQ2KTrX9Qlt77u6O4D8I2WqSOA2P9E=; b=TdO8XVH681Po090EWvuUsosNtyz5+K22rzLwCrD29L5nk8JXwwqNzOSEUFuV0RpB3n4LcvGu56gD+v/spcADczN6utFE6XIsKjJhJLGDgh1RxkCm9sUnBjz6TY5UMFHWqSUS3ev9q8zpX5vePzhsLcGxeK6VYzFKu79ON26j/dw= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=simon.marchi@ericsson.com; Received: from elxacz23q12.ca.am.ericsson.se (192.75.88.130) by DM6PR15MB2394.namprd15.prod.outlook.com (2603:10b6:5:8d::28) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1080.17; Mon, 27 Aug 2018 21:12:15 +0000 From: Simon Marchi To: CC: Simon Marchi Subject: [PATCH] Implement struct type_stack with a vector Date: Mon, 27 Aug 2018 17:12:04 -0400 Message-Id: <1535404324-7683-1-git-send-email-simon.marchi@ericsson.com> MIME-Version: 1.0 Return-Path: simon.marchi@ericsson.com Received-SPF: None (protection.outlook.com: ericsson.com does not designate permitted sender hosts) X-IsSubscribed: yes This patch changes the home-made stack implementation with a vector, which makes it a bit more concise and readable. Regtested on the buildbot. gdb/ChangeLog: * parser-defs.h (struct type_stack) : Change type to std::vector. : Remove. * parse.c (parse_exp_in_context_1): Adjust. (type_stack_reserve): Remove. (check_type_stack_depth): Remove. (insert_into_type_stack): Adjust to std::vector. (insert_type): Likewise. (push_type): Likewise. (push_type_int): Likewise. (insert_type_address_space): Likewise. (pop_type): Likewise. (pop_type_int): Likewise. (pop_typelist): Likewise. (pop_type_stack): Likewise. (append_type_stack): Likewise. (push_type_stack): Likewise. (get_type_stack): Likewise. (type_stack_cleanup): Likewise. (push_typelist): Likewise. (follow_types): Likewise. (_initialize_parse): Likewise. --- gdb/parse.c | 112 +++++++++++++++++++++--------------------------------- gdb/parser-defs.h | 6 +-- 2 files changed, 44 insertions(+), 74 deletions(-) diff --git a/gdb/parse.c b/gdb/parse.c index 1b58073..163852c 100644 --- a/gdb/parse.c +++ b/gdb/parse.c @@ -1126,7 +1126,7 @@ parse_exp_in_context_1 (const char **stringptr, CORE_ADDR pc, prev_lexptr = NULL; paren_depth = 0; - type_stack.depth = 0; + type_stack.elements.clear (); expout_last_struct = -1; expout_tag_completion_type = TYPE_CODE_UNDEF; expout_completion_name.reset (); @@ -1342,29 +1342,6 @@ parse_float (const char *p, int len, /* Stuff for maintaining a stack of types. Currently just used by C, but probably useful for any language which declares its types "backwards". */ -/* Ensure that there are HOWMUCH open slots on the type stack STACK. */ - -static void -type_stack_reserve (struct type_stack *stack, int howmuch) -{ - if (stack->depth + howmuch >= stack->size) - { - stack->size *= 2; - if (stack->size < howmuch) - stack->size = howmuch; - stack->elements = XRESIZEVEC (union type_stack_elt, stack->elements, - stack->size); - } -} - -/* Ensure that there is a single open slot in the global type stack. */ - -static void -check_type_stack_depth (void) -{ - type_stack_reserve (&type_stack, 1); -} - /* A helper function for insert_type and insert_type_address_space. This does work of expanding the type stack and inserting the new element, ELEMENT, into the stack at location SLOT. */ @@ -1372,13 +1349,8 @@ check_type_stack_depth (void) static void insert_into_type_stack (int slot, union type_stack_elt element) { - check_type_stack_depth (); - - if (slot < type_stack.depth) - memmove (&type_stack.elements[slot + 1], &type_stack.elements[slot], - (type_stack.depth - slot) * sizeof (union type_stack_elt)); - type_stack.elements[slot] = element; - ++type_stack.depth; + gdb_assert (slot <= type_stack.elements.size ()); + type_stack.elements.insert (type_stack.elements.begin () + slot, element); } /* Insert a new type, TP, at the bottom of the type stack. If TP is @@ -1400,7 +1372,7 @@ insert_type (enum type_pieces tp) /* If there is anything on the stack (we know it will be a tp_pointer), insert the qualifier above it. Otherwise, simply push this on the top of the stack. */ - if (type_stack.depth && (tp == tp_const || tp == tp_volatile)) + if (!type_stack.elements.empty () && (tp == tp_const || tp == tp_volatile)) slot = 1; else slot = 0; @@ -1412,15 +1384,17 @@ insert_type (enum type_pieces tp) void push_type (enum type_pieces tp) { - check_type_stack_depth (); - type_stack.elements[type_stack.depth++].piece = tp; + type_stack_elt elt; + elt.piece = tp; + type_stack.elements.push_back (elt); } void push_type_int (int n) { - check_type_stack_depth (); - type_stack.elements[type_stack.depth++].int_val = n; + type_stack_elt elt; + elt.int_val = n; + type_stack.elements.push_back (elt); } /* Insert a tp_space_identifier and the corresponding address space @@ -1440,7 +1414,7 @@ insert_type_address_space (struct parser_state *pstate, char *string) /* If there is anything on the stack (we know it will be a tp_pointer), insert the address space qualifier above it. Otherwise, simply push this on the top of the stack. */ - if (type_stack.depth) + if (!type_stack.elements.empty ()) slot = 1; else slot = 0; @@ -1455,16 +1429,24 @@ insert_type_address_space (struct parser_state *pstate, char *string) enum type_pieces pop_type (void) { - if (type_stack.depth) - return type_stack.elements[--type_stack.depth].piece; + if (!type_stack.elements.empty ()) + { + type_stack_elt elt = type_stack.elements.back (); + type_stack.elements.pop_back (); + return elt.piece; + } return tp_end; } int pop_type_int (void) { - if (type_stack.depth) - return type_stack.elements[--type_stack.depth].int_val; + if (!type_stack.elements.empty ()) + { + type_stack_elt elt = type_stack.elements.back (); + type_stack.elements.pop_back (); + return elt.int_val; + } /* "Can't happen". */ return 0; } @@ -1474,8 +1456,10 @@ pop_type_int (void) static VEC (type_ptr) * pop_typelist (void) { - gdb_assert (type_stack.depth); - return type_stack.elements[--type_stack.depth].typelist_val; + gdb_assert (!type_stack.elements.empty ()); + type_stack_elt elt = type_stack.elements.back (); + type_stack.elements.pop_back (); + return elt.typelist_val; } /* Pop a type_stack element from the global type stack. */ @@ -1483,8 +1467,10 @@ pop_typelist (void) static struct type_stack * pop_type_stack (void) { - gdb_assert (type_stack.depth); - return type_stack.elements[--type_stack.depth].stack_val; + gdb_assert (!type_stack.elements.empty ()); + type_stack_elt elt = type_stack.elements.back (); + type_stack.elements.pop_back (); + return elt.stack_val; } /* Append the elements of the type stack FROM to the type stack TO. @@ -1493,12 +1479,8 @@ pop_type_stack (void) struct type_stack * append_type_stack (struct type_stack *to, struct type_stack *from) { - type_stack_reserve (to, from->depth); - - memcpy (&to->elements[to->depth], &from->elements[0], - from->depth * sizeof (union type_stack_elt)); - to->depth += from->depth; - + to->elements.insert (to->elements.end (), from->elements.begin (), + from->elements.end ()); return to; } @@ -1507,8 +1489,9 @@ append_type_stack (struct type_stack *to, struct type_stack *from) void push_type_stack (struct type_stack *stack) { - check_type_stack_depth (); - type_stack.elements[type_stack.depth++].stack_val = stack; + type_stack_elt elt; + elt.stack_val = stack; + type_stack.elements.push_back (elt); push_type (tp_type_stack); } @@ -1519,13 +1502,8 @@ push_type_stack (struct type_stack *stack) struct type_stack * get_type_stack (void) { - struct type_stack *result = XNEW (struct type_stack); - - *result = type_stack; - type_stack.depth = 0; - type_stack.size = 0; - type_stack.elements = NULL; - + struct type_stack *result = new struct type_stack (std::move (type_stack)); + type_stack.elements.clear (); return result; } @@ -1536,8 +1514,7 @@ type_stack_cleanup (void *arg) { struct type_stack *stack = (struct type_stack *) arg; - xfree (stack->elements); - xfree (stack); + delete stack; } /* Push a function type with arguments onto the global type stack. @@ -1547,8 +1524,9 @@ type_stack_cleanup (void *arg) void push_typelist (VEC (type_ptr) *list) { - check_type_stack_depth (); - type_stack.elements[type_stack.depth++].typelist_val = list; + type_stack_elt elt; + elt.typelist_val = list; + type_stack.elements.push_back (elt); push_type (tp_function_with_arguments); } @@ -1693,7 +1671,7 @@ follow_types (struct type *follow_type) type_stack = *stack; follow_type = follow_types (follow_type); - gdb_assert (type_stack.depth == 0); + gdb_assert (type_stack.elements.empty ()); type_stack = save; } @@ -1878,10 +1856,6 @@ increase_expout_size (struct parser_state *ps, size_t lenelt) void _initialize_parse (void) { - type_stack.size = 0; - type_stack.depth = 0; - type_stack.elements = NULL; - add_setshow_zuinteger_cmd ("expression", class_maintenance, &expressiondebug, _("Set expression debugging."), diff --git a/gdb/parser-defs.h b/gdb/parser-defs.h index c67b8d5..242409c 100644 --- a/gdb/parser-defs.h +++ b/gdb/parser-defs.h @@ -233,11 +233,7 @@ union type_stack_elt struct type_stack { /* Elements on the stack. */ - union type_stack_elt *elements; - /* Current stack depth. */ - int depth; - /* Allocated size of stack. */ - int size; + std::vector elements; }; /* Reverse an expression from suffix form (in which it is constructed)