From patchwork Wed Nov 2 05:06:12 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Ian Lance Taylor X-Patchwork-Id: 123210 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id 04604B6F0E for ; Wed, 2 Nov 2011 16:06:46 +1100 (EST) Received: (qmail 21029 invoked by alias); 2 Nov 2011 05:06:43 -0000 Received: (qmail 21014 invoked by uid 22791); 2 Nov 2011 05:06:41 -0000 X-SWARE-Spam-Status: No, hits=-3.1 required=5.0 tests=AWL, BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, RCVD_IN_DNSWL_LOW, RP_MATCHES_RCVD, TW_CP, TW_MH, TW_ZJ X-Spam-Check-By: sourceware.org Received: from mail-gy0-f175.google.com (HELO mail-gy0-f175.google.com) (209.85.160.175) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 02 Nov 2011 05:06:23 +0000 Received: by gyd8 with SMTP id 8so4052874gyd.20 for ; Tue, 01 Nov 2011 22:06:23 -0700 (PDT) Received: by 10.236.124.97 with SMTP id w61mr3943398yhh.106.1320210383121; Tue, 01 Nov 2011 22:06:23 -0700 (PDT) Received: by 10.236.124.97 with SMTP id w61mr3943379yhh.106.1320210382993; Tue, 01 Nov 2011 22:06:22 -0700 (PDT) Received: from coign.google.com ([216.239.45.130]) by mx.google.com with ESMTPS id m29sm2422344yhi.20.2011.11.01.22.06.20 (version=TLSv1/SSLv3 cipher=OTHER); Tue, 01 Nov 2011 22:06:22 -0700 (PDT) From: Ian Lance Taylor To: Uros Bizjak Cc: gcc-patches@gcc.gnu.org, gofrontend-dev@googlegroups.com Subject: Re: -fdump-go-spec option does not handle redefinitions References: Date: Tue, 01 Nov 2011 22:06:12 -0700 In-Reply-To: (Uros Bizjak's message of "Thu, 27 Oct 2011 21:35:47 +0200") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/23.1 (gnu/linux) MIME-Version: 1.0 X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Uros Bizjak writes: >> The problem with your proposal is that the output would be invalid Go, >> because it would attempt to define the name _aa twice.  However, it does >> seem plausible that in most scenarios of this type it would be more >> useful for -fdump-go-spec to generate >> >> const _aa = 3 > > I agree. This patch implements this approach. Bootstrapped and ran Go testsuite on x86_64-unknown-linux-gnu. Committed to mainline. Ian 2011-11-01 Ian Lance Taylor * godump.c (struct macro_hash_value): Define. (macro_hash_hashval): New static function. (macro_hash_eq, macro_hash_del): New static functions. (go_define): Use macro_hash_value to store values in macro_hash. Replace an old value on a redefinition. Don't print anything to go_dump_file. (go_undef): Delete the entry from the hash table. (go_output_typedef): For an enum, use macro_hash_value, and don't print anything to go_dump_file. (go_print_macro): New static function. (go_finish): Traverse macro_hash with go_print_macro. (dump_go_spec_init): Update macro_hash creation for macro_hash_value. Index: godump.c =================================================================== --- godump.c (revision 180342) +++ godump.c (working copy) @@ -62,7 +62,47 @@ static GTY(()) VEC(tree,gc) *queue; static htab_t macro_hash; -/* For the hash tables. */ +/* The type of a value in macro_hash. */ + +struct macro_hash_value +{ + /* The name stored in the hash table. */ + char *name; + /* The value of the macro. */ + char *value; +}; + +/* Calculate the hash value for an entry in the macro hash table. */ + +static hashval_t +macro_hash_hashval (const void *val) +{ + const struct macro_hash_value *mhval = (const struct macro_hash_value *) val; + return htab_hash_string (mhval->name); +} + +/* Compare values in the macro hash table for equality. */ + +static int +macro_hash_eq (const void *v1, const void *v2) +{ + const struct macro_hash_value *mhv1 = (const struct macro_hash_value *) v1; + const struct macro_hash_value *mhv2 = (const struct macro_hash_value *) v2; + return strcmp (mhv1->name, mhv2->name) == 0; +} + +/* Free values deleted from the macro hash table. */ + +static void +macro_hash_del (void *v) +{ + struct macro_hash_value *mhv = (struct macro_hash_value *) v; + XDELETEVEC (mhv->name); + XDELETEVEC (mhv->value); + XDELETE (mhv); +} + +/* For the string hash tables. */ static int string_hash_eq (const void *y1, const void *y2) @@ -77,10 +117,12 @@ go_define (unsigned int lineno, const ch { const char *p; const char *name_end; + size_t out_len; char *out_buffer; char *q; bool saw_operand; bool need_operand; + struct macro_hash_value *mhval; char *copy; hashval_t hashval; void **slot; @@ -105,17 +147,17 @@ go_define (unsigned int lineno, const ch memcpy (copy, buffer, name_end - buffer); copy[name_end - buffer] = '\0'; + mhval = XNEW (struct macro_hash_value); + mhval->name = copy; + mhval->value = NULL; + hashval = htab_hash_string (copy); - slot = htab_find_slot_with_hash (macro_hash, copy, hashval, NO_INSERT); - if (slot != NULL) - { - XDELETEVEC (copy); - return; - } + slot = htab_find_slot_with_hash (macro_hash, mhval, hashval, NO_INSERT); /* For simplicity, we force all names to be hidden by adding an initial underscore, and let the user undo this as needed. */ - out_buffer = XNEWVEC (char, strlen (p) * 2 + 1); + out_len = strlen (p) * 2 + 1; + out_buffer = XNEWVEC (char, out_len); q = out_buffer; saw_operand = false; need_operand = false; @@ -141,6 +183,7 @@ go_define (unsigned int lineno, const ch don't worry about them. */ const char *start; char *n; + struct macro_hash_value idval; if (saw_operand) goto unknown; @@ -151,8 +194,9 @@ go_define (unsigned int lineno, const ch n = XALLOCAVEC (char, p - start + 1); memcpy (n, start, p - start); n[p - start] = '\0'; - slot = htab_find_slot (macro_hash, n, NO_INSERT); - if (slot == NULL || *slot == NULL) + idval.name = n; + idval.value = NULL; + if (htab_find (macro_hash, &idval) == NULL) { /* This is a reference to a name which was not defined as a macro. */ @@ -382,18 +426,30 @@ go_define (unsigned int lineno, const ch if (need_operand) goto unknown; + gcc_assert ((size_t) (q - out_buffer) < out_len); *q = '\0'; - slot = htab_find_slot_with_hash (macro_hash, copy, hashval, INSERT); - *slot = copy; + mhval->value = out_buffer; - fprintf (go_dump_file, "const _%s = %s\n", copy, out_buffer); + if (slot == NULL) + { + slot = htab_find_slot_with_hash (macro_hash, mhval, hashval, INSERT); + gcc_assert (slot != NULL && *slot == NULL); + } + else + { + if (*slot != NULL) + macro_hash_del (*slot); + } + + *slot = mhval; - XDELETEVEC (out_buffer); return; unknown: fprintf (go_dump_file, "// unknowndefine %s\n", buffer); + if (slot != NULL) + htab_clear_slot (macro_hash, slot); XDELETEVEC (out_buffer); XDELETEVEC (copy); } @@ -403,16 +459,16 @@ go_define (unsigned int lineno, const ch static void go_undef (unsigned int lineno, const char *buffer) { + struct macro_hash_value mhval; void **slot; real_debug_hooks->undef (lineno, buffer); - slot = htab_find_slot (macro_hash, buffer, NO_INSERT); - if (slot == NULL) - return; - fprintf (go_dump_file, "// undef _%s\n", buffer); - /* We don't delete the slot from the hash table because that will - cause a duplicate const definition. */ + mhval.name = CONST_CAST (char *, buffer); + mhval.value = NULL; + slot = htab_find_slot (macro_hash, &mhval, NO_INSERT); + if (slot != NULL) + htab_clear_slot (macro_hash, slot); } /* A function or variable decl. */ @@ -909,32 +965,37 @@ go_output_typedef (struct godump_contain element = TREE_CHAIN (element)) { const char *name; + struct macro_hash_value *mhval; void **slot; + char buf[100]; name = IDENTIFIER_POINTER (TREE_PURPOSE (element)); /* Sometimes a name will be defined as both an enum constant and a macro. Avoid duplicate definition errors by treating enum constants as macros. */ - slot = htab_find_slot (macro_hash, name, INSERT); - if (*slot == NULL) - { - *slot = CONST_CAST (char *, name); - fprintf (go_dump_file, "const _%s = ", name); - if (host_integerp (TREE_VALUE (element), 0)) - fprintf (go_dump_file, HOST_WIDE_INT_PRINT_DEC, - tree_low_cst (TREE_VALUE (element), 0)); - else if (host_integerp (TREE_VALUE (element), 1)) - fprintf (go_dump_file, HOST_WIDE_INT_PRINT_UNSIGNED, - ((unsigned HOST_WIDE_INT) - tree_low_cst (TREE_VALUE (element), 1))); - else - fprintf (go_dump_file, HOST_WIDE_INT_PRINT_DOUBLE_HEX, - ((unsigned HOST_WIDE_INT) - TREE_INT_CST_HIGH (TREE_VALUE (element))), - TREE_INT_CST_LOW (TREE_VALUE (element))); - fprintf (go_dump_file, "\n"); - } + mhval = XNEW (struct macro_hash_value); + mhval->name = xstrdup (name); + mhval->value = NULL; + slot = htab_find_slot (macro_hash, mhval, INSERT); + if (*slot != NULL) + macro_hash_del (*slot); + + if (host_integerp (TREE_VALUE (element), 0)) + snprintf (buf, sizeof buf, HOST_WIDE_INT_PRINT_DEC, + tree_low_cst (TREE_VALUE (element), 0)); + else if (host_integerp (TREE_VALUE (element), 1)) + snprintf (buf, sizeof buf, HOST_WIDE_INT_PRINT_UNSIGNED, + ((unsigned HOST_WIDE_INT) + tree_low_cst (TREE_VALUE (element), 1))); + else + snprintf (buf, sizeof buf, HOST_WIDE_INT_PRINT_DOUBLE_HEX, + ((unsigned HOST_WIDE_INT) + TREE_INT_CST_HIGH (TREE_VALUE (element))), + TREE_INT_CST_LOW (TREE_VALUE (element))); + + mhval->value = xstrdup (buf); + *slot = mhval; } pointer_set_insert (container->decls_seen, TREE_TYPE (decl)); if (TYPE_CANONICAL (TREE_TYPE (decl)) != NULL_TREE) @@ -1039,6 +1100,17 @@ go_output_var (struct godump_container * } } +/* Output the final value of a preprocessor macro or enum constant. + This is called via htab_traverse_noresize. */ + +static int +go_print_macro (void **slot, void *arg ATTRIBUTE_UNUSED) +{ + struct macro_hash_value *mhval = (struct macro_hash_value *) *slot; + fprintf (go_dump_file, "const _%s = %s\n", mhval->name, mhval->value); + return 1; +} + /* Build a hash table with the Go keywords. */ static const char * const keywords[] = { @@ -1123,6 +1195,8 @@ go_finish (const char *filename) } } + htab_traverse_noresize (macro_hash, go_print_macro, NULL); + /* To emit dummy definitions. */ pointer_set_traverse (container.pot_dummy_types, find_dummy_types, (void *) &container); @@ -1163,7 +1237,8 @@ dump_go_spec_init (const char *filename, go_debug_hooks.global_decl = go_global_decl; go_debug_hooks.type_decl = go_type_decl; - macro_hash = htab_create (100, htab_hash_string, string_hash_eq, NULL); + macro_hash = htab_create (100, macro_hash_hashval, macro_hash_eq, + macro_hash_del); return &go_debug_hooks; }