This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: [PATCH][GIMPLE FE] Add parsing of MEM_REFs
On Thu, 12 Jan 2017, Richard Biener wrote:
> On Thu, 12 Jan 2017, Jakub Jelinek wrote:
>
> > On Thu, Jan 12, 2017 at 01:35:32PM +0100, Richard Biener wrote:
> > > It also lacks expressiveness when comparing
> > >
> > > short s;
> > > s_1 = (short) 1;
> > > s_2 = short (1);
> > >
> > > IMHO having a _Literal somewhere makes it more obvious what is meant
> > > (I'm still going to dump 1u or 1l instead of _Literal (unsigned) 1
> > > of course as that's even more easy to recognize).
> >
> > So, with the _Literal (type) constant syntax, what are we going to emit
> > and parse for __int128 constants?
> > _Literal (__int128) (0x123456ULL << 64 || 0x123456ULL), something else?
>
> Yes, unless we teach libcpp about larger than 64bit literals.
>
> The following patch implements _Literal (but not proper dumping of
> > 64bit literals for __int128 nor parsing the above).
>
> I think that's a good start which also covers pointer types nicely.
> For integers we might at some point want to adopt sN and uN suffixes
> which appearantly MSVC supports to handle native 128bit literals.
>
> For
>
> struct X { int a : 2; };
> void __GIMPLE ()
> foo (struct X * p)
> {
> p->a = _Literal (int : 2) 1;
> return;
> }
>
> and thus 2 bit literals c_parser_type_name needs to be extended
> or for _Literal we can handle : 2 on our own. But for loads
> from p->a into a temporary we need to handle that in declarations as well.
>
> struct X { int a : 2; };
> int __GIMPLE ()
> foo (struct X * p)
> {
> int : 2 a; // int a : 2;
> a = p->a;
> return a;
> }
I have bootstrapped and tested the patch below and installed it. We
can add support for parsing vector and complex constants via the
same mechanism so having _Literal ( type ) x looks useful even if
we get another means of handling integer literals in the future.
Richard.
> 2017-01-12 Richard Biener <rguenther@suse.de>
>
> c/
> * gimple-parser.c (c_parser_gimple_postfix_expression): Parse
> _Literal ( type-name ) number.
>
> * tree-pretty-print.c (dump_generic_node): Dump INTEGER_CSTs
> as _Literal ( type ) number in case usual suffixes do not
> preserve all information.
>
> * gcc.dg/gimplefe-22.c: New testcase.
>
> Index: gcc/c/gimple-parser.c
> ===================================================================
> --- gcc/c/gimple-parser.c (revision 244350)
> +++ gcc/c/gimple-parser.c (working copy)
> @@ -799,6 +799,32 @@ c_parser_gimple_postfix_expression (c_pa
> type, ptr.value, alias_off);
> break;
> }
> + else if (strcmp (IDENTIFIER_POINTER (id), "_Literal") == 0)
> + {
> + /* _Literal '(' type-name ')' number */
> + c_parser_consume_token (parser);
> + tree type = NULL_TREE;
> + if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
> + {
> + struct c_type_name *type_name = c_parser_type_name (parser);
> + tree tem;
> + if (type_name)
> + type = groktypename (type_name, &tem, NULL);
> + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
> + "expected %<)%>");
> + }
> + tree val = c_parser_gimple_postfix_expression (parser).value;
> + if (! type
> + || ! val
> + || val == error_mark_node
> + || TREE_CODE (val) != INTEGER_CST)
> + {
> + c_parser_error (parser, "invalid _Literal");
> + return expr;
> + }
> + expr.value = fold_convert (type, val);
> + return expr;
> + }
> /* SSA name. */
> unsigned version, ver_offset;
> if (! lookup_name (id)
> Index: gcc/tree-pretty-print.c
> ===================================================================
> --- gcc/tree-pretty-print.c (revision 244350)
> +++ gcc/tree-pretty-print.c (working copy)
> @@ -1664,6 +1664,16 @@ dump_generic_node (pretty_printer *pp, t
> break;
>
> case INTEGER_CST:
> + if (flags & TDF_GIMPLE
> + && (POINTER_TYPE_P (TREE_TYPE (node))
> + || (TYPE_PRECISION (TREE_TYPE (node))
> + < TYPE_PRECISION (integer_type_node))
> + || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1))
> + {
> + pp_string (pp, "_Literal (");
> + dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
> + pp_string (pp, ") ");
> + }
> if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE
> && ! (flags & TDF_GIMPLE))
> {
> @@ -1693,11 +1703,7 @@ dump_generic_node (pretty_printer *pp, t
> else if (tree_fits_shwi_p (node))
> pp_wide_integer (pp, tree_to_shwi (node));
> else if (tree_fits_uhwi_p (node))
> - {
> - pp_unsigned_wide_integer (pp, tree_to_uhwi (node));
> - if (flags & TDF_GIMPLE)
> - pp_character (pp, 'U');
> - }
> + pp_unsigned_wide_integer (pp, tree_to_uhwi (node));
> else
> {
> wide_int val = node;
> @@ -1710,6 +1716,24 @@ dump_generic_node (pretty_printer *pp, t
> print_hex (val, pp_buffer (pp)->digit_buffer);
> pp_string (pp, pp_buffer (pp)->digit_buffer);
> }
> + if ((flags & TDF_GIMPLE)
> + && (POINTER_TYPE_P (TREE_TYPE (node))
> + || (TYPE_PRECISION (TREE_TYPE (node))
> + < TYPE_PRECISION (integer_type_node))
> + || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1))
> + {
> + if (TYPE_UNSIGNED (TREE_TYPE (node)))
> + pp_character (pp, 'u');
> + if (TYPE_PRECISION (TREE_TYPE (node))
> + == TYPE_PRECISION (unsigned_type_node))
> + ;
> + else if (TYPE_PRECISION (TREE_TYPE (node))
> + == TYPE_PRECISION (long_unsigned_type_node))
> + pp_character (pp, 'l');
> + else if (TYPE_PRECISION (TREE_TYPE (node))
> + == TYPE_PRECISION (long_long_unsigned_type_node))
> + pp_string (pp, "ll");
> + }
> if (TREE_OVERFLOW (node))
> pp_string (pp, "(OVF)");
> break;
> Index: gcc/testsuite/gcc.dg/gimplefe-22.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/gimplefe-22.c (nonexistent)
> +++ gcc/testsuite/gcc.dg/gimplefe-22.c (working copy)
> @@ -0,0 +1,9 @@
> +/* { dg-do compile } */
> +/* { dg-options "-fgimple" } */
> +
> +void __GIMPLE ()
> +foo (short * p)
> +{
> + *p = _Literal (short int) 1;
> + return;
> +}
>
--
Richard Biener <rguenther@suse.de>
SUSE LINUX GmbH, GF: Felix Imendoerffer, Jane Smithard, Graham Norton, HRB 21284 (AG Nuernberg)