Re: [gimplefe][patch] The symbol table for declarations

[Sandeep Soni <soni dot sandeepb at gmail dot com>]

On Wed, Feb 29, 2012 at 8:14 PM, Diego Novillo <dnovillo@google.com> wrote:
> On 24/02/12 01:03 , Sandeep Soni wrote:
>
>> + ?name_token = gl_consume_expected_token (parser->lexer, CPP_NAME);
>> + ?name = gl_token_as_text (name_token);
>> +
>> + ?e = ggc_alloc_cleared_gimple_symtab_entry_def ();
>> + ?e->id = get_identifier(name);
>> + ?slot = htab_find_slot (gimple_symtab, e, NO_INSERT);
>> + ?if (!slot)
>
>
> Why not just use INSERT here? ?If the slot is empty, you can then test 'if
> (*slot == NULL)' (since the INSERT operation guarantees that 'slot' will be
> non-NULL.
>
> Also, please factor this code to a helper function to abstract the hash
> table operations. ? We will later want to add a pure lookup routine and we
> may want to add symbols to the symbol table from other contexts.

Done with the above changes. The hash table operations are abstracted
out to two helper functions. Also added is a function to lazily
initialize the hash table similar to the one we have in the LTO front
end.

The patch is attached. Up for review. The changelog is as follows:
2012-03-01  Sandeep Soni  <soni.sandeepb@gmail.com>

	* parser.c : Include hashtab.h.
	(gimple_symtab): New. The symbol table.
	(gimple_symtab_entry_hash): New.
	(gimple_symtab_eq_hash): New.
	(gimple_symtab_entry_marked_p):New.
	(gimple_symtab_maybe_init_hash_table):New.
	(gimple_symtab_register_decl):New.
	(gimple_register_var_decl_in_symtab):New.
	(gp_parse_var_decl): Put declaration in the symbol table.
	(gimple_main): Creates the symbol table
	* parser.h : (struct gimple_symtab_entry_def): New.

2011-10-11  Sandeep Soni  <soni.sandeepb@gmail.com>

	* parser.c (gp_parse_var_decl): Fixed a bug for the
	missing symbol 'CPP_LESS' in the 'INTEGER_TYPE' declaration.


-- 
Cheers
Sandy

Index: gcc/gimple/parser.h
===================================================================
--- gcc/gimple/parser.h	(revision 174754)
+++ gcc/gimple/parser.h	(working copy)
@@ -27,6 +27,19 @@
 #include "vec.h"
 
 
+/* The GIMPLE symbol table entry.  */
+
+struct GTY(()) gimple_symtab_entry_def 
+{
+  /* symbol table entry key, an identifier.  */
+  tree id;
+
+  /* symbol table entry, a DECL.  */
+  tree decl;
+};
+
+typedef struct gimple_symtab_entry_def *gimple_symtab_entry_t;
+
 /* A GIMPLE token.  */
 
 typedef struct GTY(()) gimple_token {
@@ -81,7 +94,7 @@
   struct GTY((skip)) ht *ident_hash;
 } gimple_parser;
 
-
+ 
 /* In parser.c  */
 extern void gimple_main (void);
 
Index: gcc/gimple/parser.c
===================================================================
--- gcc/gimple/parser.c	(revision 174754)
+++ gcc/gimple/parser.c	(working copy)
@@ -28,6 +28,7 @@
 #include "tree.h"
 #include "gimple.h"
 #include "parser.h"
+#include "hashtab.h"
 #include "ggc.h"
 
 /* The GIMPLE parser.  Note: do not use this variable directly.  It is
@@ -44,6 +45,84 @@
 /* EOF token.  */
 static gimple_token gl_eof_token = { CPP_EOF, 0, 0, 0 };
 
+/* Gimple symbol table.  */
+
+static GTY ((if_marked ("gimple_symtab_entry_marked_p"),
+	     param_is (struct gimple_symtab_entry_def)))
+  htab_t gimple_symtab;
+
+/* Return the hash value of the declaration name of a gimple_symtab_entry_def
+   object pointed by ENTRY.  */
+
+static hashval_t
+gimple_symtab_entry_hash (const void *entry)
+{
+  const struct gimple_symtab_entry_def *base =
+    (const struct gimple_symtab_entry_def *)entry;
+  return IDENTIFIER_HASH_VALUE (base->id);
+}
+
+/* Returns non-zero if ENTRY1 and ENTRY2 point to gimple_symtab_entry_def
+   objects corresponding to the same declaration.  */
+
+static int
+gimple_symtab_eq_hash (const void *entry1, const void *entry2)
+{
+  const struct gimple_symtab_entry_def *base1 =
+    (const struct gimple_symtab_entry_def *)entry1;
+  const struct gimple_symtab_entry_def *base2 =
+    (const struct gimple_symtab_entry_def *)entry2;
+
+  return (base1->id == base2->id);
+}
+
+/* Returns non-zero if P points to an gimple_symtab_entry_def struct that needs
+   to be marked for GC.  */
+
+static int
+gimple_symtab_entry_marked_p (const void *p)
+{
+  const struct gimple_symtab_entry_def *base =
+     (const struct gimple_symtab_entry_def *) p;
+
+  /* Keep this only if the common IDENTIFIER_NODE of the symtab chain
+     is marked which it will be if at least one of the DECLs in the
+     chain is marked.  */
+  return ggc_marked_p (base->id);
+}
+
+
+/* Lazily initialize hash tables.  */
+
+static void
+gimple_symtab_maybe_init_hash_table (void)
+{
+  if (gimple_symtab)
+    return;
+
+  gimple_symtab =
+    htab_create_ggc (1021, gimple_symtab_entry_hash,
+		     gimple_symtab_eq_hash, NULL);
+}
+
+/* Registers DECL with the gimple symbol table as having identifier ID.  */
+
+static void
+gimple_symtab_register_decl (tree decl, tree id)
+{
+  gimple_symtab_entry_t new_entry;
+  void **slot;
+
+  new_entry = ggc_alloc_cleared_gimple_symtab_entry_def ();
+  new_entry->id = id;
+  new_entry->decl = decl;
+
+  gimple_symtab_maybe_init_hash_table ();
+  slot = htab_find_slot (gimple_symtab, new_entry, INSERT); 
+  if (*slot == NULL)
+    *slot = new_entry;
+}
+
 /* Return the string representation of token TOKEN.  */
 
 static const char *
@@ -67,7 +146,19 @@
     }
 }
 
+/* Helper function to register the variable declaration having token NAME_TOKEN
+   in the global gimple symbol table.  */
 
+static void
+gimple_register_var_decl_in_symtab (const gimple_token *name_token)
+{
+  const char *name = gl_token_as_text(name_token);
+  tree id = get_identifier(name);
+  tree decl = build_decl(name_token->location, VAR_DECL, get_identifier(name), void_type_node);
+
+  gimple_symtab_register_decl (decl,id);
+}
+
 /* Return true if we have reached the end of LEXER's token buffer.  */
 
 static bool
@@ -807,6 +898,7 @@
     }
 }
 
+
 /* The Declaration section within a .gimple file can consist of 
    a) Declaration of variables.
    b) Declaration of functions.
@@ -870,18 +962,21 @@
 static void
 gp_parse_var_decl (gimple_parser *parser)
 {
-  const gimple_token *next_token;
+  const gimple_token *next_token, *name_token;
   enum tree_code code ;
+ 
+  gl_consume_expected_token (parser->lexer, CPP_LESS);
+  name_token = gl_consume_expected_token (parser->lexer, CPP_NAME);
 
-  gl_consume_expected_token (parser->lexer, CPP_LESS);
-  gl_consume_expected_token (parser->lexer, CPP_NAME);
+  gimple_register_var_decl_in_symtab (name_token);
+
   gl_consume_expected_token (parser->lexer, CPP_COMMA);
-
   next_token = gl_consume_token (parser->lexer);
   code = gl_tree_code_for_token (next_token);
   switch (code)
     {
     case INTEGER_TYPE:
+      gl_consume_expected_token (parser->lexer, CPP_LESS);
       gl_consume_expected_token (parser->lexer, CPP_NUMBER);
       gl_consume_expected_token (parser->lexer, CPP_RSHIFT);
       break;
@@ -981,6 +1076,7 @@
   gimple_parser *parser = ggc_alloc_cleared_gimple_parser ();
   line_table = parser->line_table = ggc_alloc_cleared_line_maps ();
   parser->ident_hash = ident_hash;
+  
   linemap_init (parser->line_table);
   parser->lexer = gl_init (parser, fname);
 
@@ -1403,6 +1499,7 @@
   if (parser->lexer->filename == NULL)
     return;
 
+  gimple_symtab_maybe_init_hash_table();
   gl_lex (parser->lexer);
   gp_parse (parser);
   gp_finish (parser);