1 /* Generate pattern matching and transform code shared between
2 GENERIC and GIMPLE folding code from match-and-simplify description.
4 Copyright (C) 2014-2016 Free Software Foundation, Inc.
5 Contributed by Richard Biener <rguenther@suse.de>
6 and Prathamesh Kulkarni <bilbotheelffriend@gmail.com>
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
27 #include "coretypes.h"
30 #include "hash-table.h"
35 /* Stubs for GGC referenced through instantiations triggered by hash-map. */
36 void *ggc_internal_cleared_alloc (size_t, void (*)(void *),
37 size_t, size_t MEM_STAT_DECL
)
41 void ggc_free (void *)
48 /* Verboseness. 0 is quiet, 1 adds some warnings, 2 is for debugging. */
54 static struct line_maps
*line_table
;
56 /* The rich_location class within libcpp requires a way to expand
57 source_location instances, and relies on the client code
58 providing a symbol named
59 linemap_client_expand_location_to_spelling_point
62 This is the implementation for genmatch. */
65 linemap_client_expand_location_to_spelling_point (source_location loc
)
67 const struct line_map_ordinary
*map
;
68 loc
= linemap_resolve_location (line_table
, loc
, LRK_SPELLING_LOCATION
, &map
);
69 return linemap_expand_location (line_table
, map
, loc
);
73 #if GCC_VERSION >= 4001
74 __attribute__((format (printf
, 5, 0)))
76 error_cb (cpp_reader
*, int errtype
, int, rich_location
*richloc
,
77 const char *msg
, va_list *ap
)
79 const line_map_ordinary
*map
;
80 source_location location
= richloc
->get_loc ();
81 linemap_resolve_location (line_table
, location
, LRK_SPELLING_LOCATION
, &map
);
82 expanded_location loc
= linemap_expand_location (line_table
, map
, location
);
83 fprintf (stderr
, "%s:%d:%d %s: ", loc
.file
, loc
.line
, loc
.column
,
84 (errtype
== CPP_DL_WARNING
) ? "warning" : "error");
85 vfprintf (stderr
, msg
, *ap
);
86 fprintf (stderr
, "\n");
87 FILE *f
= fopen (loc
.file
, "r");
93 if (!fgets (buf
, 128, f
))
95 if (buf
[strlen (buf
) - 1] != '\n')
102 fprintf (stderr
, "%s", buf
);
103 for (int i
= 0; i
< loc
.column
- 1; ++i
)
106 fputc ('\n', stderr
);
111 if (errtype
== CPP_DL_FATAL
)
117 #if GCC_VERSION >= 4001
118 __attribute__((format (printf
, 2, 3)))
120 fatal_at (const cpp_token
*tk
, const char *msg
, ...)
122 rich_location
richloc (line_table
, tk
->src_loc
);
125 error_cb (NULL
, CPP_DL_FATAL
, 0, &richloc
, msg
, &ap
);
130 #if GCC_VERSION >= 4001
131 __attribute__((format (printf
, 2, 3)))
133 fatal_at (source_location loc
, const char *msg
, ...)
135 rich_location
richloc (line_table
, loc
);
138 error_cb (NULL
, CPP_DL_FATAL
, 0, &richloc
, msg
, &ap
);
143 #if GCC_VERSION >= 4001
144 __attribute__((format (printf
, 2, 3)))
146 warning_at (const cpp_token
*tk
, const char *msg
, ...)
148 rich_location
richloc (line_table
, tk
->src_loc
);
151 error_cb (NULL
, CPP_DL_WARNING
, 0, &richloc
, msg
, &ap
);
156 #if GCC_VERSION >= 4001
157 __attribute__((format (printf
, 2, 3)))
159 warning_at (source_location loc
, const char *msg
, ...)
161 rich_location
richloc (line_table
, loc
);
164 error_cb (NULL
, CPP_DL_WARNING
, 0, &richloc
, msg
, &ap
);
168 /* Like fprintf, but print INDENT spaces at the beginning. */
171 #if GCC_VERSION >= 4001
172 __attribute__((format (printf
, 3, 4)))
174 fprintf_indent (FILE *f
, unsigned int indent
, const char *format
, ...)
177 for (; indent
>= 8; indent
-= 8)
179 fprintf (f
, "%*s", indent
, "");
180 va_start (ap
, format
);
181 vfprintf (f
, format
, ap
);
186 output_line_directive (FILE *f
, source_location location
,
187 bool dumpfile
= false)
189 const line_map_ordinary
*map
;
190 linemap_resolve_location (line_table
, location
, LRK_SPELLING_LOCATION
, &map
);
191 expanded_location loc
= linemap_expand_location (line_table
, map
, location
);
194 /* When writing to a dumpfile only dump the filename. */
195 const char *file
= strrchr (loc
.file
, DIR_SEPARATOR
);
200 fprintf (f
, "%s:%d", file
, loc
.line
);
203 /* Other gen programs really output line directives here, at least for
204 development it's right now more convenient to have line information
205 from the generated file. Still keep the directives as comment for now
206 to easily back-point to the meta-description. */
207 fprintf (f
, "/* #line %d \"%s\" */\n", loc
.line
, loc
.file
);
211 /* Pull in tree codes and builtin function codes from their
214 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM,
227 #define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) ENUM,
228 enum built_in_function
{
229 #include "builtins.def"
233 #define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC) IFN_##CODE,
235 #include "internal-fn.def"
239 /* Return true if CODE represents a commutative tree code. Otherwise
242 commutative_tree_code (enum tree_code code
)
248 case MULT_HIGHPART_EXPR
:
263 case WIDEN_MULT_EXPR
:
264 case VEC_WIDEN_MULT_HI_EXPR
:
265 case VEC_WIDEN_MULT_LO_EXPR
:
266 case VEC_WIDEN_MULT_EVEN_EXPR
:
267 case VEC_WIDEN_MULT_ODD_EXPR
:
276 /* Return true if CODE represents a ternary tree code for which the
277 first two operands are commutative. Otherwise return false. */
279 commutative_ternary_tree_code (enum tree_code code
)
283 case WIDEN_MULT_PLUS_EXPR
:
284 case WIDEN_MULT_MINUS_EXPR
:
296 /* Base class for all identifiers the parser knows. */
298 struct id_base
: nofree_ptr_hash
<id_base
>
300 enum id_kind
{ CODE
, FN
, PREDICATE
, USER
, NULL_ID
} kind
;
302 id_base (id_kind
, const char *, int = -1);
308 /* hash_table support. */
309 static inline hashval_t
hash (const id_base
*);
310 static inline int equal (const id_base
*, const id_base
*);
314 id_base::hash (const id_base
*op
)
320 id_base::equal (const id_base
*op1
,
323 return (op1
->hashval
== op2
->hashval
324 && strcmp (op1
->id
, op2
->id
) == 0);
327 /* The special id "null", which matches nothing. */
328 static id_base
*null_id
;
330 /* Hashtable of known pattern operators. This is pre-seeded from
331 all known tree codes and all known builtin function ids. */
332 static hash_table
<id_base
> *operators
;
334 id_base::id_base (id_kind kind_
, const char *id_
, int nargs_
)
339 hashval
= htab_hash_string (id
);
342 /* Identifier that maps to a tree code. */
344 struct operator_id
: public id_base
346 operator_id (enum tree_code code_
, const char *id_
, unsigned nargs_
,
348 : id_base (id_base::CODE
, id_
, nargs_
), code (code_
), tcc (tcc_
) {}
353 /* Identifier that maps to a builtin or internal function code. */
355 struct fn_id
: public id_base
357 fn_id (enum built_in_function fn_
, const char *id_
)
358 : id_base (id_base::FN
, id_
), fn (fn_
) {}
359 fn_id (enum internal_fn fn_
, const char *id_
)
360 : id_base (id_base::FN
, id_
), fn (int (END_BUILTINS
) + int (fn_
)) {}
366 /* Identifier that maps to a user-defined predicate. */
368 struct predicate_id
: public id_base
370 predicate_id (const char *id_
)
371 : id_base (id_base::PREDICATE
, id_
), matchers (vNULL
) {}
372 vec
<simplify
*> matchers
;
375 /* Identifier that maps to a operator defined by a 'for' directive. */
377 struct user_id
: public id_base
379 user_id (const char *id_
, bool is_oper_list_
= false)
380 : id_base (id_base::USER
, id_
), substitutes (vNULL
),
381 used (false), is_oper_list (is_oper_list_
) {}
382 vec
<id_base
*> substitutes
;
390 is_a_helper
<fn_id
*>::test (id_base
*id
)
392 return id
->kind
== id_base::FN
;
398 is_a_helper
<operator_id
*>::test (id_base
*id
)
400 return id
->kind
== id_base::CODE
;
406 is_a_helper
<predicate_id
*>::test (id_base
*id
)
408 return id
->kind
== id_base::PREDICATE
;
414 is_a_helper
<user_id
*>::test (id_base
*id
)
416 return id
->kind
== id_base::USER
;
419 /* Add a predicate identifier to the hash. */
421 static predicate_id
*
422 add_predicate (const char *id
)
424 predicate_id
*p
= new predicate_id (id
);
425 id_base
**slot
= operators
->find_slot_with_hash (p
, p
->hashval
, INSERT
);
427 fatal ("duplicate id definition");
432 /* Add a tree code identifier to the hash. */
435 add_operator (enum tree_code code
, const char *id
,
436 const char *tcc
, unsigned nargs
)
438 if (strcmp (tcc
, "tcc_unary") != 0
439 && strcmp (tcc
, "tcc_binary") != 0
440 && strcmp (tcc
, "tcc_comparison") != 0
441 && strcmp (tcc
, "tcc_expression") != 0
442 /* For {REAL,IMAG}PART_EXPR and VIEW_CONVERT_EXPR. */
443 && strcmp (tcc
, "tcc_reference") != 0
444 /* To have INTEGER_CST and friends as "predicate operators". */
445 && strcmp (tcc
, "tcc_constant") != 0
446 /* And allow CONSTRUCTOR for vector initializers. */
447 && !(code
== CONSTRUCTOR
)
448 /* Allow SSA_NAME as predicate operator. */
449 && !(code
== SSA_NAME
))
451 /* Treat ADDR_EXPR as atom, thus don't allow matching its operand. */
452 if (code
== ADDR_EXPR
)
454 operator_id
*op
= new operator_id (code
, id
, nargs
, tcc
);
455 id_base
**slot
= operators
->find_slot_with_hash (op
, op
->hashval
, INSERT
);
457 fatal ("duplicate id definition");
461 /* Add a built-in or internal function identifier to the hash. ID is
462 the name of its CFN_* enumeration value. */
464 template <typename T
>
466 add_function (T code
, const char *id
)
468 fn_id
*fn
= new fn_id (code
, id
);
469 id_base
**slot
= operators
->find_slot_with_hash (fn
, fn
->hashval
, INSERT
);
471 fatal ("duplicate id definition");
475 /* Helper for easy comparing ID with tree code CODE. */
478 operator==(id_base
&id
, enum tree_code code
)
480 if (operator_id
*oid
= dyn_cast
<operator_id
*> (&id
))
481 return oid
->code
== code
;
485 /* Lookup the identifier ID. Allow "null" if ALLOW_NULL. */
488 get_operator (const char *id
, bool allow_null
= false)
490 if (allow_null
&& strcmp (id
, "null") == 0)
493 id_base
tem (id_base::CODE
, id
);
495 id_base
*op
= operators
->find_with_hash (&tem
, tem
.hashval
);
498 /* If this is a user-defined identifier track whether it was used. */
499 if (user_id
*uid
= dyn_cast
<user_id
*> (op
))
505 bool all_upper
= true;
506 bool all_lower
= true;
507 for (unsigned int i
= 0; id
[i
]; ++i
)
510 else if (ISLOWER (id
[i
]))
514 /* Try in caps with _EXPR appended. */
515 id2
= ACONCAT ((id
, "_EXPR", NULL
));
516 for (unsigned int i
= 0; id2
[i
]; ++i
)
517 id2
[i
] = TOUPPER (id2
[i
]);
519 else if (all_upper
&& strncmp (id
, "IFN_", 4) == 0)
520 /* Try CFN_ instead of IFN_. */
521 id2
= ACONCAT (("CFN_", id
+ 4, NULL
));
522 else if (all_upper
&& strncmp (id
, "BUILT_IN_", 9) == 0)
523 /* Try prepending CFN_. */
524 id2
= ACONCAT (("CFN_", id
, NULL
));
528 new (&tem
) id_base (id_base::CODE
, id2
);
529 return operators
->find_with_hash (&tem
, tem
.hashval
);
532 typedef hash_map
<nofree_string_hash
, unsigned> cid_map_t
;
535 /* The AST produced by parsing of the pattern definitions. */
540 /* The base class for operands. */
543 enum op_type
{ OP_PREDICATE
, OP_EXPR
, OP_CAPTURE
, OP_C_EXPR
, OP_IF
, OP_WITH
};
544 operand (enum op_type type_
, source_location loc_
)
545 : type (type_
), location (loc_
) {}
547 source_location location
;
548 virtual void gen_transform (FILE *, int, const char *, bool, int,
549 const char *, capture_info
*,
552 { gcc_unreachable (); }
555 /* A predicate operand. Predicates are leafs in the AST. */
557 struct predicate
: public operand
559 predicate (predicate_id
*p_
, source_location loc
)
560 : operand (OP_PREDICATE
, loc
), p (p_
) {}
564 /* An operand that constitutes an expression. Expressions include
565 function calls and user-defined predicate invocations. */
567 struct expr
: public operand
569 expr (id_base
*operation_
, source_location loc
, bool is_commutative_
= false)
570 : operand (OP_EXPR
, loc
), operation (operation_
),
571 ops (vNULL
), expr_type (NULL
), is_commutative (is_commutative_
),
572 is_generic (false), force_single_use (false) {}
574 : operand (OP_EXPR
, e
->location
), operation (e
->operation
),
575 ops (vNULL
), expr_type (e
->expr_type
), is_commutative (e
->is_commutative
),
576 is_generic (e
->is_generic
), force_single_use (e
->force_single_use
) {}
577 void append_op (operand
*op
) { ops
.safe_push (op
); }
578 /* The operator and its operands. */
581 /* An explicitely specified type - used exclusively for conversions. */
582 const char *expr_type
;
583 /* Whether the operation is to be applied commutatively. This is
584 later lowered to two separate patterns. */
586 /* Whether the expression is expected to be in GENERIC form. */
588 /* Whether pushing any stmt to the sequence should be conditional
589 on this expression having a single-use. */
590 bool force_single_use
;
591 virtual void gen_transform (FILE *f
, int, const char *, bool, int,
592 const char *, capture_info
*,
593 dt_operand
** = 0, int = 0);
596 /* An operator that is represented by native C code. This is always
597 a leaf operand in the AST. This class is also used to represent
598 the code to be generated for 'if' and 'with' expressions. */
600 struct c_expr
: public operand
602 /* A mapping of an identifier and its replacement. Used to apply
607 id_tab (const char *id_
, const char *oper_
): id (id_
), oper (oper_
) {}
610 c_expr (cpp_reader
*r_
, source_location loc
,
611 vec
<cpp_token
> code_
, unsigned nr_stmts_
,
612 vec
<id_tab
> ids_
, cid_map_t
*capture_ids_
)
613 : operand (OP_C_EXPR
, loc
), r (r_
), code (code_
),
614 capture_ids (capture_ids_
), nr_stmts (nr_stmts_
), ids (ids_
) {}
615 /* cpplib tokens and state to transform this back to source. */
618 cid_map_t
*capture_ids
;
619 /* The number of statements parsed (well, the number of ';'s). */
621 /* The identifier replacement vector. */
623 virtual void gen_transform (FILE *f
, int, const char *, bool, int,
624 const char *, capture_info
*,
625 dt_operand
** = 0, int = 0);
628 /* A wrapper around another operand that captures its value. */
630 struct capture
: public operand
632 capture (source_location loc
, unsigned where_
, operand
*what_
)
633 : operand (OP_CAPTURE
, loc
), where (where_
), what (what_
) {}
634 /* Identifier index for the value. */
636 /* The captured value. */
638 virtual void gen_transform (FILE *f
, int, const char *, bool, int,
639 const char *, capture_info
*,
640 dt_operand
** = 0, int = 0);
645 struct if_expr
: public operand
647 if_expr (source_location loc
)
648 : operand (OP_IF
, loc
), cond (NULL
), trueexpr (NULL
), falseexpr (NULL
) {}
654 /* with expression. */
656 struct with_expr
: public operand
658 with_expr (source_location loc
)
659 : operand (OP_WITH
, loc
), with (NULL
), subexpr (NULL
) {}
667 is_a_helper
<capture
*>::test (operand
*op
)
669 return op
->type
== operand::OP_CAPTURE
;
675 is_a_helper
<predicate
*>::test (operand
*op
)
677 return op
->type
== operand::OP_PREDICATE
;
683 is_a_helper
<c_expr
*>::test (operand
*op
)
685 return op
->type
== operand::OP_C_EXPR
;
691 is_a_helper
<expr
*>::test (operand
*op
)
693 return op
->type
== operand::OP_EXPR
;
699 is_a_helper
<if_expr
*>::test (operand
*op
)
701 return op
->type
== operand::OP_IF
;
707 is_a_helper
<with_expr
*>::test (operand
*op
)
709 return op
->type
== operand::OP_WITH
;
712 /* The main class of a pattern and its transform. This is used to
713 represent both (simplify ...) and (match ...) kinds. The AST
714 duplicates all outer 'if' and 'for' expressions here so each
715 simplify can exist in isolation. */
719 enum simplify_kind
{ SIMPLIFY
, MATCH
};
721 simplify (simplify_kind kind_
, operand
*match_
, operand
*result_
,
722 vec
<vec
<user_id
*> > for_vec_
, cid_map_t
*capture_ids_
)
723 : kind (kind_
), match (match_
), result (result_
),
724 for_vec (for_vec_
), for_subst_vec (vNULL
),
725 capture_ids (capture_ids_
), capture_max (capture_ids_
->elements () - 1) {}
728 /* The expression that is matched against the GENERIC or GIMPLE IL. */
730 /* For a (simplify ...) an expression with ifs and withs with the expression
731 produced when the pattern applies in the leafs.
732 For a (match ...) the leafs are either empty if it is a simple predicate
733 or the single expression specifying the matched operands. */
734 struct operand
*result
;
735 /* Collected 'for' expression operators that have to be replaced
736 in the lowering phase. */
737 vec
<vec
<user_id
*> > for_vec
;
738 vec
<std::pair
<user_id
*, id_base
*> > for_subst_vec
;
739 /* A map of capture identifiers to indexes. */
740 cid_map_t
*capture_ids
;
744 /* Debugging routines for dumping the AST. */
747 print_operand (operand
*o
, FILE *f
= stderr
, bool flattened
= false)
749 if (capture
*c
= dyn_cast
<capture
*> (o
))
751 if (c
->what
&& flattened
== false)
752 print_operand (c
->what
, f
, flattened
);
753 fprintf (f
, "@%u", c
->where
);
756 else if (predicate
*p
= dyn_cast
<predicate
*> (o
))
757 fprintf (f
, "%s", p
->p
->id
);
759 else if (is_a
<c_expr
*> (o
))
760 fprintf (f
, "c_expr");
762 else if (expr
*e
= dyn_cast
<expr
*> (o
))
764 if (e
->ops
.length () == 0)
765 fprintf (f
, "%s", e
->operation
->id
);
768 fprintf (f
, "(%s", e
->operation
->id
);
770 if (flattened
== false)
772 for (unsigned i
= 0; i
< e
->ops
.length (); ++i
)
775 print_operand (e
->ops
[i
], f
, flattened
);
787 print_matches (struct simplify
*s
, FILE *f
= stderr
)
789 fprintf (f
, "for expression: ");
790 print_operand (s
->match
, f
);
797 /* Lowering of commutative operators. */
800 cartesian_product (const vec
< vec
<operand
*> >& ops_vector
,
801 vec
< vec
<operand
*> >& result
, vec
<operand
*>& v
, unsigned n
)
803 if (n
== ops_vector
.length ())
805 vec
<operand
*> xv
= v
.copy ();
806 result
.safe_push (xv
);
810 for (unsigned i
= 0; i
< ops_vector
[n
].length (); ++i
)
812 v
[n
] = ops_vector
[n
][i
];
813 cartesian_product (ops_vector
, result
, v
, n
+ 1);
817 /* Lower OP to two operands in case it is marked as commutative. */
819 static vec
<operand
*>
820 commutate (operand
*op
)
822 vec
<operand
*> ret
= vNULL
;
824 if (capture
*c
= dyn_cast
<capture
*> (op
))
831 vec
<operand
*> v
= commutate (c
->what
);
832 for (unsigned i
= 0; i
< v
.length (); ++i
)
834 capture
*nc
= new capture (c
->location
, c
->where
, v
[i
]);
840 expr
*e
= dyn_cast
<expr
*> (op
);
841 if (!e
|| e
->ops
.length () == 0)
847 vec
< vec
<operand
*> > ops_vector
= vNULL
;
848 for (unsigned i
= 0; i
< e
->ops
.length (); ++i
)
849 ops_vector
.safe_push (commutate (e
->ops
[i
]));
851 auto_vec
< vec
<operand
*> > result
;
852 auto_vec
<operand
*> v (e
->ops
.length ());
853 v
.quick_grow_cleared (e
->ops
.length ());
854 cartesian_product (ops_vector
, result
, v
, 0);
857 for (unsigned i
= 0; i
< result
.length (); ++i
)
859 expr
*ne
= new expr (e
);
860 ne
->is_commutative
= false;
861 for (unsigned j
= 0; j
< result
[i
].length (); ++j
)
862 ne
->append_op (result
[i
][j
]);
866 if (!e
->is_commutative
)
869 for (unsigned i
= 0; i
< result
.length (); ++i
)
871 expr
*ne
= new expr (e
);
872 ne
->is_commutative
= false;
873 // result[i].length () is 2 since e->operation is binary
874 for (unsigned j
= result
[i
].length (); j
; --j
)
875 ne
->append_op (result
[i
][j
-1]);
882 /* Lower operations marked as commutative in the AST of S and push
883 the resulting patterns to SIMPLIFIERS. */
886 lower_commutative (simplify
*s
, vec
<simplify
*>& simplifiers
)
888 vec
<operand
*> matchers
= commutate (s
->match
);
889 for (unsigned i
= 0; i
< matchers
.length (); ++i
)
891 simplify
*ns
= new simplify (s
->kind
, matchers
[i
], s
->result
,
892 s
->for_vec
, s
->capture_ids
);
893 simplifiers
.safe_push (ns
);
897 /* Strip conditional conversios using operator OPER from O and its
898 children if STRIP, else replace them with an unconditional convert. */
901 lower_opt_convert (operand
*o
, enum tree_code oper
,
902 enum tree_code to_oper
, bool strip
)
904 if (capture
*c
= dyn_cast
<capture
*> (o
))
907 return new capture (c
->location
, c
->where
,
908 lower_opt_convert (c
->what
, oper
, to_oper
, strip
));
913 expr
*e
= dyn_cast
<expr
*> (o
);
917 if (*e
->operation
== oper
)
920 return lower_opt_convert (e
->ops
[0], oper
, to_oper
, strip
);
922 expr
*ne
= new expr (e
);
923 ne
->operation
= (to_oper
== CONVERT_EXPR
924 ? get_operator ("CONVERT_EXPR")
925 : get_operator ("VIEW_CONVERT_EXPR"));
926 ne
->append_op (lower_opt_convert (e
->ops
[0], oper
, to_oper
, strip
));
930 expr
*ne
= new expr (e
);
931 for (unsigned i
= 0; i
< e
->ops
.length (); ++i
)
932 ne
->append_op (lower_opt_convert (e
->ops
[i
], oper
, to_oper
, strip
));
937 /* Determine whether O or its children uses the conditional conversion
941 has_opt_convert (operand
*o
, enum tree_code oper
)
943 if (capture
*c
= dyn_cast
<capture
*> (o
))
946 return has_opt_convert (c
->what
, oper
);
951 expr
*e
= dyn_cast
<expr
*> (o
);
955 if (*e
->operation
== oper
)
958 for (unsigned i
= 0; i
< e
->ops
.length (); ++i
)
959 if (has_opt_convert (e
->ops
[i
], oper
))
965 /* Lower conditional convert operators in O, expanding it to a vector
968 static vec
<operand
*>
969 lower_opt_convert (operand
*o
)
971 vec
<operand
*> v1
= vNULL
, v2
;
975 enum tree_code opers
[]
976 = { CONVERT0
, CONVERT_EXPR
,
977 CONVERT1
, CONVERT_EXPR
,
978 CONVERT2
, CONVERT_EXPR
,
979 VIEW_CONVERT0
, VIEW_CONVERT_EXPR
,
980 VIEW_CONVERT1
, VIEW_CONVERT_EXPR
,
981 VIEW_CONVERT2
, VIEW_CONVERT_EXPR
};
983 /* Conditional converts are lowered to a pattern with the
984 conversion and one without. The three different conditional
985 convert codes are lowered separately. */
987 for (unsigned i
= 0; i
< sizeof (opers
) / sizeof (enum tree_code
); i
+= 2)
990 for (unsigned j
= 0; j
< v1
.length (); ++j
)
991 if (has_opt_convert (v1
[j
], opers
[i
]))
993 v2
.safe_push (lower_opt_convert (v1
[j
],
994 opers
[i
], opers
[i
+1], false));
995 v2
.safe_push (lower_opt_convert (v1
[j
],
996 opers
[i
], opers
[i
+1], true));
1002 for (unsigned j
= 0; j
< v2
.length (); ++j
)
1003 v1
.safe_push (v2
[j
]);
1010 /* Lower conditional convert operators in the AST of S and push
1011 the resulting multiple patterns to SIMPLIFIERS. */
1014 lower_opt_convert (simplify
*s
, vec
<simplify
*>& simplifiers
)
1016 vec
<operand
*> matchers
= lower_opt_convert (s
->match
);
1017 for (unsigned i
= 0; i
< matchers
.length (); ++i
)
1019 simplify
*ns
= new simplify (s
->kind
, matchers
[i
], s
->result
,
1020 s
->for_vec
, s
->capture_ids
);
1021 simplifiers
.safe_push (ns
);
1025 /* Lower the compare operand of COND_EXPRs and VEC_COND_EXPRs to a
1026 GENERIC and a GIMPLE variant. */
1028 static vec
<operand
*>
1029 lower_cond (operand
*o
)
1031 vec
<operand
*> ro
= vNULL
;
1033 if (capture
*c
= dyn_cast
<capture
*> (o
))
1037 vec
<operand
*> lop
= vNULL
;
1038 lop
= lower_cond (c
->what
);
1040 for (unsigned i
= 0; i
< lop
.length (); ++i
)
1041 ro
.safe_push (new capture (c
->location
, c
->where
, lop
[i
]));
1046 expr
*e
= dyn_cast
<expr
*> (o
);
1047 if (!e
|| e
->ops
.length () == 0)
1053 vec
< vec
<operand
*> > ops_vector
= vNULL
;
1054 for (unsigned i
= 0; i
< e
->ops
.length (); ++i
)
1055 ops_vector
.safe_push (lower_cond (e
->ops
[i
]));
1057 auto_vec
< vec
<operand
*> > result
;
1058 auto_vec
<operand
*> v (e
->ops
.length ());
1059 v
.quick_grow_cleared (e
->ops
.length ());
1060 cartesian_product (ops_vector
, result
, v
, 0);
1062 for (unsigned i
= 0; i
< result
.length (); ++i
)
1064 expr
*ne
= new expr (e
);
1065 for (unsigned j
= 0; j
< result
[i
].length (); ++j
)
1066 ne
->append_op (result
[i
][j
]);
1068 /* If this is a COND with a captured expression or an
1069 expression with two operands then also match a GENERIC
1070 form on the compare. */
1071 if ((*e
->operation
== COND_EXPR
1072 || *e
->operation
== VEC_COND_EXPR
)
1073 && ((is_a
<capture
*> (e
->ops
[0])
1074 && as_a
<capture
*> (e
->ops
[0])->what
1075 && is_a
<expr
*> (as_a
<capture
*> (e
->ops
[0])->what
)
1077 (as_a
<capture
*> (e
->ops
[0])->what
)->ops
.length () == 2)
1078 || (is_a
<expr
*> (e
->ops
[0])
1079 && as_a
<expr
*> (e
->ops
[0])->ops
.length () == 2)))
1081 expr
*ne
= new expr (e
);
1082 for (unsigned j
= 0; j
< result
[i
].length (); ++j
)
1083 ne
->append_op (result
[i
][j
]);
1084 if (capture
*c
= dyn_cast
<capture
*> (ne
->ops
[0]))
1086 expr
*ocmp
= as_a
<expr
*> (c
->what
);
1087 expr
*cmp
= new expr (ocmp
);
1088 for (unsigned j
= 0; j
< ocmp
->ops
.length (); ++j
)
1089 cmp
->append_op (ocmp
->ops
[j
]);
1090 cmp
->is_generic
= true;
1091 ne
->ops
[0] = new capture (c
->location
, c
->where
, cmp
);
1095 expr
*ocmp
= as_a
<expr
*> (ne
->ops
[0]);
1096 expr
*cmp
= new expr (ocmp
);
1097 for (unsigned j
= 0; j
< ocmp
->ops
.length (); ++j
)
1098 cmp
->append_op (ocmp
->ops
[j
]);
1099 cmp
->is_generic
= true;
1109 /* Lower the compare operand of COND_EXPRs and VEC_COND_EXPRs to a
1110 GENERIC and a GIMPLE variant. */
1113 lower_cond (simplify
*s
, vec
<simplify
*>& simplifiers
)
1115 vec
<operand
*> matchers
= lower_cond (s
->match
);
1116 for (unsigned i
= 0; i
< matchers
.length (); ++i
)
1118 simplify
*ns
= new simplify (s
->kind
, matchers
[i
], s
->result
,
1119 s
->for_vec
, s
->capture_ids
);
1120 simplifiers
.safe_push (ns
);
1124 /* Return true if O refers to ID. */
1127 contains_id (operand
*o
, user_id
*id
)
1129 if (capture
*c
= dyn_cast
<capture
*> (o
))
1130 return c
->what
&& contains_id (c
->what
, id
);
1132 if (expr
*e
= dyn_cast
<expr
*> (o
))
1134 if (e
->operation
== id
)
1136 for (unsigned i
= 0; i
< e
->ops
.length (); ++i
)
1137 if (contains_id (e
->ops
[i
], id
))
1142 if (with_expr
*w
= dyn_cast
<with_expr
*> (o
))
1143 return (contains_id (w
->with
, id
)
1144 || contains_id (w
->subexpr
, id
));
1146 if (if_expr
*ife
= dyn_cast
<if_expr
*> (o
))
1147 return (contains_id (ife
->cond
, id
)
1148 || contains_id (ife
->trueexpr
, id
)
1149 || (ife
->falseexpr
&& contains_id (ife
->falseexpr
, id
)));
1151 if (c_expr
*ce
= dyn_cast
<c_expr
*> (o
))
1152 return ce
->capture_ids
&& ce
->capture_ids
->get (id
->id
);
1158 /* In AST operand O replace operator ID with operator WITH. */
1161 replace_id (operand
*o
, user_id
*id
, id_base
*with
)
1163 /* Deep-copy captures and expressions, replacing operations as
1165 if (capture
*c
= dyn_cast
<capture
*> (o
))
1169 return new capture (c
->location
, c
->where
,
1170 replace_id (c
->what
, id
, with
));
1172 else if (expr
*e
= dyn_cast
<expr
*> (o
))
1174 expr
*ne
= new expr (e
);
1175 if (e
->operation
== id
)
1176 ne
->operation
= with
;
1177 for (unsigned i
= 0; i
< e
->ops
.length (); ++i
)
1178 ne
->append_op (replace_id (e
->ops
[i
], id
, with
));
1181 else if (with_expr
*w
= dyn_cast
<with_expr
*> (o
))
1183 with_expr
*nw
= new with_expr (w
->location
);
1184 nw
->with
= as_a
<c_expr
*> (replace_id (w
->with
, id
, with
));
1185 nw
->subexpr
= replace_id (w
->subexpr
, id
, with
);
1188 else if (if_expr
*ife
= dyn_cast
<if_expr
*> (o
))
1190 if_expr
*nife
= new if_expr (ife
->location
);
1191 nife
->cond
= as_a
<c_expr
*> (replace_id (ife
->cond
, id
, with
));
1192 nife
->trueexpr
= replace_id (ife
->trueexpr
, id
, with
);
1194 nife
->falseexpr
= replace_id (ife
->falseexpr
, id
, with
);
1198 /* For c_expr we simply record a string replacement table which is
1199 applied at code-generation time. */
1200 if (c_expr
*ce
= dyn_cast
<c_expr
*> (o
))
1202 vec
<c_expr::id_tab
> ids
= ce
->ids
.copy ();
1203 ids
.safe_push (c_expr::id_tab (id
->id
, with
->id
));
1204 return new c_expr (ce
->r
, ce
->location
,
1205 ce
->code
, ce
->nr_stmts
, ids
, ce
->capture_ids
);
1211 /* Return true if the binary operator OP is ok for delayed substitution
1212 during for lowering. */
1215 binary_ok (operator_id
*op
)
1222 case TRUNC_DIV_EXPR
:
1224 case FLOOR_DIV_EXPR
:
1225 case ROUND_DIV_EXPR
:
1226 case TRUNC_MOD_EXPR
:
1228 case FLOOR_MOD_EXPR
:
1229 case ROUND_MOD_EXPR
:
1231 case EXACT_DIV_EXPR
:
1243 /* Lower recorded fors for SIN and output to SIMPLIFIERS. */
1246 lower_for (simplify
*sin
, vec
<simplify
*>& simplifiers
)
1248 vec
<vec
<user_id
*> >& for_vec
= sin
->for_vec
;
1249 unsigned worklist_start
= 0;
1250 auto_vec
<simplify
*> worklist
;
1251 worklist
.safe_push (sin
);
1253 /* Lower each recorded for separately, operating on the
1254 set of simplifiers created by the previous one.
1255 Lower inner-to-outer so inner for substitutes can refer
1256 to operators replaced by outer fors. */
1257 for (int fi
= for_vec
.length () - 1; fi
>= 0; --fi
)
1259 vec
<user_id
*>& ids
= for_vec
[fi
];
1260 unsigned n_ids
= ids
.length ();
1261 unsigned max_n_opers
= 0;
1262 bool can_delay_subst
= (sin
->kind
== simplify::SIMPLIFY
);
1263 for (unsigned i
= 0; i
< n_ids
; ++i
)
1265 if (ids
[i
]->substitutes
.length () > max_n_opers
)
1266 max_n_opers
= ids
[i
]->substitutes
.length ();
1267 /* Require that all substitutes are of the same kind so that
1268 if we delay substitution to the result op code generation
1269 can look at the first substitute for deciding things like
1270 types of operands. */
1271 enum id_base::id_kind kind
= ids
[i
]->substitutes
[0]->kind
;
1272 for (unsigned j
= 0; j
< ids
[i
]->substitutes
.length (); ++j
)
1273 if (ids
[i
]->substitutes
[j
]->kind
!= kind
)
1274 can_delay_subst
= false;
1275 else if (operator_id
*op
1276 = dyn_cast
<operator_id
*> (ids
[i
]->substitutes
[j
]))
1279 = as_a
<operator_id
*> (ids
[i
]->substitutes
[0]);
1280 if (strcmp (op
->tcc
, "tcc_comparison") == 0
1281 && strcmp (op0
->tcc
, "tcc_comparison") == 0)
1283 /* Unfortunately we can't just allow all tcc_binary. */
1284 else if (strcmp (op
->tcc
, "tcc_binary") == 0
1285 && strcmp (op0
->tcc
, "tcc_binary") == 0
1289 else if ((strcmp (op
->id
+ 1, "SHIFT_EXPR") == 0
1290 || strcmp (op
->id
+ 1, "ROTATE_EXPR") == 0)
1291 && (strcmp (op0
->id
+ 1, "SHIFT_EXPR") == 0
1292 || strcmp (op0
->id
+ 1, "ROTATE_EXPR") == 0))
1295 can_delay_subst
= false;
1297 else if (is_a
<fn_id
*> (ids
[i
]->substitutes
[j
]))
1300 can_delay_subst
= false;
1303 unsigned worklist_end
= worklist
.length ();
1304 for (unsigned si
= worklist_start
; si
< worklist_end
; ++si
)
1306 simplify
*s
= worklist
[si
];
1307 for (unsigned j
= 0; j
< max_n_opers
; ++j
)
1309 operand
*match_op
= s
->match
;
1310 operand
*result_op
= s
->result
;
1311 vec
<std::pair
<user_id
*, id_base
*> > subst
;
1312 subst
.create (n_ids
);
1314 for (unsigned i
= 0; i
< n_ids
; ++i
)
1316 user_id
*id
= ids
[i
];
1317 id_base
*oper
= id
->substitutes
[j
% id
->substitutes
.length ()];
1319 && (contains_id (match_op
, id
)
1320 || contains_id (result_op
, id
)))
1325 subst
.quick_push (std::make_pair (id
, oper
));
1326 match_op
= replace_id (match_op
, id
, oper
);
1328 && !can_delay_subst
)
1329 result_op
= replace_id (result_op
, id
, oper
);
1336 simplify
*ns
= new simplify (s
->kind
, match_op
, result_op
,
1337 vNULL
, s
->capture_ids
);
1338 ns
->for_subst_vec
.safe_splice (s
->for_subst_vec
);
1341 ns
->for_subst_vec
.safe_splice (subst
);
1344 worklist
.safe_push (ns
);
1347 worklist_start
= worklist_end
;
1350 /* Copy out the result from the last for lowering. */
1351 for (unsigned i
= worklist_start
; i
< worklist
.length (); ++i
)
1352 simplifiers
.safe_push (worklist
[i
]);
1355 /* Lower the AST for everything in SIMPLIFIERS. */
1358 lower (vec
<simplify
*>& simplifiers
, bool gimple
)
1360 auto_vec
<simplify
*> out_simplifiers
;
1361 for (unsigned i
= 0; i
< simplifiers
.length (); ++i
)
1362 lower_opt_convert (simplifiers
[i
], out_simplifiers
);
1364 simplifiers
.truncate (0);
1365 for (unsigned i
= 0; i
< out_simplifiers
.length (); ++i
)
1366 lower_commutative (out_simplifiers
[i
], simplifiers
);
1368 out_simplifiers
.truncate (0);
1370 for (unsigned i
= 0; i
< simplifiers
.length (); ++i
)
1371 lower_cond (simplifiers
[i
], out_simplifiers
);
1373 out_simplifiers
.safe_splice (simplifiers
);
1376 simplifiers
.truncate (0);
1377 for (unsigned i
= 0; i
< out_simplifiers
.length (); ++i
)
1378 lower_for (out_simplifiers
[i
], simplifiers
);
1384 /* The decision tree built for generating GIMPLE and GENERIC pattern
1385 matching code. It represents the 'match' expression of all
1386 simplifies and has those as its leafs. */
1390 /* A hash-map collecting semantically equivalent leafs in the decision
1391 tree for splitting out to separate functions. */
1400 struct sinfo_hashmap_traits
: simple_hashmap_traits
<pointer_hash
<dt_simplify
>,
1403 static inline hashval_t
hash (const key_type
&);
1404 static inline bool equal_keys (const key_type
&, const key_type
&);
1405 template <typename T
> static inline void remove (T
&) {}
1408 typedef hash_map
<void * /* unused */, sinfo
*, sinfo_hashmap_traits
>
1412 /* Decision tree base class, used for DT_TRUE and DT_NODE. */
1416 enum dt_type
{ DT_NODE
, DT_OPERAND
, DT_TRUE
, DT_MATCH
, DT_SIMPLIFY
};
1420 vec
<dt_node
*> kids
;
1424 unsigned total_size
;
1427 dt_node (enum dt_type type_
): type (type_
), level (0), kids (vNULL
) {}
1429 dt_node
*append_node (dt_node
*);
1430 dt_node
*append_op (operand
*, dt_node
*parent
= 0, unsigned pos
= 0);
1431 dt_node
*append_true_op (dt_node
*parent
= 0, unsigned pos
= 0);
1432 dt_node
*append_match_op (dt_operand
*, dt_node
*parent
= 0, unsigned pos
= 0);
1433 dt_node
*append_simplify (simplify
*, unsigned, dt_operand
**);
1435 virtual void gen (FILE *, int, bool) {}
1437 void gen_kids (FILE *, int, bool);
1438 void gen_kids_1 (FILE *, int, bool,
1439 vec
<dt_operand
*>, vec
<dt_operand
*>, vec
<dt_operand
*>,
1440 vec
<dt_operand
*>, vec
<dt_operand
*>, vec
<dt_node
*>);
1442 void analyze (sinfo_map_t
&);
1445 /* Generic decision tree node used for DT_OPERAND and DT_MATCH. */
1447 struct dt_operand
: public dt_node
1450 dt_operand
*match_dop
;
1454 dt_operand (enum dt_type type
, operand
*op_
, dt_operand
*match_dop_
,
1455 dt_operand
*parent_
= 0, unsigned pos_
= 0)
1456 : dt_node (type
), op (op_
), match_dop (match_dop_
),
1457 parent (parent_
), pos (pos_
) {}
1459 void gen (FILE *, int, bool);
1460 unsigned gen_predicate (FILE *, int, const char *, bool);
1461 unsigned gen_match_op (FILE *, int, const char *);
1463 unsigned gen_gimple_expr (FILE *, int);
1464 unsigned gen_generic_expr (FILE *, int, const char *);
1466 char *get_name (char *);
1467 void gen_opname (char *, unsigned);
1470 /* Leaf node of the decision tree, used for DT_SIMPLIFY. */
1472 struct dt_simplify
: public dt_node
1475 unsigned pattern_no
;
1476 dt_operand
**indexes
;
1479 dt_simplify (simplify
*s_
, unsigned pattern_no_
, dt_operand
**indexes_
)
1480 : dt_node (DT_SIMPLIFY
), s (s_
), pattern_no (pattern_no_
),
1481 indexes (indexes_
), info (NULL
) {}
1483 void gen_1 (FILE *, int, bool, operand
*);
1484 void gen (FILE *f
, int, bool);
1490 is_a_helper
<dt_operand
*>::test (dt_node
*n
)
1492 return (n
->type
== dt_node::DT_OPERAND
1493 || n
->type
== dt_node::DT_MATCH
);
1499 is_a_helper
<dt_simplify
*>::test (dt_node
*n
)
1501 return n
->type
== dt_node::DT_SIMPLIFY
;
1506 /* A container for the actual decision tree. */
1508 struct decision_tree
1512 void insert (struct simplify
*, unsigned);
1513 void gen (FILE *f
, bool gimple
);
1514 void print (FILE *f
= stderr
);
1516 decision_tree () { root
= new dt_node (dt_node::DT_NODE
); }
1518 static dt_node
*insert_operand (dt_node
*, operand
*, dt_operand
**indexes
,
1519 unsigned pos
= 0, dt_node
*parent
= 0);
1520 static dt_node
*find_node (vec
<dt_node
*>&, dt_node
*);
1521 static bool cmp_node (dt_node
*, dt_node
*);
1522 static void print_node (dt_node
*, FILE *f
= stderr
, unsigned = 0);
1525 /* Compare two AST operands O1 and O2 and return true if they are equal. */
1528 cmp_operand (operand
*o1
, operand
*o2
)
1530 if (!o1
|| !o2
|| o1
->type
!= o2
->type
)
1533 if (o1
->type
== operand::OP_PREDICATE
)
1535 predicate
*p1
= as_a
<predicate
*>(o1
);
1536 predicate
*p2
= as_a
<predicate
*>(o2
);
1537 return p1
->p
== p2
->p
;
1539 else if (o1
->type
== operand::OP_EXPR
)
1541 expr
*e1
= static_cast<expr
*>(o1
);
1542 expr
*e2
= static_cast<expr
*>(o2
);
1543 return (e1
->operation
== e2
->operation
1544 && e1
->is_generic
== e2
->is_generic
);
1550 /* Compare two decision tree nodes N1 and N2 and return true if they
1554 decision_tree::cmp_node (dt_node
*n1
, dt_node
*n2
)
1556 if (!n1
|| !n2
|| n1
->type
!= n2
->type
)
1562 if (n1
->type
== dt_node::DT_TRUE
)
1565 if (n1
->type
== dt_node::DT_OPERAND
)
1566 return cmp_operand ((as_a
<dt_operand
*> (n1
))->op
,
1567 (as_a
<dt_operand
*> (n2
))->op
);
1568 else if (n1
->type
== dt_node::DT_MATCH
)
1569 return ((as_a
<dt_operand
*> (n1
))->match_dop
1570 == (as_a
<dt_operand
*> (n2
))->match_dop
);
1574 /* Search OPS for a decision tree node like P and return it if found. */
1577 decision_tree::find_node (vec
<dt_node
*>& ops
, dt_node
*p
)
1579 /* We can merge adjacent DT_TRUE. */
1580 if (p
->type
== dt_node::DT_TRUE
1582 && ops
.last ()->type
== dt_node::DT_TRUE
)
1584 for (int i
= ops
.length () - 1; i
>= 0; --i
)
1586 /* But we can't merge across DT_TRUE nodes as they serve as
1587 pattern order barriers to make sure that patterns apply
1588 in order of appearance in case multiple matches are possible. */
1589 if (ops
[i
]->type
== dt_node::DT_TRUE
)
1591 if (decision_tree::cmp_node (ops
[i
], p
))
1597 /* Append N to the decision tree if it there is not already an existing
1601 dt_node::append_node (dt_node
*n
)
1605 kid
= decision_tree::find_node (kids
, n
);
1610 n
->level
= this->level
+ 1;
1615 /* Append OP to the decision tree. */
1618 dt_node::append_op (operand
*op
, dt_node
*parent
, unsigned pos
)
1620 dt_operand
*parent_
= safe_as_a
<dt_operand
*> (parent
);
1621 dt_operand
*n
= new dt_operand (DT_OPERAND
, op
, 0, parent_
, pos
);
1622 return append_node (n
);
1625 /* Append a DT_TRUE decision tree node. */
1628 dt_node::append_true_op (dt_node
*parent
, unsigned pos
)
1630 dt_operand
*parent_
= safe_as_a
<dt_operand
*> (parent
);
1631 dt_operand
*n
= new dt_operand (DT_TRUE
, 0, 0, parent_
, pos
);
1632 return append_node (n
);
1635 /* Append a DT_MATCH decision tree node. */
1638 dt_node::append_match_op (dt_operand
*match_dop
, dt_node
*parent
, unsigned pos
)
1640 dt_operand
*parent_
= as_a
<dt_operand
*> (parent
);
1641 dt_operand
*n
= new dt_operand (DT_MATCH
, 0, match_dop
, parent_
, pos
);
1642 return append_node (n
);
1645 /* Append S to the decision tree. */
1648 dt_node::append_simplify (simplify
*s
, unsigned pattern_no
,
1649 dt_operand
**indexes
)
1651 dt_simplify
*n
= new dt_simplify (s
, pattern_no
, indexes
);
1652 for (unsigned i
= 0; i
< kids
.length (); ++i
)
1653 if (dt_simplify
*s2
= dyn_cast
<dt_simplify
*> (kids
[i
]))
1655 warning_at (s
->match
->location
, "duplicate pattern");
1656 warning_at (s2
->s
->match
->location
, "previous pattern defined here");
1657 print_operand (s
->match
, stderr
);
1658 fprintf (stderr
, "\n");
1660 return append_node (n
);
1663 /* Analyze the node and its children. */
1666 dt_node::analyze (sinfo_map_t
&map
)
1672 if (type
== DT_SIMPLIFY
)
1674 /* Populate the map of equivalent simplifies. */
1675 dt_simplify
*s
= as_a
<dt_simplify
*> (this);
1677 sinfo
*&si
= map
.get_or_insert (s
, &existed
);
1692 for (unsigned i
= 0; i
< kids
.length (); ++i
)
1694 kids
[i
]->analyze (map
);
1695 num_leafs
+= kids
[i
]->num_leafs
;
1696 total_size
+= kids
[i
]->total_size
;
1697 max_level
= MAX (max_level
, kids
[i
]->max_level
);
1701 /* Insert O into the decision tree and return the decision tree node found
1705 decision_tree::insert_operand (dt_node
*p
, operand
*o
, dt_operand
**indexes
,
1706 unsigned pos
, dt_node
*parent
)
1708 dt_node
*q
, *elm
= 0;
1710 if (capture
*c
= dyn_cast
<capture
*> (o
))
1712 unsigned capt_index
= c
->where
;
1714 if (indexes
[capt_index
] == 0)
1717 q
= insert_operand (p
, c
->what
, indexes
, pos
, parent
);
1720 q
= elm
= p
->append_true_op (parent
, pos
);
1723 // get to the last capture
1724 for (operand
*what
= c
->what
;
1725 what
&& is_a
<capture
*> (what
);
1726 c
= as_a
<capture
*> (what
), what
= c
->what
)
1731 unsigned cc_index
= c
->where
;
1732 dt_operand
*match_op
= indexes
[cc_index
];
1734 dt_operand
temp (dt_node::DT_TRUE
, 0, 0);
1735 elm
= decision_tree::find_node (p
->kids
, &temp
);
1739 dt_operand
temp (dt_node::DT_MATCH
, 0, match_op
);
1740 elm
= decision_tree::find_node (p
->kids
, &temp
);
1745 dt_operand
temp (dt_node::DT_OPERAND
, c
->what
, 0);
1746 elm
= decision_tree::find_node (p
->kids
, &temp
);
1750 gcc_assert (elm
->type
== dt_node::DT_TRUE
1751 || elm
->type
== dt_node::DT_OPERAND
1752 || elm
->type
== dt_node::DT_MATCH
);
1753 indexes
[capt_index
] = static_cast<dt_operand
*> (elm
);
1758 p
= p
->append_match_op (indexes
[capt_index
], parent
, pos
);
1760 return insert_operand (p
, c
->what
, indexes
, 0, p
);
1765 p
= p
->append_op (o
, parent
, pos
);
1768 if (expr
*e
= dyn_cast
<expr
*>(o
))
1770 for (unsigned i
= 0; i
< e
->ops
.length (); ++i
)
1771 q
= decision_tree::insert_operand (q
, e
->ops
[i
], indexes
, i
, p
);
1777 /* Insert S into the decision tree. */
1780 decision_tree::insert (struct simplify
*s
, unsigned pattern_no
)
1782 dt_operand
**indexes
= XCNEWVEC (dt_operand
*, s
->capture_max
+ 1);
1783 dt_node
*p
= decision_tree::insert_operand (root
, s
->match
, indexes
);
1784 p
->append_simplify (s
, pattern_no
, indexes
);
1787 /* Debug functions to dump the decision tree. */
1790 decision_tree::print_node (dt_node
*p
, FILE *f
, unsigned indent
)
1792 if (p
->type
== dt_node::DT_NODE
)
1793 fprintf (f
, "root");
1797 for (unsigned i
= 0; i
< indent
; i
++)
1800 if (p
->type
== dt_node::DT_OPERAND
)
1802 dt_operand
*dop
= static_cast<dt_operand
*>(p
);
1803 print_operand (dop
->op
, f
, true);
1805 else if (p
->type
== dt_node::DT_TRUE
)
1806 fprintf (f
, "true");
1807 else if (p
->type
== dt_node::DT_MATCH
)
1808 fprintf (f
, "match (%p)", (void *)((as_a
<dt_operand
*>(p
))->match_dop
));
1809 else if (p
->type
== dt_node::DT_SIMPLIFY
)
1811 dt_simplify
*s
= static_cast<dt_simplify
*> (p
);
1812 fprintf (f
, "simplify_%u { ", s
->pattern_no
);
1813 for (int i
= 0; i
<= s
->s
->capture_max
; ++i
)
1814 fprintf (f
, "%p, ", (void *) s
->indexes
[i
]);
1819 fprintf (stderr
, " (%p), %u, %u\n", (void *) p
, p
->level
, p
->kids
.length ());
1821 for (unsigned i
= 0; i
< p
->kids
.length (); ++i
)
1822 decision_tree::print_node (p
->kids
[i
], f
, indent
+ 2);
1826 decision_tree::print (FILE *f
)
1828 return decision_tree::print_node (root
, f
);
1832 /* For GENERIC we have to take care of wrapping multiple-used
1833 expressions with side-effects in save_expr and preserve side-effects
1834 of expressions with omit_one_operand. Analyze captures in
1835 match, result and with expressions and perform early-outs
1836 on the outermost match expression operands for cases we cannot
1841 capture_info (simplify
*s
, operand
*, bool);
1842 void walk_match (operand
*o
, unsigned toplevel_arg
, bool, bool);
1843 bool walk_result (operand
*o
, bool, operand
*);
1844 void walk_c_expr (c_expr
*);
1850 bool force_no_side_effects_p
;
1851 bool force_single_use
;
1852 bool cond_expr_cond_p
;
1853 unsigned long toplevel_msk
;
1854 unsigned match_use_count
;
1855 unsigned result_use_count
;
1860 auto_vec
<cinfo
> info
;
1861 unsigned long force_no_side_effects
;
1865 /* Analyze captures in S. */
1867 capture_info::capture_info (simplify
*s
, operand
*result
, bool gimple_
)
1872 if (s
->kind
== simplify::MATCH
)
1874 force_no_side_effects
= -1;
1878 force_no_side_effects
= 0;
1879 info
.safe_grow_cleared (s
->capture_max
+ 1);
1880 for (int i
= 0; i
<= s
->capture_max
; ++i
)
1881 info
[i
].same_as
= i
;
1883 e
= as_a
<expr
*> (s
->match
);
1884 for (unsigned i
= 0; i
< e
->ops
.length (); ++i
)
1885 walk_match (e
->ops
[i
], i
,
1886 (i
!= 0 && *e
->operation
== COND_EXPR
)
1887 || *e
->operation
== TRUTH_ANDIF_EXPR
1888 || *e
->operation
== TRUTH_ORIF_EXPR
,
1890 && (*e
->operation
== COND_EXPR
1891 || *e
->operation
== VEC_COND_EXPR
));
1893 walk_result (s
->result
, false, result
);
1896 /* Analyze captures in the match expression piece O. */
1899 capture_info::walk_match (operand
*o
, unsigned toplevel_arg
,
1900 bool conditional_p
, bool cond_expr_cond_p
)
1902 if (capture
*c
= dyn_cast
<capture
*> (o
))
1904 unsigned where
= c
->where
;
1905 info
[where
].match_use_count
++;
1906 info
[where
].toplevel_msk
|= 1 << toplevel_arg
;
1907 info
[where
].force_no_side_effects_p
|= conditional_p
;
1908 info
[where
].cond_expr_cond_p
|= cond_expr_cond_p
;
1913 /* Recurse to exprs and captures. */
1914 if (is_a
<capture
*> (c
->what
)
1915 || is_a
<expr
*> (c
->what
))
1916 walk_match (c
->what
, toplevel_arg
, conditional_p
, false);
1917 /* We need to look past multiple captures to find a captured
1918 expression as with conditional converts two captures
1919 can be collapsed onto the same expression. Also collect
1920 what captures capture the same thing. */
1921 while (c
->what
&& is_a
<capture
*> (c
->what
))
1923 c
= as_a
<capture
*> (c
->what
);
1924 if (info
[c
->where
].same_as
!= c
->where
1925 && info
[c
->where
].same_as
!= info
[where
].same_as
)
1926 fatal_at (c
->location
, "cannot handle this collapsed capture");
1927 info
[c
->where
].same_as
= info
[where
].same_as
;
1929 /* Mark expr (non-leaf) captures and forced single-use exprs. */
1932 && (e
= dyn_cast
<expr
*> (c
->what
)))
1934 info
[where
].expr_p
= true;
1935 info
[where
].force_single_use
|= e
->force_single_use
;
1938 else if (expr
*e
= dyn_cast
<expr
*> (o
))
1940 for (unsigned i
= 0; i
< e
->ops
.length (); ++i
)
1942 bool cond_p
= conditional_p
;
1943 bool cond_expr_cond_p
= false;
1944 if (i
!= 0 && *e
->operation
== COND_EXPR
)
1946 else if (*e
->operation
== TRUTH_ANDIF_EXPR
1947 || *e
->operation
== TRUTH_ORIF_EXPR
)
1950 && (*e
->operation
== COND_EXPR
1951 || *e
->operation
== VEC_COND_EXPR
))
1952 cond_expr_cond_p
= true;
1953 walk_match (e
->ops
[i
], toplevel_arg
, cond_p
, cond_expr_cond_p
);
1956 else if (is_a
<predicate
*> (o
))
1958 /* Mark non-captured leafs toplevel arg for checking. */
1959 force_no_side_effects
|= 1 << toplevel_arg
;
1962 warning_at (o
->location
,
1963 "forcing no side-effects on possibly lost leaf");
1969 /* Analyze captures in the result expression piece O. Return true
1970 if RESULT was visited in one of the children. Only visit
1971 non-if/with children if they are rooted on RESULT. */
1974 capture_info::walk_result (operand
*o
, bool conditional_p
, operand
*result
)
1976 if (capture
*c
= dyn_cast
<capture
*> (o
))
1978 unsigned where
= info
[c
->where
].same_as
;
1979 info
[where
].result_use_count
++;
1980 /* If we substitute an expression capture we don't know
1981 which captures this will end up using (well, we don't
1982 compute that). Force the uses to be side-effect free
1983 which means forcing the toplevels that reach the
1984 expression side-effect free. */
1985 if (info
[where
].expr_p
)
1986 force_no_side_effects
|= info
[where
].toplevel_msk
;
1987 /* Mark CSE capture uses as forced to have no side-effects. */
1989 && is_a
<expr
*> (c
->what
))
1991 info
[where
].cse_p
= true;
1992 walk_result (c
->what
, true, result
);
1995 else if (expr
*e
= dyn_cast
<expr
*> (o
))
1997 id_base
*opr
= e
->operation
;
1998 if (user_id
*uid
= dyn_cast
<user_id
*> (opr
))
1999 opr
= uid
->substitutes
[0];
2000 for (unsigned i
= 0; i
< e
->ops
.length (); ++i
)
2002 bool cond_p
= conditional_p
;
2003 if (i
!= 0 && *e
->operation
== COND_EXPR
)
2005 else if (*e
->operation
== TRUTH_ANDIF_EXPR
2006 || *e
->operation
== TRUTH_ORIF_EXPR
)
2008 walk_result (e
->ops
[i
], cond_p
, result
);
2011 else if (if_expr
*e
= dyn_cast
<if_expr
*> (o
))
2013 /* 'if' conditions should be all fine. */
2014 if (e
->trueexpr
== result
)
2016 walk_result (e
->trueexpr
, false, result
);
2019 if (e
->falseexpr
== result
)
2021 walk_result (e
->falseexpr
, false, result
);
2025 if (is_a
<if_expr
*> (e
->trueexpr
)
2026 || is_a
<with_expr
*> (e
->trueexpr
))
2027 res
|= walk_result (e
->trueexpr
, false, result
);
2029 && (is_a
<if_expr
*> (e
->falseexpr
)
2030 || is_a
<with_expr
*> (e
->falseexpr
)))
2031 res
|= walk_result (e
->falseexpr
, false, result
);
2034 else if (with_expr
*e
= dyn_cast
<with_expr
*> (o
))
2036 bool res
= (e
->subexpr
== result
);
2038 || is_a
<if_expr
*> (e
->subexpr
)
2039 || is_a
<with_expr
*> (e
->subexpr
))
2040 res
|= walk_result (e
->subexpr
, false, result
);
2042 walk_c_expr (e
->with
);
2045 else if (c_expr
*e
= dyn_cast
<c_expr
*> (o
))
2053 /* Look for captures in the C expr E. */
2056 capture_info::walk_c_expr (c_expr
*e
)
2058 /* Give up for C exprs mentioning captures not inside TREE_TYPE,
2059 TREE_REAL_CST, TREE_CODE or a predicate where they cannot
2060 really escape through. */
2061 unsigned p_depth
= 0;
2062 for (unsigned i
= 0; i
< e
->code
.length (); ++i
)
2064 const cpp_token
*t
= &e
->code
[i
];
2065 const cpp_token
*n
= i
< e
->code
.length () - 1 ? &e
->code
[i
+1] : NULL
;
2067 if (t
->type
== CPP_NAME
2068 && (strcmp ((const char *)CPP_HASHNODE
2069 (t
->val
.node
.node
)->ident
.str
, "TREE_TYPE") == 0
2070 || strcmp ((const char *)CPP_HASHNODE
2071 (t
->val
.node
.node
)->ident
.str
, "TREE_CODE") == 0
2072 || strcmp ((const char *)CPP_HASHNODE
2073 (t
->val
.node
.node
)->ident
.str
, "TREE_REAL_CST") == 0
2074 || ((id
= get_operator ((const char *)CPP_HASHNODE
2075 (t
->val
.node
.node
)->ident
.str
))
2076 && is_a
<predicate_id
*> (id
)))
2077 && n
->type
== CPP_OPEN_PAREN
)
2079 else if (t
->type
== CPP_CLOSE_PAREN
2082 else if (p_depth
== 0
2083 && t
->type
== CPP_ATSIGN
2084 && (n
->type
== CPP_NUMBER
2085 || n
->type
== CPP_NAME
)
2086 && !(n
->flags
& PREV_WHITE
))
2089 if (n
->type
== CPP_NUMBER
)
2090 id
= (const char *)n
->val
.str
.text
;
2092 id
= (const char *)CPP_HASHNODE (n
->val
.node
.node
)->ident
.str
;
2093 unsigned where
= *e
->capture_ids
->get(id
);
2094 info
[info
[where
].same_as
].force_no_side_effects_p
= true;
2097 warning_at (t
, "capture escapes");
2103 /* Code generation off the decision tree and the refered AST nodes. */
2106 is_conversion (id_base
*op
)
2108 return (*op
== CONVERT_EXPR
2110 || *op
== FLOAT_EXPR
2111 || *op
== FIX_TRUNC_EXPR
2112 || *op
== VIEW_CONVERT_EXPR
);
2115 /* Get the type to be used for generating operands of OP from the
2119 get_operand_type (id_base
*op
, const char *in_type
,
2120 const char *expr_type
,
2121 const char *other_oprnd_type
)
2123 /* Generally operands whose type does not match the type of the
2124 expression generated need to know their types but match and
2125 thus can fall back to 'other_oprnd_type'. */
2126 if (is_conversion (op
))
2127 return other_oprnd_type
;
2128 else if (*op
== REALPART_EXPR
2129 || *op
== IMAGPART_EXPR
)
2130 return other_oprnd_type
;
2131 else if (is_a
<operator_id
*> (op
)
2132 && strcmp (as_a
<operator_id
*> (op
)->tcc
, "tcc_comparison") == 0)
2133 return other_oprnd_type
;
2136 /* Otherwise all types should match - choose one in order of
2143 return other_oprnd_type
;
2147 /* Generate transform code for an expression. */
2150 expr::gen_transform (FILE *f
, int indent
, const char *dest
, bool gimple
,
2151 int depth
, const char *in_type
, capture_info
*cinfo
,
2152 dt_operand
**indexes
, int)
2154 id_base
*opr
= operation
;
2155 /* When we delay operator substituting during lowering of fors we
2156 make sure that for code-gen purposes the effects of each substitute
2157 are the same. Thus just look at that. */
2158 if (user_id
*uid
= dyn_cast
<user_id
*> (opr
))
2159 opr
= uid
->substitutes
[0];
2161 bool conversion_p
= is_conversion (opr
);
2162 const char *type
= expr_type
;
2165 /* If there was a type specification in the pattern use it. */
2167 else if (conversion_p
)
2168 /* For conversions we need to build the expression using the
2169 outer type passed in. */
2171 else if (*opr
== REALPART_EXPR
2172 || *opr
== IMAGPART_EXPR
)
2174 /* __real and __imag use the component type of its operand. */
2175 sprintf (optype
, "TREE_TYPE (TREE_TYPE (ops%d[0]))", depth
);
2178 else if (is_a
<operator_id
*> (opr
)
2179 && !strcmp (as_a
<operator_id
*> (opr
)->tcc
, "tcc_comparison"))
2181 /* comparisons use boolean_type_node (or what gets in), but
2182 their operands need to figure out the types themselves. */
2183 sprintf (optype
, "boolean_type_node");
2186 else if (*opr
== COND_EXPR
2187 || *opr
== VEC_COND_EXPR
)
2189 /* Conditions are of the same type as their first alternative. */
2190 sprintf (optype
, "TREE_TYPE (ops%d[1])", depth
);
2195 /* Other operations are of the same type as their first operand. */
2196 sprintf (optype
, "TREE_TYPE (ops%d[0])", depth
);
2200 fatal_at (location
, "cannot determine type of operand");
2202 fprintf_indent (f
, indent
, "{\n");
2204 fprintf_indent (f
, indent
, "tree ops%d[%u], res;\n", depth
, ops
.length ());
2206 snprintf (op0type
, 64, "TREE_TYPE (ops%d[0])", depth
);
2207 for (unsigned i
= 0; i
< ops
.length (); ++i
)
2210 snprintf (dest
, 32, "ops%d[%u]", depth
, i
);
2212 = get_operand_type (opr
, in_type
, expr_type
,
2213 i
== 0 ? NULL
: op0type
);
2214 ops
[i
]->gen_transform (f
, indent
, dest
, gimple
, depth
+ 1, optype
,
2217 || *opr
== VEC_COND_EXPR
) && i
== 0 ? 1 : 2);
2220 const char *opr_name
;
2221 if (*operation
== CONVERT_EXPR
)
2222 opr_name
= "NOP_EXPR";
2224 opr_name
= operation
->id
;
2228 if (*opr
== CONVERT_EXPR
)
2230 fprintf_indent (f
, indent
,
2231 "if (%s != TREE_TYPE (ops%d[0])\n",
2233 fprintf_indent (f
, indent
,
2234 " && !useless_type_conversion_p (%s, TREE_TYPE (ops%d[0])))\n",
2236 fprintf_indent (f
, indent
+ 2, "{\n");
2239 /* ??? Building a stmt can fail for various reasons here, seq being
2240 NULL or the stmt referencing SSA names occuring in abnormal PHIs.
2241 So if we fail here we should continue matching other patterns. */
2242 fprintf_indent (f
, indent
, "code_helper tem_code = %s;\n", opr_name
);
2243 fprintf_indent (f
, indent
, "tree tem_ops[3] = { ");
2244 for (unsigned i
= 0; i
< ops
.length (); ++i
)
2245 fprintf (f
, "ops%d[%u]%s", depth
, i
,
2246 i
== ops
.length () - 1 ? " };\n" : ", ");
2247 fprintf_indent (f
, indent
,
2248 "gimple_resimplify%d (lseq, &tem_code, %s, tem_ops, valueize);\n",
2249 ops
.length (), type
);
2250 fprintf_indent (f
, indent
,
2251 "res = maybe_push_res_to_seq (tem_code, %s, tem_ops, lseq);\n",
2253 fprintf_indent (f
, indent
,
2254 "if (!res) return false;\n");
2255 if (*opr
== CONVERT_EXPR
)
2258 fprintf_indent (f
, indent
, " }\n");
2259 fprintf_indent (f
, indent
, "else\n");
2260 fprintf_indent (f
, indent
, " res = ops%d[0];\n", depth
);
2265 if (*opr
== CONVERT_EXPR
)
2267 fprintf_indent (f
, indent
, "if (TREE_TYPE (ops%d[0]) != %s)\n",
2271 if (opr
->kind
== id_base::CODE
)
2272 fprintf_indent (f
, indent
, "res = fold_build%d_loc (loc, %s, %s",
2273 ops
.length(), opr_name
, type
);
2276 fprintf_indent (f
, indent
, "{\n");
2277 fprintf_indent (f
, indent
, " res = maybe_build_call_expr_loc (loc, "
2278 "%s, %s, %d", opr_name
, type
, ops
.length());
2280 for (unsigned i
= 0; i
< ops
.length (); ++i
)
2281 fprintf (f
, ", ops%d[%u]", depth
, i
);
2282 fprintf (f
, ");\n");
2283 if (opr
->kind
!= id_base::CODE
)
2285 fprintf_indent (f
, indent
, " if (!res)\n");
2286 fprintf_indent (f
, indent
, " return NULL_TREE;\n");
2287 fprintf_indent (f
, indent
, "}\n");
2289 if (*opr
== CONVERT_EXPR
)
2292 fprintf_indent (f
, indent
, "else\n");
2293 fprintf_indent (f
, indent
, " res = ops%d[0];\n", depth
);
2296 fprintf_indent (f
, indent
, "%s = res;\n", dest
);
2298 fprintf_indent (f
, indent
, "}\n");
2301 /* Generate code for a c_expr which is either the expression inside
2302 an if statement or a sequence of statements which computes a
2303 result to be stored to DEST. */
2306 c_expr::gen_transform (FILE *f
, int indent
, const char *dest
,
2307 bool, int, const char *, capture_info
*,
2310 if (dest
&& nr_stmts
== 1)
2311 fprintf_indent (f
, indent
, "%s = ", dest
);
2313 unsigned stmt_nr
= 1;
2314 for (unsigned i
= 0; i
< code
.length (); ++i
)
2316 const cpp_token
*token
= &code
[i
];
2318 /* Replace captures for code-gen. */
2319 if (token
->type
== CPP_ATSIGN
)
2321 const cpp_token
*n
= &code
[i
+1];
2322 if ((n
->type
== CPP_NUMBER
2323 || n
->type
== CPP_NAME
)
2324 && !(n
->flags
& PREV_WHITE
))
2326 if (token
->flags
& PREV_WHITE
)
2329 if (n
->type
== CPP_NUMBER
)
2330 id
= (const char *)n
->val
.str
.text
;
2332 id
= (const char *)CPP_HASHNODE (n
->val
.node
.node
)->ident
.str
;
2333 unsigned *cid
= capture_ids
->get (id
);
2335 fatal_at (token
, "unknown capture id");
2336 fprintf (f
, "captures[%u]", *cid
);
2342 if (token
->flags
& PREV_WHITE
)
2345 if (token
->type
== CPP_NAME
)
2347 const char *id
= (const char *) NODE_NAME (token
->val
.node
.node
);
2349 for (j
= 0; j
< ids
.length (); ++j
)
2351 if (strcmp (id
, ids
[j
].id
) == 0)
2353 fprintf (f
, "%s", ids
[j
].oper
);
2357 if (j
< ids
.length ())
2361 /* Output the token as string. */
2362 char *tk
= (char *)cpp_token_as_text (r
, token
);
2365 if (token
->type
== CPP_SEMICOLON
)
2369 if (dest
&& stmt_nr
== nr_stmts
)
2370 fprintf_indent (f
, indent
, "%s = ", dest
);
2375 /* Generate transform code for a capture. */
2378 capture::gen_transform (FILE *f
, int indent
, const char *dest
, bool gimple
,
2379 int depth
, const char *in_type
, capture_info
*cinfo
,
2380 dt_operand
**indexes
, int cond_handling
)
2382 if (what
&& is_a
<expr
*> (what
))
2384 if (indexes
[where
] == 0)
2387 sprintf (buf
, "captures[%u]", where
);
2388 what
->gen_transform (f
, indent
, buf
, gimple
, depth
, in_type
,
2393 fprintf_indent (f
, indent
, "%s = captures[%u];\n", dest
, where
);
2395 /* ??? Stupid tcc_comparison GENERIC trees in COND_EXPRs. Deal
2396 with substituting a capture of that. */
2398 && cond_handling
!= 0
2399 && cinfo
->info
[where
].cond_expr_cond_p
)
2401 /* If substituting into a cond_expr condition, unshare. */
2402 if (cond_handling
== 1)
2403 fprintf_indent (f
, indent
, "%s = unshare_expr (%s);\n", dest
, dest
);
2404 /* If substituting elsewhere we might need to decompose it. */
2405 else if (cond_handling
== 2)
2407 /* ??? Returning false here will also not allow any other patterns
2408 to match unless this generator was split out. */
2409 fprintf_indent (f
, indent
, "if (COMPARISON_CLASS_P (%s))\n", dest
);
2410 fprintf_indent (f
, indent
, " {\n");
2411 fprintf_indent (f
, indent
, " if (!seq) return false;\n");
2412 fprintf_indent (f
, indent
, " %s = gimple_build (seq,"
2414 " TREE_TYPE (%s), TREE_OPERAND (%s, 0),"
2415 " TREE_OPERAND (%s, 1));\n",
2416 dest
, dest
, dest
, dest
, dest
);
2417 fprintf_indent (f
, indent
, " }\n");
2422 /* Return the name of the operand representing the decision tree node.
2423 Use NAME as space to generate it. */
2426 dt_operand::get_name (char *name
)
2429 sprintf (name
, "t");
2430 else if (parent
->level
== 1)
2431 sprintf (name
, "op%u", pos
);
2432 else if (parent
->type
== dt_node::DT_MATCH
)
2433 return parent
->get_name (name
);
2435 sprintf (name
, "o%u%u", parent
->level
, pos
);
2439 /* Fill NAME with the operand name at position POS. */
2442 dt_operand::gen_opname (char *name
, unsigned pos
)
2445 sprintf (name
, "op%u", pos
);
2447 sprintf (name
, "o%u%u", level
, pos
);
2450 /* Generate matching code for the decision tree operand which is
2454 dt_operand::gen_predicate (FILE *f
, int indent
, const char *opname
, bool gimple
)
2456 predicate
*p
= as_a
<predicate
*> (op
);
2458 if (p
->p
->matchers
.exists ())
2460 /* If this is a predicate generated from a pattern mangle its
2461 name and pass on the valueize hook. */
2463 fprintf_indent (f
, indent
, "if (gimple_%s (%s, valueize))\n",
2466 fprintf_indent (f
, indent
, "if (tree_%s (%s))\n", p
->p
->id
, opname
);
2469 fprintf_indent (f
, indent
, "if (%s (%s))\n", p
->p
->id
, opname
);
2470 fprintf_indent (f
, indent
+ 2, "{\n");
2474 /* Generate matching code for the decision tree operand which is
2478 dt_operand::gen_match_op (FILE *f
, int indent
, const char *opname
)
2480 char match_opname
[20];
2481 match_dop
->get_name (match_opname
);
2482 fprintf_indent (f
, indent
, "if (%s == %s || operand_equal_p (%s, %s, 0))\n",
2483 opname
, match_opname
, opname
, match_opname
);
2484 fprintf_indent (f
, indent
+ 2, "{\n");
2488 /* Generate GIMPLE matching code for the decision tree operand. */
2491 dt_operand::gen_gimple_expr (FILE *f
, int indent
)
2493 expr
*e
= static_cast<expr
*> (op
);
2494 id_base
*id
= e
->operation
;
2495 unsigned n_ops
= e
->ops
.length ();
2497 for (unsigned i
= 0; i
< n_ops
; ++i
)
2499 char child_opname
[20];
2500 gen_opname (child_opname
, i
);
2502 if (id
->kind
== id_base::CODE
)
2505 || *id
== REALPART_EXPR
|| *id
== IMAGPART_EXPR
2506 || *id
== BIT_FIELD_REF
|| *id
== VIEW_CONVERT_EXPR
)
2508 /* ??? If this is a memory operation we can't (and should not)
2509 match this. The only sensible operand types are
2510 SSA names and invariants. */
2511 fprintf_indent (f
, indent
,
2512 "tree %s = TREE_OPERAND (gimple_assign_rhs1 (def), %i);\n",
2514 fprintf_indent (f
, indent
,
2515 "if ((TREE_CODE (%s) == SSA_NAME\n",
2517 fprintf_indent (f
, indent
,
2518 " || is_gimple_min_invariant (%s))\n",
2520 fprintf_indent (f
, indent
,
2521 " && (%s = do_valueize (valueize, %s)))\n",
2522 child_opname
, child_opname
);
2523 fprintf_indent (f
, indent
,
2529 fprintf_indent (f
, indent
,
2530 "tree %s = gimple_assign_rhs%u (def);\n",
2531 child_opname
, i
+ 1);
2534 fprintf_indent (f
, indent
,
2535 "tree %s = gimple_call_arg (def, %u);\n",
2537 fprintf_indent (f
, indent
,
2538 "if ((%s = do_valueize (valueize, %s)))\n",
2539 child_opname
, child_opname
);
2540 fprintf_indent (f
, indent
, " {\n");
2543 /* While the toplevel operands are canonicalized by the caller
2544 after valueizing operands of sub-expressions we have to
2545 re-canonicalize operand order. */
2546 if (operator_id
*code
= dyn_cast
<operator_id
*> (id
))
2548 /* ??? We can't canonicalize tcc_comparison operands here
2549 because that requires changing the comparison code which
2550 we already matched... */
2551 if (commutative_tree_code (code
->code
)
2552 || commutative_ternary_tree_code (code
->code
))
2554 char child_opname0
[20], child_opname1
[20];
2555 gen_opname (child_opname0
, 0);
2556 gen_opname (child_opname1
, 1);
2557 fprintf_indent (f
, indent
,
2558 "if (tree_swap_operands_p (%s, %s, false))\n",
2559 child_opname0
, child_opname1
);
2560 fprintf_indent (f
, indent
,
2561 " std::swap (%s, %s);\n",
2562 child_opname0
, child_opname1
);
2569 /* Generate GENERIC matching code for the decision tree operand. */
2572 dt_operand::gen_generic_expr (FILE *f
, int indent
, const char *opname
)
2574 expr
*e
= static_cast<expr
*> (op
);
2575 unsigned n_ops
= e
->ops
.length ();
2577 for (unsigned i
= 0; i
< n_ops
; ++i
)
2579 char child_opname
[20];
2580 gen_opname (child_opname
, i
);
2582 if (e
->operation
->kind
== id_base::CODE
)
2583 fprintf_indent (f
, indent
, "tree %s = TREE_OPERAND (%s, %u);\n",
2584 child_opname
, opname
, i
);
2586 fprintf_indent (f
, indent
, "tree %s = CALL_EXPR_ARG (%s, %u);\n",
2587 child_opname
, opname
, i
);
2593 /* Generate matching code for the children of the decision tree node. */
2596 dt_node::gen_kids (FILE *f
, int indent
, bool gimple
)
2598 auto_vec
<dt_operand
*> gimple_exprs
;
2599 auto_vec
<dt_operand
*> generic_exprs
;
2600 auto_vec
<dt_operand
*> fns
;
2601 auto_vec
<dt_operand
*> generic_fns
;
2602 auto_vec
<dt_operand
*> preds
;
2603 auto_vec
<dt_node
*> others
;
2605 for (unsigned i
= 0; i
< kids
.length (); ++i
)
2607 if (kids
[i
]->type
== dt_node::DT_OPERAND
)
2609 dt_operand
*op
= as_a
<dt_operand
*> (kids
[i
]);
2610 if (expr
*e
= dyn_cast
<expr
*> (op
->op
))
2612 if (e
->ops
.length () == 0
2613 && (!gimple
|| !(*e
->operation
== CONSTRUCTOR
)))
2614 generic_exprs
.safe_push (op
);
2615 else if (e
->operation
->kind
== id_base::FN
)
2620 generic_fns
.safe_push (op
);
2622 else if (e
->operation
->kind
== id_base::PREDICATE
)
2623 preds
.safe_push (op
);
2626 if (gimple
&& !e
->is_generic
)
2627 gimple_exprs
.safe_push (op
);
2629 generic_exprs
.safe_push (op
);
2632 else if (op
->op
->type
== operand::OP_PREDICATE
)
2633 others
.safe_push (kids
[i
]);
2637 else if (kids
[i
]->type
== dt_node::DT_SIMPLIFY
)
2638 others
.safe_push (kids
[i
]);
2639 else if (kids
[i
]->type
== dt_node::DT_MATCH
2640 || kids
[i
]->type
== dt_node::DT_TRUE
)
2642 /* A DT_TRUE operand serves as a barrier - generate code now
2643 for what we have collected sofar.
2644 Like DT_TRUE, DT_MATCH serves as a barrier as it can cause
2645 dependent matches to get out-of-order. Generate code now
2646 for what we have collected sofar. */
2647 gen_kids_1 (f
, indent
, gimple
, gimple_exprs
, generic_exprs
,
2648 fns
, generic_fns
, preds
, others
);
2649 /* And output the true operand itself. */
2650 kids
[i
]->gen (f
, indent
, gimple
);
2651 gimple_exprs
.truncate (0);
2652 generic_exprs
.truncate (0);
2654 generic_fns
.truncate (0);
2656 others
.truncate (0);
2662 /* Generate code for the remains. */
2663 gen_kids_1 (f
, indent
, gimple
, gimple_exprs
, generic_exprs
,
2664 fns
, generic_fns
, preds
, others
);
2667 /* Generate matching code for the children of the decision tree node. */
2670 dt_node::gen_kids_1 (FILE *f
, int indent
, bool gimple
,
2671 vec
<dt_operand
*> gimple_exprs
,
2672 vec
<dt_operand
*> generic_exprs
,
2673 vec
<dt_operand
*> fns
,
2674 vec
<dt_operand
*> generic_fns
,
2675 vec
<dt_operand
*> preds
,
2676 vec
<dt_node
*> others
)
2679 char *kid_opname
= buf
;
2681 unsigned exprs_len
= gimple_exprs
.length ();
2682 unsigned gexprs_len
= generic_exprs
.length ();
2683 unsigned fns_len
= fns
.length ();
2684 unsigned gfns_len
= generic_fns
.length ();
2686 if (exprs_len
|| fns_len
|| gexprs_len
|| gfns_len
)
2689 gimple_exprs
[0]->get_name (kid_opname
);
2691 fns
[0]->get_name (kid_opname
);
2693 generic_fns
[0]->get_name (kid_opname
);
2695 generic_exprs
[0]->get_name (kid_opname
);
2697 fprintf_indent (f
, indent
, "switch (TREE_CODE (%s))\n", kid_opname
);
2698 fprintf_indent (f
, indent
, " {\n");
2702 if (exprs_len
|| fns_len
)
2704 fprintf_indent (f
, indent
,
2705 "case SSA_NAME:\n");
2706 fprintf_indent (f
, indent
,
2707 " if (do_valueize (valueize, %s) != NULL_TREE)\n",
2709 fprintf_indent (f
, indent
,
2711 fprintf_indent (f
, indent
,
2712 " gimple *def_stmt = SSA_NAME_DEF_STMT (%s);\n",
2718 fprintf_indent (f
, indent
,
2719 "if (gassign *def = dyn_cast <gassign *> (def_stmt))\n");
2720 fprintf_indent (f
, indent
,
2721 " switch (gimple_assign_rhs_code (def))\n");
2723 fprintf_indent (f
, indent
, "{\n");
2724 for (unsigned i
= 0; i
< exprs_len
; ++i
)
2726 expr
*e
= as_a
<expr
*> (gimple_exprs
[i
]->op
);
2727 id_base
*op
= e
->operation
;
2728 if (*op
== CONVERT_EXPR
|| *op
== NOP_EXPR
)
2729 fprintf_indent (f
, indent
, "CASE_CONVERT:\n");
2731 fprintf_indent (f
, indent
, "case %s:\n", op
->id
);
2732 fprintf_indent (f
, indent
, " {\n");
2733 gimple_exprs
[i
]->gen (f
, indent
+ 4, true);
2734 fprintf_indent (f
, indent
, " break;\n");
2735 fprintf_indent (f
, indent
, " }\n");
2737 fprintf_indent (f
, indent
, "default:;\n");
2738 fprintf_indent (f
, indent
, "}\n");
2744 fprintf_indent (f
, indent
,
2745 "%sif (gcall *def = dyn_cast <gcall *>"
2747 exprs_len
? "else " : "");
2748 fprintf_indent (f
, indent
,
2749 " switch (gimple_call_combined_fn (def))\n");
2752 fprintf_indent (f
, indent
, "{\n");
2753 for (unsigned i
= 0; i
< fns_len
; ++i
)
2755 expr
*e
= as_a
<expr
*>(fns
[i
]->op
);
2756 fprintf_indent (f
, indent
, "case %s:\n", e
->operation
->id
);
2757 fprintf_indent (f
, indent
, " {\n");
2758 fns
[i
]->gen (f
, indent
+ 4, true);
2759 fprintf_indent (f
, indent
, " break;\n");
2760 fprintf_indent (f
, indent
, " }\n");
2763 fprintf_indent (f
, indent
, "default:;\n");
2764 fprintf_indent (f
, indent
, "}\n");
2769 fprintf_indent (f
, indent
, " }\n");
2770 fprintf_indent (f
, indent
, " break;\n");
2773 for (unsigned i
= 0; i
< generic_exprs
.length (); ++i
)
2775 expr
*e
= as_a
<expr
*>(generic_exprs
[i
]->op
);
2776 id_base
*op
= e
->operation
;
2777 if (*op
== CONVERT_EXPR
|| *op
== NOP_EXPR
)
2778 fprintf_indent (f
, indent
, "CASE_CONVERT:\n");
2780 fprintf_indent (f
, indent
, "case %s:\n", op
->id
);
2781 fprintf_indent (f
, indent
, " {\n");
2782 generic_exprs
[i
]->gen (f
, indent
+ 4, gimple
);
2783 fprintf_indent (f
, indent
, " break;\n");
2784 fprintf_indent (f
, indent
, " }\n");
2789 fprintf_indent (f
, indent
,
2790 "case CALL_EXPR:\n");
2791 fprintf_indent (f
, indent
,
2792 " switch (get_call_combined_fn (%s))\n",
2794 fprintf_indent (f
, indent
,
2798 for (unsigned j
= 0; j
< generic_fns
.length (); ++j
)
2800 expr
*e
= as_a
<expr
*>(generic_fns
[j
]->op
);
2801 gcc_assert (e
->operation
->kind
== id_base::FN
);
2803 fprintf_indent (f
, indent
, "case %s:\n", e
->operation
->id
);
2804 fprintf_indent (f
, indent
, " {\n");
2805 generic_fns
[j
]->gen (f
, indent
+ 4, false);
2806 fprintf_indent (f
, indent
, " break;\n");
2807 fprintf_indent (f
, indent
, " }\n");
2809 fprintf_indent (f
, indent
, "default:;\n");
2812 fprintf_indent (f
, indent
, " }\n");
2813 fprintf_indent (f
, indent
, " break;\n");
2816 /* Close switch (TREE_CODE ()). */
2817 if (exprs_len
|| fns_len
|| gexprs_len
|| gfns_len
)
2820 fprintf_indent (f
, indent
, " default:;\n");
2821 fprintf_indent (f
, indent
, " }\n");
2824 for (unsigned i
= 0; i
< preds
.length (); ++i
)
2826 expr
*e
= as_a
<expr
*> (preds
[i
]->op
);
2827 predicate_id
*p
= as_a
<predicate_id
*> (e
->operation
);
2828 preds
[i
]->get_name (kid_opname
);
2829 fprintf_indent (f
, indent
, "tree %s_pops[%d];\n", kid_opname
, p
->nargs
);
2830 fprintf_indent (f
, indent
, "if (%s_%s (%s, %s_pops%s))\n",
2831 gimple
? "gimple" : "tree",
2832 p
->id
, kid_opname
, kid_opname
,
2833 gimple
? ", valueize" : "");
2834 fprintf_indent (f
, indent
, " {\n");
2835 for (int j
= 0; j
< p
->nargs
; ++j
)
2837 char child_opname
[20];
2838 preds
[i
]->gen_opname (child_opname
, j
);
2839 fprintf_indent (f
, indent
+ 4, "tree %s = %s_pops[%d];\n",
2840 child_opname
, kid_opname
, j
);
2842 preds
[i
]->gen_kids (f
, indent
+ 4, gimple
);
2846 for (unsigned i
= 0; i
< others
.length (); ++i
)
2847 others
[i
]->gen (f
, indent
, gimple
);
2850 /* Generate matching code for the decision tree operand. */
2853 dt_operand::gen (FILE *f
, int indent
, bool gimple
)
2858 unsigned n_braces
= 0;
2860 if (type
== DT_OPERAND
)
2863 case operand::OP_PREDICATE
:
2864 n_braces
= gen_predicate (f
, indent
, opname
, gimple
);
2867 case operand::OP_EXPR
:
2869 n_braces
= gen_gimple_expr (f
, indent
);
2871 n_braces
= gen_generic_expr (f
, indent
, opname
);
2877 else if (type
== DT_TRUE
)
2879 else if (type
== DT_MATCH
)
2880 n_braces
= gen_match_op (f
, indent
, opname
);
2884 indent
+= 4 * n_braces
;
2885 gen_kids (f
, indent
, gimple
);
2887 for (unsigned i
= 0; i
< n_braces
; ++i
)
2892 fprintf_indent (f
, indent
, " }\n");
2897 /* Generate code for the '(if ...)', '(with ..)' and actual transform
2898 step of a '(simplify ...)' or '(match ...)'. This handles everything
2899 that is not part of the decision tree (simplify->match).
2900 Main recursive worker. */
2903 dt_simplify::gen_1 (FILE *f
, int indent
, bool gimple
, operand
*result
)
2907 if (with_expr
*w
= dyn_cast
<with_expr
*> (result
))
2909 fprintf_indent (f
, indent
, "{\n");
2911 output_line_directive (f
, w
->location
);
2912 w
->with
->gen_transform (f
, indent
, NULL
, true, 1, "type", NULL
);
2913 gen_1 (f
, indent
, gimple
, w
->subexpr
);
2915 fprintf_indent (f
, indent
, "}\n");
2918 else if (if_expr
*ife
= dyn_cast
<if_expr
*> (result
))
2920 output_line_directive (f
, ife
->location
);
2921 fprintf_indent (f
, indent
, "if (");
2922 ife
->cond
->gen_transform (f
, indent
, NULL
, true, 1, "type", NULL
);
2924 fprintf_indent (f
, indent
+ 2, "{\n");
2926 gen_1 (f
, indent
, gimple
, ife
->trueexpr
);
2928 fprintf_indent (f
, indent
+ 2, "}\n");
2931 fprintf_indent (f
, indent
, "else\n");
2932 fprintf_indent (f
, indent
+ 2, "{\n");
2934 gen_1 (f
, indent
, gimple
, ife
->falseexpr
);
2936 fprintf_indent (f
, indent
+ 2, "}\n");
2942 /* Analyze captures and perform early-outs on the incoming arguments
2943 that cover cases we cannot handle. */
2944 capture_info
cinfo (s
, result
, gimple
);
2945 if (s
->kind
== simplify::SIMPLIFY
)
2949 for (unsigned i
= 0; i
< as_a
<expr
*> (s
->match
)->ops
.length (); ++i
)
2950 if (cinfo
.force_no_side_effects
& (1 << i
))
2952 fprintf_indent (f
, indent
,
2953 "if (TREE_SIDE_EFFECTS (op%d)) return NULL_TREE;\n",
2956 warning_at (as_a
<expr
*> (s
->match
)->ops
[i
]->location
,
2957 "forcing toplevel operand to have no "
2960 for (int i
= 0; i
<= s
->capture_max
; ++i
)
2961 if (cinfo
.info
[i
].cse_p
)
2963 else if (cinfo
.info
[i
].force_no_side_effects_p
2964 && (cinfo
.info
[i
].toplevel_msk
2965 & cinfo
.force_no_side_effects
) == 0)
2967 fprintf_indent (f
, indent
,
2968 "if (TREE_SIDE_EFFECTS (captures[%d])) "
2969 "return NULL_TREE;\n", i
);
2971 warning_at (cinfo
.info
[i
].c
->location
,
2972 "forcing captured operand to have no "
2975 else if ((cinfo
.info
[i
].toplevel_msk
2976 & cinfo
.force_no_side_effects
) != 0)
2977 /* Mark capture as having no side-effects if we had to verify
2978 that via forced toplevel operand checks. */
2979 cinfo
.info
[i
].force_no_side_effects_p
= true;
2983 /* Force single-use restriction by only allowing simple
2984 results via setting seq to NULL. */
2985 fprintf_indent (f
, indent
, "gimple_seq *lseq = seq;\n");
2986 bool first_p
= true;
2987 for (int i
= 0; i
<= s
->capture_max
; ++i
)
2988 if (cinfo
.info
[i
].force_single_use
)
2992 fprintf_indent (f
, indent
, "if (lseq\n");
2993 fprintf_indent (f
, indent
, " && (");
2999 fprintf_indent (f
, indent
, " || ");
3001 fprintf (f
, "!single_use (captures[%d])", i
);
3005 fprintf (f
, "))\n");
3006 fprintf_indent (f
, indent
, " lseq = NULL;\n");
3011 fprintf_indent (f
, indent
, "if (dump_file && (dump_flags & TDF_DETAILS)) "
3012 "fprintf (dump_file, \"Applying pattern ");
3013 output_line_directive (f
,
3014 result
? result
->location
: s
->match
->location
, true);
3015 fprintf (f
, ", %%s:%%d\\n\", __FILE__, __LINE__);\n");
3019 /* If there is no result then this is a predicate implementation. */
3020 fprintf_indent (f
, indent
, "return true;\n");
3024 /* For GIMPLE simply drop NON_LVALUE_EXPR (which only appears
3025 in outermost position). */
3026 if (result
->type
== operand::OP_EXPR
3027 && *as_a
<expr
*> (result
)->operation
== NON_LVALUE_EXPR
)
3028 result
= as_a
<expr
*> (result
)->ops
[0];
3029 if (result
->type
== operand::OP_EXPR
)
3031 expr
*e
= as_a
<expr
*> (result
);
3032 id_base
*opr
= e
->operation
;
3033 bool is_predicate
= false;
3034 /* When we delay operator substituting during lowering of fors we
3035 make sure that for code-gen purposes the effects of each substitute
3036 are the same. Thus just look at that. */
3037 if (user_id
*uid
= dyn_cast
<user_id
*> (opr
))
3038 opr
= uid
->substitutes
[0];
3039 else if (is_a
<predicate_id
*> (opr
))
3040 is_predicate
= true;
3042 fprintf_indent (f
, indent
, "*res_code = %s;\n",
3043 *e
->operation
== CONVERT_EXPR
3044 ? "NOP_EXPR" : e
->operation
->id
);
3045 for (unsigned j
= 0; j
< e
->ops
.length (); ++j
)
3048 snprintf (dest
, 32, "res_ops[%d]", j
);
3050 = get_operand_type (opr
,
3051 "type", e
->expr_type
,
3052 j
== 0 ? NULL
: "TREE_TYPE (res_ops[0])");
3053 /* We need to expand GENERIC conditions we captured from
3054 COND_EXPRs and we need to unshare them when substituting
3056 int cond_handling
= 0;
3058 cond_handling
= ((*opr
== COND_EXPR
3059 || *opr
== VEC_COND_EXPR
) && j
== 0) ? 1 : 2;
3060 e
->ops
[j
]->gen_transform (f
, indent
, dest
, true, 1, optype
,
3061 &cinfo
, indexes
, cond_handling
);
3064 /* Re-fold the toplevel result. It's basically an embedded
3065 gimple_build w/o actually building the stmt. */
3067 fprintf_indent (f
, indent
,
3068 "gimple_resimplify%d (lseq, res_code, type, "
3069 "res_ops, valueize);\n", e
->ops
.length ());
3071 else if (result
->type
== operand::OP_CAPTURE
3072 || result
->type
== operand::OP_C_EXPR
)
3074 result
->gen_transform (f
, indent
, "res_ops[0]", true, 1, "type",
3076 fprintf_indent (f
, indent
, "*res_code = TREE_CODE (res_ops[0]);\n");
3077 if (is_a
<capture
*> (result
)
3078 && cinfo
.info
[as_a
<capture
*> (result
)->where
].cond_expr_cond_p
)
3080 /* ??? Stupid tcc_comparison GENERIC trees in COND_EXPRs. Deal
3081 with substituting a capture of that. */
3082 fprintf_indent (f
, indent
,
3083 "if (COMPARISON_CLASS_P (res_ops[0]))\n");
3084 fprintf_indent (f
, indent
,
3086 fprintf_indent (f
, indent
,
3087 " tree tem = res_ops[0];\n");
3088 fprintf_indent (f
, indent
,
3089 " res_ops[0] = TREE_OPERAND (tem, 0);\n");
3090 fprintf_indent (f
, indent
,
3091 " res_ops[1] = TREE_OPERAND (tem, 1);\n");
3092 fprintf_indent (f
, indent
,
3098 fprintf_indent (f
, indent
, "return true;\n");
3102 bool is_predicate
= false;
3103 if (result
->type
== operand::OP_EXPR
)
3105 expr
*e
= as_a
<expr
*> (result
);
3106 id_base
*opr
= e
->operation
;
3107 /* When we delay operator substituting during lowering of fors we
3108 make sure that for code-gen purposes the effects of each substitute
3109 are the same. Thus just look at that. */
3110 if (user_id
*uid
= dyn_cast
<user_id
*> (opr
))
3111 opr
= uid
->substitutes
[0];
3112 else if (is_a
<predicate_id
*> (opr
))
3113 is_predicate
= true;
3114 /* Search for captures used multiple times in the result expression
3115 and wrap them in a SAVE_EXPR. Allow as many uses as in the
3116 original expression. */
3118 for (int i
= 0; i
< s
->capture_max
+ 1; ++i
)
3120 if (cinfo
.info
[i
].same_as
!= (unsigned)i
3121 || cinfo
.info
[i
].cse_p
)
3123 if (cinfo
.info
[i
].result_use_count
3124 > cinfo
.info
[i
].match_use_count
)
3125 fprintf_indent (f
, indent
,
3126 "if (! tree_invariant_p (captures[%d])) "
3127 "return NULL_TREE;\n", i
);
3129 for (unsigned j
= 0; j
< e
->ops
.length (); ++j
)
3133 snprintf (dest
, 32, "res_ops[%d]", j
);
3136 fprintf_indent (f
, indent
, "tree res_op%d;\n", j
);
3137 snprintf (dest
, 32, "res_op%d", j
);
3140 = get_operand_type (opr
,
3141 "type", e
->expr_type
,
3143 ? NULL
: "TREE_TYPE (res_op0)");
3144 e
->ops
[j
]->gen_transform (f
, indent
, dest
, false, 1, optype
,
3148 fprintf_indent (f
, indent
, "return true;\n");
3151 fprintf_indent (f
, indent
, "tree res;\n");
3152 /* Re-fold the toplevel result. Use non_lvalue to
3153 build NON_LVALUE_EXPRs so they get properly
3154 ignored when in GIMPLE form. */
3155 if (*opr
== NON_LVALUE_EXPR
)
3156 fprintf_indent (f
, indent
,
3157 "res = non_lvalue_loc (loc, res_op0);\n");
3160 if (is_a
<operator_id
*> (opr
))
3161 fprintf_indent (f
, indent
,
3162 "res = fold_build%d_loc (loc, %s, type",
3164 *e
->operation
== CONVERT_EXPR
3165 ? "NOP_EXPR" : e
->operation
->id
);
3167 fprintf_indent (f
, indent
,
3168 "res = maybe_build_call_expr_loc (loc, "
3169 "%s, type, %d", e
->operation
->id
,
3171 for (unsigned j
= 0; j
< e
->ops
.length (); ++j
)
3172 fprintf (f
, ", res_op%d", j
);
3173 fprintf (f
, ");\n");
3174 if (!is_a
<operator_id
*> (opr
))
3176 fprintf_indent (f
, indent
, "if (!res)\n");
3177 fprintf_indent (f
, indent
, " return NULL_TREE;\n");
3182 else if (result
->type
== operand::OP_CAPTURE
3183 || result
->type
== operand::OP_C_EXPR
)
3186 fprintf_indent (f
, indent
, "tree res;\n");
3187 result
->gen_transform (f
, indent
, "res", false, 1, "type",
3194 /* Search for captures not used in the result expression and dependent
3195 on TREE_SIDE_EFFECTS emit omit_one_operand. */
3196 for (int i
= 0; i
< s
->capture_max
+ 1; ++i
)
3198 if (cinfo
.info
[i
].same_as
!= (unsigned)i
)
3200 if (!cinfo
.info
[i
].force_no_side_effects_p
3201 && !cinfo
.info
[i
].expr_p
3202 && cinfo
.info
[i
].result_use_count
== 0)
3204 fprintf_indent (f
, indent
,
3205 "if (TREE_SIDE_EFFECTS (captures[%d]))\n",
3207 fprintf_indent (f
, indent
+ 2,
3208 "res = build2_loc (loc, COMPOUND_EXPR, type, "
3209 "fold_ignored_result (captures[%d]), res);\n",
3213 fprintf_indent (f
, indent
, "return res;\n");
3218 /* Generate code for the '(if ...)', '(with ..)' and actual transform
3219 step of a '(simplify ...)' or '(match ...)'. This handles everything
3220 that is not part of the decision tree (simplify->match). */
3223 dt_simplify::gen (FILE *f
, int indent
, bool gimple
)
3225 fprintf_indent (f
, indent
, "{\n");
3227 output_line_directive (f
,
3228 s
->result
? s
->result
->location
: s
->match
->location
);
3229 if (s
->capture_max
>= 0)
3232 fprintf_indent (f
, indent
, "tree captures[%u] ATTRIBUTE_UNUSED = { %s",
3233 s
->capture_max
+ 1, indexes
[0]->get_name (opname
));
3235 for (int i
= 1; i
<= s
->capture_max
; ++i
)
3239 fprintf (f
, ", %s", indexes
[i
]->get_name (opname
));
3241 fprintf (f
, " };\n");
3244 /* If we have a split-out function for the actual transform, call it. */
3245 if (info
&& info
->fname
)
3249 fprintf_indent (f
, indent
, "if (%s (res_code, res_ops, seq, "
3250 "valueize, type, captures", info
->fname
);
3251 for (unsigned i
= 0; i
< s
->for_subst_vec
.length (); ++i
)
3252 fprintf (f
, ", %s", s
->for_subst_vec
[i
].second
->id
);
3253 fprintf (f
, "))\n");
3254 fprintf_indent (f
, indent
, " return true;\n");
3258 fprintf_indent (f
, indent
, "tree res = %s (loc, type",
3260 for (unsigned i
= 0; i
< as_a
<expr
*> (s
->match
)->ops
.length (); ++i
)
3261 fprintf (f
, ", op%d", i
);
3262 fprintf (f
, ", captures");
3263 for (unsigned i
= 0; i
< s
->for_subst_vec
.length (); ++i
)
3264 fprintf (f
, ", %s", s
->for_subst_vec
[i
].second
->id
);
3265 fprintf (f
, ");\n");
3266 fprintf_indent (f
, indent
, "if (res) return res;\n");
3271 for (unsigned i
= 0; i
< s
->for_subst_vec
.length (); ++i
)
3273 if (is_a
<operator_id
*> (s
->for_subst_vec
[i
].second
))
3274 fprintf_indent (f
, indent
, "enum tree_code %s = %s;\n",
3275 s
->for_subst_vec
[i
].first
->id
,
3276 s
->for_subst_vec
[i
].second
->id
);
3277 else if (is_a
<fn_id
*> (s
->for_subst_vec
[i
].second
))
3278 fprintf_indent (f
, indent
, "combined_fn %s = %s;\n",
3279 s
->for_subst_vec
[i
].first
->id
,
3280 s
->for_subst_vec
[i
].second
->id
);
3284 gen_1 (f
, indent
, gimple
, s
->result
);
3288 fprintf_indent (f
, indent
, "}\n");
3292 /* Hash function for finding equivalent transforms. */
3295 sinfo_hashmap_traits::hash (const key_type
&v
)
3297 /* Only bother to compare those originating from the same source pattern. */
3298 return v
->s
->result
->location
;
3301 /* Compare function for finding equivalent transforms. */
3304 compare_op (operand
*o1
, simplify
*s1
, operand
*o2
, simplify
*s2
)
3306 if (o1
->type
!= o2
->type
)
3311 case operand::OP_IF
:
3313 if_expr
*if1
= as_a
<if_expr
*> (o1
);
3314 if_expr
*if2
= as_a
<if_expr
*> (o2
);
3315 /* ??? Properly compare c-exprs. */
3316 if (if1
->cond
!= if2
->cond
)
3318 if (!compare_op (if1
->trueexpr
, s1
, if2
->trueexpr
, s2
))
3320 if (if1
->falseexpr
!= if2
->falseexpr
3322 && !compare_op (if1
->falseexpr
, s1
, if2
->falseexpr
, s2
)))
3326 case operand::OP_WITH
:
3328 with_expr
*with1
= as_a
<with_expr
*> (o1
);
3329 with_expr
*with2
= as_a
<with_expr
*> (o2
);
3330 if (with1
->with
!= with2
->with
)
3332 return compare_op (with1
->subexpr
, s1
, with2
->subexpr
, s2
);
3337 /* We've hit a result. Time to compare capture-infos - this is required
3338 in addition to the conservative pointer-equivalency of the result IL. */
3339 capture_info
cinfo1 (s1
, o1
, true);
3340 capture_info
cinfo2 (s2
, o2
, true);
3342 if (cinfo1
.force_no_side_effects
!= cinfo2
.force_no_side_effects
3343 || cinfo1
.info
.length () != cinfo2
.info
.length ())
3346 for (unsigned i
= 0; i
< cinfo1
.info
.length (); ++i
)
3348 if (cinfo1
.info
[i
].expr_p
!= cinfo2
.info
[i
].expr_p
3349 || cinfo1
.info
[i
].cse_p
!= cinfo2
.info
[i
].cse_p
3350 || (cinfo1
.info
[i
].force_no_side_effects_p
3351 != cinfo2
.info
[i
].force_no_side_effects_p
)
3352 || cinfo1
.info
[i
].force_single_use
!= cinfo2
.info
[i
].force_single_use
3353 || cinfo1
.info
[i
].cond_expr_cond_p
!= cinfo2
.info
[i
].cond_expr_cond_p
3354 /* toplevel_msk is an optimization */
3355 || cinfo1
.info
[i
].result_use_count
!= cinfo2
.info
[i
].result_use_count
3356 || cinfo1
.info
[i
].same_as
!= cinfo2
.info
[i
].same_as
3357 /* the pointer back to the capture is for diagnostics only */)
3361 /* ??? Deep-compare the actual result. */
3366 sinfo_hashmap_traits::equal_keys (const key_type
&v
,
3367 const key_type
&candidate
)
3369 return compare_op (v
->s
->result
, v
->s
, candidate
->s
->result
, candidate
->s
);
3373 /* Main entry to generate code for matching GIMPLE IL off the decision
3377 decision_tree::gen (FILE *f
, bool gimple
)
3383 fprintf (stderr
, "%s decision tree has %u leafs, maximum depth %u and "
3384 "a total number of %u nodes\n",
3385 gimple
? "GIMPLE" : "GENERIC",
3386 root
->num_leafs
, root
->max_level
, root
->total_size
);
3388 /* First split out the transform part of equal leafs. */
3391 for (sinfo_map_t::iterator iter
= si
.begin ();
3392 iter
!= si
.end (); ++iter
)
3394 sinfo
*s
= (*iter
).second
;
3395 /* Do not split out single uses. */
3402 fprintf (stderr
, "found %u uses of", s
->cnt
);
3403 output_line_directive (stderr
, s
->s
->s
->result
->location
);
3406 /* Generate a split out function with the leaf transform code. */
3407 s
->fname
= xasprintf ("%s_simplify_%u", gimple
? "gimple" : "generic",
3410 fprintf (f
, "\nstatic bool\n"
3411 "%s (code_helper *res_code, tree *res_ops,\n"
3412 " gimple_seq *seq, tree (*valueize)(tree) "
3413 "ATTRIBUTE_UNUSED,\n"
3414 " tree ARG_UNUSED (type), tree *ARG_UNUSED "
3419 fprintf (f
, "\nstatic tree\n"
3420 "%s (location_t ARG_UNUSED (loc), tree ARG_UNUSED (type),\n",
3421 (*iter
).second
->fname
);
3422 for (unsigned i
= 0;
3423 i
< as_a
<expr
*>(s
->s
->s
->match
)->ops
.length (); ++i
)
3424 fprintf (f
, " tree ARG_UNUSED (op%d),", i
);
3425 fprintf (f
, " tree *captures\n");
3427 for (unsigned i
= 0; i
< s
->s
->s
->for_subst_vec
.length (); ++i
)
3429 if (is_a
<operator_id
*> (s
->s
->s
->for_subst_vec
[i
].second
))
3430 fprintf (f
, ", enum tree_code ARG_UNUSED (%s)",
3431 s
->s
->s
->for_subst_vec
[i
].first
->id
);
3432 else if (is_a
<fn_id
*> (s
->s
->s
->for_subst_vec
[i
].second
))
3433 fprintf (f
, ", combined_fn ARG_UNUSED (%s)",
3434 s
->s
->s
->for_subst_vec
[i
].first
->id
);
3437 fprintf (f
, ")\n{\n");
3438 s
->s
->gen_1 (f
, 2, gimple
, s
->s
->s
->result
);
3440 fprintf (f
, " return false;\n");
3442 fprintf (f
, " return NULL_TREE;\n");
3445 fprintf (stderr
, "removed %u duplicate tails\n", rcnt
);
3447 for (unsigned n
= 1; n
<= 3; ++n
)
3449 /* First generate split-out functions. */
3450 for (unsigned i
= 0; i
< root
->kids
.length (); i
++)
3452 dt_operand
*dop
= static_cast<dt_operand
*>(root
->kids
[i
]);
3453 expr
*e
= static_cast<expr
*>(dop
->op
);
3454 if (e
->ops
.length () != n
3455 /* Builtin simplifications are somewhat premature on
3456 GENERIC. The following drops patterns with outermost
3457 calls. It's easy to emit overloads for function code
3458 though if necessary. */
3460 && e
->operation
->kind
!= id_base::CODE
))
3464 fprintf (f
, "\nstatic bool\n"
3465 "gimple_simplify_%s (code_helper *res_code, tree *res_ops,\n"
3466 " gimple_seq *seq, tree (*valueize)(tree) "
3467 "ATTRIBUTE_UNUSED,\n"
3468 " code_helper ARG_UNUSED (code), tree "
3469 "ARG_UNUSED (type)\n",
3472 fprintf (f
, "\nstatic tree\n"
3473 "generic_simplify_%s (location_t ARG_UNUSED (loc), enum "
3474 "tree_code ARG_UNUSED (code), tree ARG_UNUSED (type)",
3476 for (unsigned i
= 0; i
< n
; ++i
)
3477 fprintf (f
, ", tree op%d", i
);
3480 dop
->gen_kids (f
, 2, gimple
);
3482 fprintf (f
, " return false;\n");
3484 fprintf (f
, " return NULL_TREE;\n");
3488 /* Then generate the main entry with the outermost switch and
3489 tail-calls to the split-out functions. */
3491 fprintf (f
, "\nstatic bool\n"
3492 "gimple_simplify (code_helper *res_code, tree *res_ops,\n"
3493 " gimple_seq *seq, tree (*valueize)(tree),\n"
3494 " code_helper code, tree type");
3496 fprintf (f
, "\ntree\n"
3497 "generic_simplify (location_t loc, enum tree_code code, "
3498 "tree type ATTRIBUTE_UNUSED");
3499 for (unsigned i
= 0; i
< n
; ++i
)
3500 fprintf (f
, ", tree op%d", i
);
3505 fprintf (f
, " switch (code.get_rep())\n"
3508 fprintf (f
, " switch (code)\n"
3510 for (unsigned i
= 0; i
< root
->kids
.length (); i
++)
3512 dt_operand
*dop
= static_cast<dt_operand
*>(root
->kids
[i
]);
3513 expr
*e
= static_cast<expr
*>(dop
->op
);
3514 if (e
->ops
.length () != n
3515 /* Builtin simplifications are somewhat premature on
3516 GENERIC. The following drops patterns with outermost
3517 calls. It's easy to emit overloads for function code
3518 though if necessary. */
3520 && e
->operation
->kind
!= id_base::CODE
))
3523 if (*e
->operation
== CONVERT_EXPR
3524 || *e
->operation
== NOP_EXPR
)
3525 fprintf (f
, " CASE_CONVERT:\n");
3527 fprintf (f
, " case %s%s:\n",
3528 is_a
<fn_id
*> (e
->operation
) ? "-" : "",
3531 fprintf (f
, " return gimple_simplify_%s (res_code, res_ops, "
3532 "seq, valueize, code, type", e
->operation
->id
);
3534 fprintf (f
, " return generic_simplify_%s (loc, code, type",
3536 for (unsigned i
= 0; i
< n
; ++i
)
3537 fprintf (f
, ", op%d", i
);
3538 fprintf (f
, ");\n");
3540 fprintf (f
, " default:;\n"
3544 fprintf (f
, " return false;\n");
3546 fprintf (f
, " return NULL_TREE;\n");
3551 /* Output code to implement the predicate P from the decision tree DT. */
3554 write_predicate (FILE *f
, predicate_id
*p
, decision_tree
&dt
, bool gimple
)
3556 fprintf (f
, "\nbool\n"
3557 "%s%s (tree t%s%s)\n"
3558 "{\n", gimple
? "gimple_" : "tree_", p
->id
,
3559 p
->nargs
> 0 ? ", tree *res_ops" : "",
3560 gimple
? ", tree (*valueize)(tree)" : "");
3561 /* Conveniently make 'type' available. */
3562 fprintf_indent (f
, 2, "tree type = TREE_TYPE (t);\n");
3565 fprintf_indent (f
, 2, "if (TREE_SIDE_EFFECTS (t)) return false;\n");
3566 dt
.root
->gen_kids (f
, 2, gimple
);
3568 fprintf_indent (f
, 2, "return false;\n"
3572 /* Write the common header for the GIMPLE/GENERIC IL matching routines. */
3575 write_header (FILE *f
, const char *head
)
3577 fprintf (f
, "/* Generated automatically by the program `genmatch' from\n");
3578 fprintf (f
, " a IL pattern matching and simplification description. */\n");
3580 /* Include the header instead of writing it awkwardly quoted here. */
3581 fprintf (f
, "\n#include \"%s\"\n", head
);
3591 parser (cpp_reader
*);
3594 const cpp_token
*next ();
3595 const cpp_token
*peek (unsigned = 1);
3596 const cpp_token
*peek_ident (const char * = NULL
, unsigned = 1);
3597 const cpp_token
*expect (enum cpp_ttype
);
3598 const cpp_token
*eat_token (enum cpp_ttype
);
3599 const char *get_string ();
3600 const char *get_ident ();
3601 const cpp_token
*eat_ident (const char *);
3602 const char *get_number ();
3604 id_base
*parse_operation ();
3605 operand
*parse_capture (operand
*, bool);
3606 operand
*parse_expr ();
3607 c_expr
*parse_c_expr (cpp_ttype
);
3608 operand
*parse_op ();
3610 void record_operlist (source_location
, user_id
*);
3612 void parse_pattern ();
3613 operand
*parse_result (operand
*, predicate_id
*);
3614 void push_simplify (simplify::simplify_kind
,
3615 vec
<simplify
*>&, operand
*, operand
*);
3616 void parse_simplify (simplify::simplify_kind
,
3617 vec
<simplify
*>&, predicate_id
*, operand
*);
3618 void parse_for (source_location
);
3619 void parse_if (source_location
);
3620 void parse_predicates (source_location
);
3621 void parse_operator_list (source_location
);
3624 vec
<c_expr
*> active_ifs
;
3625 vec
<vec
<user_id
*> > active_fors
;
3626 hash_set
<user_id
*> *oper_lists_set
;
3627 vec
<user_id
*> oper_lists
;
3629 cid_map_t
*capture_ids
;
3632 vec
<simplify
*> simplifiers
;
3633 vec
<predicate_id
*> user_predicates
;
3634 bool parsing_match_operand
;
3637 /* Lexing helpers. */
3639 /* Read the next non-whitespace token from R. */
3644 const cpp_token
*token
;
3647 token
= cpp_get_token (r
);
3649 while (token
->type
== CPP_PADDING
3650 && token
->type
!= CPP_EOF
);
3654 /* Peek at the next non-whitespace token from R. */
3657 parser::peek (unsigned num
)
3659 const cpp_token
*token
;
3663 token
= cpp_peek_token (r
, i
++);
3665 while ((token
->type
== CPP_PADDING
3666 && token
->type
!= CPP_EOF
)
3668 /* If we peek at EOF this is a fatal error as it leaves the
3669 cpp_reader in unusable state. Assume we really wanted a
3670 token and thus this EOF is unexpected. */
3671 if (token
->type
== CPP_EOF
)
3672 fatal_at (token
, "unexpected end of file");
3676 /* Peek at the next identifier token (or return NULL if the next
3677 token is not an identifier or equal to ID if supplied). */
3680 parser::peek_ident (const char *id
, unsigned num
)
3682 const cpp_token
*token
= peek (num
);
3683 if (token
->type
!= CPP_NAME
)
3689 const char *t
= (const char *) CPP_HASHNODE (token
->val
.node
.node
)->ident
.str
;
3690 if (strcmp (id
, t
) == 0)
3696 /* Read the next token from R and assert it is of type TK. */
3699 parser::expect (enum cpp_ttype tk
)
3701 const cpp_token
*token
= next ();
3702 if (token
->type
!= tk
)
3703 fatal_at (token
, "expected %s, got %s",
3704 cpp_type2name (tk
, 0), cpp_type2name (token
->type
, 0));
3709 /* Consume the next token from R and assert it is of type TK. */
3712 parser::eat_token (enum cpp_ttype tk
)
3717 /* Read the next token from R and assert it is of type CPP_STRING and
3718 return its value. */
3721 parser::get_string ()
3723 const cpp_token
*token
= expect (CPP_STRING
);
3724 return (const char *)token
->val
.str
.text
;
3727 /* Read the next token from R and assert it is of type CPP_NAME and
3728 return its value. */
3731 parser::get_ident ()
3733 const cpp_token
*token
= expect (CPP_NAME
);
3734 return (const char *)CPP_HASHNODE (token
->val
.node
.node
)->ident
.str
;
3737 /* Eat an identifier token with value S from R. */
3740 parser::eat_ident (const char *s
)
3742 const cpp_token
*token
= peek ();
3743 const char *t
= get_ident ();
3744 if (strcmp (s
, t
) != 0)
3745 fatal_at (token
, "expected '%s' got '%s'\n", s
, t
);
3749 /* Read the next token from R and assert it is of type CPP_NUMBER and
3750 return its value. */
3753 parser::get_number ()
3755 const cpp_token
*token
= expect (CPP_NUMBER
);
3756 return (const char *)token
->val
.str
.text
;
3760 /* Record an operator-list use for transparent for handling. */
3763 parser::record_operlist (source_location loc
, user_id
*p
)
3765 if (!oper_lists_set
->add (p
))
3767 if (!oper_lists
.is_empty ()
3768 && oper_lists
[0]->substitutes
.length () != p
->substitutes
.length ())
3769 fatal_at (loc
, "User-defined operator list does not have the "
3770 "same number of entries as others used in the pattern");
3771 oper_lists
.safe_push (p
);
3775 /* Parse the operator ID, special-casing convert?, convert1? and
3779 parser::parse_operation ()
3781 const cpp_token
*id_tok
= peek ();
3782 const char *id
= get_ident ();
3783 const cpp_token
*token
= peek ();
3784 if (strcmp (id
, "convert0") == 0)
3785 fatal_at (id_tok
, "use 'convert?' here");
3786 else if (strcmp (id
, "view_convert0") == 0)
3787 fatal_at (id_tok
, "use 'view_convert?' here");
3788 if (token
->type
== CPP_QUERY
3789 && !(token
->flags
& PREV_WHITE
))
3791 if (strcmp (id
, "convert") == 0)
3793 else if (strcmp (id
, "convert1") == 0)
3795 else if (strcmp (id
, "convert2") == 0)
3797 else if (strcmp (id
, "view_convert") == 0)
3798 id
= "view_convert0";
3799 else if (strcmp (id
, "view_convert1") == 0)
3801 else if (strcmp (id
, "view_convert2") == 0)
3804 fatal_at (id_tok
, "non-convert operator conditionalized");
3806 if (!parsing_match_operand
)
3807 fatal_at (id_tok
, "conditional convert can only be used in "
3808 "match expression");
3809 eat_token (CPP_QUERY
);
3811 else if (strcmp (id
, "convert1") == 0
3812 || strcmp (id
, "convert2") == 0
3813 || strcmp (id
, "view_convert1") == 0
3814 || strcmp (id
, "view_convert2") == 0)
3815 fatal_at (id_tok
, "expected '?' after conditional operator");
3816 id_base
*op
= get_operator (id
);
3818 fatal_at (id_tok
, "unknown operator %s", id
);
3820 user_id
*p
= dyn_cast
<user_id
*> (op
);
3821 if (p
&& p
->is_oper_list
)
3823 if (active_fors
.length() == 0)
3824 record_operlist (id_tok
->src_loc
, p
);
3826 fatal_at (id_tok
, "operator-list %s cannot be exapnded inside 'for'", id
);
3832 capture = '@'<number> */
3835 parser::parse_capture (operand
*op
, bool require_existing
)
3837 source_location src_loc
= eat_token (CPP_ATSIGN
)->src_loc
;
3838 const cpp_token
*token
= peek ();
3839 const char *id
= NULL
;
3840 if (token
->type
== CPP_NUMBER
)
3842 else if (token
->type
== CPP_NAME
)
3845 fatal_at (token
, "expected number or identifier");
3846 unsigned next_id
= capture_ids
->elements ();
3848 unsigned &num
= capture_ids
->get_or_insert (id
, &existed
);
3851 if (require_existing
)
3852 fatal_at (src_loc
, "unknown capture id");
3855 return new capture (src_loc
, num
, op
);
3858 /* Parse an expression
3859 expr = '(' <operation>[capture][flag][type] <operand>... ')' */
3862 parser::parse_expr ()
3864 const cpp_token
*token
= peek ();
3865 expr
*e
= new expr (parse_operation (), token
->src_loc
);
3868 bool is_commutative
= false;
3869 bool force_capture
= false;
3870 const char *expr_type
= NULL
;
3872 if (token
->type
== CPP_COLON
3873 && !(token
->flags
& PREV_WHITE
))
3875 eat_token (CPP_COLON
);
3877 if (token
->type
== CPP_NAME
3878 && !(token
->flags
& PREV_WHITE
))
3880 const char *s
= get_ident ();
3881 if (!parsing_match_operand
)
3889 is_commutative
= true;
3890 else if (*sp
== 's')
3892 e
->force_single_use
= true;
3893 force_capture
= true;
3896 fatal_at (token
, "flag %c not recognized", *sp
);
3903 fatal_at (token
, "expected flag or type specifying identifier");
3906 if (token
->type
== CPP_ATSIGN
3907 && !(token
->flags
& PREV_WHITE
))
3908 op
= parse_capture (e
, false);
3909 else if (force_capture
)
3911 unsigned num
= capture_ids
->elements ();
3914 sprintf (id
, "__%u", num
);
3915 capture_ids
->get_or_insert (xstrdup (id
), &existed
);
3917 fatal_at (token
, "reserved capture id '%s' already used", id
);
3918 op
= new capture (token
->src_loc
, num
, e
);
3924 const cpp_token
*token
= peek ();
3925 if (token
->type
== CPP_CLOSE_PAREN
)
3927 if (e
->operation
->nargs
!= -1
3928 && e
->operation
->nargs
!= (int) e
->ops
.length ())
3929 fatal_at (token
, "'%s' expects %u operands, not %u",
3930 e
->operation
->id
, e
->operation
->nargs
, e
->ops
.length ());
3933 if (e
->ops
.length () == 2)
3934 e
->is_commutative
= true;
3936 fatal_at (token
, "only binary operators or function with "
3937 "two arguments can be marked commutative");
3939 e
->expr_type
= expr_type
;
3942 else if (!(token
->flags
& PREV_WHITE
))
3943 fatal_at (token
, "expected expression operand");
3945 e
->append_op (parse_op ());
3950 /* Lex native C code delimited by START recording the preprocessing tokens
3951 for later processing.
3952 c_expr = ('{'|'(') <pp token>... ('}'|')') */
3955 parser::parse_c_expr (cpp_ttype start
)
3957 const cpp_token
*token
;
3960 vec
<cpp_token
> code
= vNULL
;
3961 unsigned nr_stmts
= 0;
3962 source_location loc
= eat_token (start
)->src_loc
;
3963 if (start
== CPP_OPEN_PAREN
)
3964 end
= CPP_CLOSE_PAREN
;
3965 else if (start
== CPP_OPEN_BRACE
)
3966 end
= CPP_CLOSE_BRACE
;
3974 /* Count brace pairs to find the end of the expr to match. */
3975 if (token
->type
== start
)
3977 else if (token
->type
== end
3981 /* This is a lame way of counting the number of statements. */
3982 if (token
->type
== CPP_SEMICOLON
)
3985 /* If this is possibly a user-defined identifier mark it used. */
3986 if (token
->type
== CPP_NAME
)
3988 id_base
*idb
= get_operator ((const char *)CPP_HASHNODE
3989 (token
->val
.node
.node
)->ident
.str
);
3991 if (idb
&& (p
= dyn_cast
<user_id
*> (idb
)) && p
->is_oper_list
)
3992 record_operlist (token
->src_loc
, p
);
3995 /* Record the token. */
3996 code
.safe_push (*token
);
3999 return new c_expr (r
, loc
, code
, nr_stmts
, vNULL
, capture_ids
);
4002 /* Parse an operand which is either an expression, a predicate or
4003 a standalone capture.
4004 op = predicate | expr | c_expr | capture */
4009 const cpp_token
*token
= peek ();
4010 struct operand
*op
= NULL
;
4011 if (token
->type
== CPP_OPEN_PAREN
)
4013 eat_token (CPP_OPEN_PAREN
);
4015 eat_token (CPP_CLOSE_PAREN
);
4017 else if (token
->type
== CPP_OPEN_BRACE
)
4019 op
= parse_c_expr (CPP_OPEN_BRACE
);
4023 /* Remaining ops are either empty or predicates */
4024 if (token
->type
== CPP_NAME
)
4026 const char *id
= get_ident ();
4027 id_base
*opr
= get_operator (id
);
4029 fatal_at (token
, "expected predicate name");
4030 if (operator_id
*code
= dyn_cast
<operator_id
*> (opr
))
4032 if (code
->nargs
!= 0)
4033 fatal_at (token
, "using an operator with operands as predicate");
4034 /* Parse the zero-operand operator "predicates" as
4036 op
= new expr (opr
, token
->src_loc
);
4038 else if (user_id
*code
= dyn_cast
<user_id
*> (opr
))
4040 if (code
->nargs
!= 0)
4041 fatal_at (token
, "using an operator with operands as predicate");
4042 /* Parse the zero-operand operator "predicates" as
4044 op
= new expr (opr
, token
->src_loc
);
4046 else if (predicate_id
*p
= dyn_cast
<predicate_id
*> (opr
))
4047 op
= new predicate (p
, token
->src_loc
);
4049 fatal_at (token
, "using an unsupported operator as predicate");
4050 if (!parsing_match_operand
)
4051 fatal_at (token
, "predicates are only allowed in match expression");
4053 if (token
->flags
& PREV_WHITE
)
4056 else if (token
->type
!= CPP_COLON
4057 && token
->type
!= CPP_ATSIGN
)
4058 fatal_at (token
, "expected expression or predicate");
4059 /* optionally followed by a capture and a predicate. */
4060 if (token
->type
== CPP_COLON
)
4061 fatal_at (token
, "not implemented: predicate on leaf operand");
4062 if (token
->type
== CPP_ATSIGN
)
4063 op
= parse_capture (op
, !parsing_match_operand
);
4069 /* Create a new simplify from the current parsing state and MATCH,
4070 MATCH_LOC, RESULT and RESULT_LOC and push it to SIMPLIFIERS. */
4073 parser::push_simplify (simplify::simplify_kind kind
,
4074 vec
<simplify
*>& simplifiers
,
4075 operand
*match
, operand
*result
)
4077 /* Build and push a temporary for operator list uses in expressions. */
4078 if (!oper_lists
.is_empty ())
4079 active_fors
.safe_push (oper_lists
);
4081 simplifiers
.safe_push
4082 (new simplify (kind
, match
, result
,
4083 active_fors
.copy (), capture_ids
));
4085 if (!oper_lists
.is_empty ())
4090 <result-op> = <op> | <if> | <with>
4091 <if> = '(' 'if' '(' <c-expr> ')' <result-op> ')'
4092 <with> = '(' 'with' '{' <c-expr> '}' <result-op> ')'
4096 parser::parse_result (operand
*result
, predicate_id
*matcher
)
4098 const cpp_token
*token
= peek ();
4099 if (token
->type
!= CPP_OPEN_PAREN
)
4102 eat_token (CPP_OPEN_PAREN
);
4103 if (peek_ident ("if"))
4106 if_expr
*ife
= new if_expr (token
->src_loc
);
4107 ife
->cond
= parse_c_expr (CPP_OPEN_PAREN
);
4108 if (peek ()->type
== CPP_OPEN_PAREN
)
4110 ife
->trueexpr
= parse_result (result
, matcher
);
4111 if (peek ()->type
== CPP_OPEN_PAREN
)
4112 ife
->falseexpr
= parse_result (result
, matcher
);
4113 else if (peek ()->type
!= CPP_CLOSE_PAREN
)
4114 ife
->falseexpr
= parse_op ();
4116 else if (peek ()->type
!= CPP_CLOSE_PAREN
)
4118 ife
->trueexpr
= parse_op ();
4119 if (peek ()->type
== CPP_OPEN_PAREN
)
4120 ife
->falseexpr
= parse_result (result
, matcher
);
4121 else if (peek ()->type
!= CPP_CLOSE_PAREN
)
4122 ife
->falseexpr
= parse_op ();
4124 /* If this if is immediately closed then it contains a
4125 manual matcher or is part of a predicate definition. */
4126 else /* if (peek ()->type == CPP_CLOSE_PAREN) */
4129 fatal_at (peek (), "manual transform not implemented");
4130 ife
->trueexpr
= result
;
4132 eat_token (CPP_CLOSE_PAREN
);
4135 else if (peek_ident ("with"))
4138 with_expr
*withe
= new with_expr (token
->src_loc
);
4139 /* Parse (with c-expr expr) as (if-with (true) expr). */
4140 withe
->with
= parse_c_expr (CPP_OPEN_BRACE
);
4141 withe
->with
->nr_stmts
= 0;
4142 withe
->subexpr
= parse_result (result
, matcher
);
4143 eat_token (CPP_CLOSE_PAREN
);
4146 else if (peek_ident ("switch"))
4148 token
= eat_ident ("switch");
4149 source_location ifloc
= eat_token (CPP_OPEN_PAREN
)->src_loc
;
4151 if_expr
*ife
= new if_expr (ifloc
);
4153 ife
->cond
= parse_c_expr (CPP_OPEN_PAREN
);
4154 if (peek ()->type
== CPP_OPEN_PAREN
)
4155 ife
->trueexpr
= parse_result (result
, matcher
);
4157 ife
->trueexpr
= parse_op ();
4158 eat_token (CPP_CLOSE_PAREN
);
4159 if (peek ()->type
!= CPP_OPEN_PAREN
4160 || !peek_ident ("if", 2))
4161 fatal_at (token
, "switch can be implemented with a single if");
4162 while (peek ()->type
!= CPP_CLOSE_PAREN
)
4164 if (peek ()->type
== CPP_OPEN_PAREN
)
4166 if (peek_ident ("if", 2))
4168 ifloc
= eat_token (CPP_OPEN_PAREN
)->src_loc
;
4170 ife
->falseexpr
= new if_expr (ifloc
);
4171 ife
= as_a
<if_expr
*> (ife
->falseexpr
);
4172 ife
->cond
= parse_c_expr (CPP_OPEN_PAREN
);
4173 if (peek ()->type
== CPP_OPEN_PAREN
)
4174 ife
->trueexpr
= parse_result (result
, matcher
);
4176 ife
->trueexpr
= parse_op ();
4177 eat_token (CPP_CLOSE_PAREN
);
4181 /* switch default clause */
4182 ife
->falseexpr
= parse_result (result
, matcher
);
4183 eat_token (CPP_CLOSE_PAREN
);
4189 /* switch default clause */
4190 ife
->falseexpr
= parse_op ();
4191 eat_token (CPP_CLOSE_PAREN
);
4195 eat_token (CPP_CLOSE_PAREN
);
4200 operand
*op
= result
;
4203 eat_token (CPP_CLOSE_PAREN
);
4209 simplify = 'simplify' <expr> <result-op>
4211 match = 'match' <ident> <expr> [<result-op>]
4212 and fill SIMPLIFIERS with the results. */
4215 parser::parse_simplify (simplify::simplify_kind kind
,
4216 vec
<simplify
*>& simplifiers
, predicate_id
*matcher
,
4219 /* Reset the capture map. */
4221 capture_ids
= new cid_map_t
;
4222 /* Reset oper_lists and set. */
4223 hash_set
<user_id
*> olist
;
4224 oper_lists_set
= &olist
;
4227 const cpp_token
*loc
= peek ();
4228 parsing_match_operand
= true;
4229 struct operand
*match
= parse_op ();
4230 parsing_match_operand
= false;
4231 if (match
->type
== operand::OP_CAPTURE
&& !matcher
)
4232 fatal_at (loc
, "outermost expression cannot be captured");
4233 if (match
->type
== operand::OP_EXPR
4234 && is_a
<predicate_id
*> (as_a
<expr
*> (match
)->operation
))
4235 fatal_at (loc
, "outermost expression cannot be a predicate");
4237 /* Splice active_ifs onto result and continue parsing the
4239 if_expr
*active_if
= NULL
;
4240 for (int i
= active_ifs
.length (); i
> 0; --i
)
4242 if_expr
*ifc
= new if_expr (active_ifs
[i
-1]->location
);
4243 ifc
->cond
= active_ifs
[i
-1];
4244 ifc
->trueexpr
= active_if
;
4247 if_expr
*outermost_if
= active_if
;
4248 while (active_if
&& active_if
->trueexpr
)
4249 active_if
= as_a
<if_expr
*> (active_if
->trueexpr
);
4251 const cpp_token
*token
= peek ();
4253 /* If this if is immediately closed then it is part of a predicate
4254 definition. Push it. */
4255 if (token
->type
== CPP_CLOSE_PAREN
)
4258 fatal_at (token
, "expected transform expression");
4261 active_if
->trueexpr
= result
;
4262 result
= outermost_if
;
4264 push_simplify (kind
, simplifiers
, match
, result
);
4268 operand
*tem
= parse_result (result
, matcher
);
4271 active_if
->trueexpr
= tem
;
4272 result
= outermost_if
;
4277 push_simplify (kind
, simplifiers
, match
, result
);
4280 /* Parsing of the outer control structures. */
4282 /* Parse a for expression
4283 for = '(' 'for' <subst>... <pattern> ')'
4284 subst = <ident> '(' <ident>... ')' */
4287 parser::parse_for (source_location
)
4289 auto_vec
<const cpp_token
*> user_id_tokens
;
4290 vec
<user_id
*> user_ids
= vNULL
;
4291 const cpp_token
*token
;
4292 unsigned min_n_opers
= 0, max_n_opers
= 0;
4297 if (token
->type
!= CPP_NAME
)
4300 /* Insert the user defined operators into the operator hash. */
4301 const char *id
= get_ident ();
4302 if (get_operator (id
, true) != NULL
)
4303 fatal_at (token
, "operator already defined");
4304 user_id
*op
= new user_id (id
);
4305 id_base
**slot
= operators
->find_slot_with_hash (op
, op
->hashval
, INSERT
);
4307 user_ids
.safe_push (op
);
4308 user_id_tokens
.safe_push (token
);
4310 eat_token (CPP_OPEN_PAREN
);
4313 while ((token
= peek_ident ()) != 0)
4315 const char *oper
= get_ident ();
4316 id_base
*idb
= get_operator (oper
, true);
4318 fatal_at (token
, "no such operator '%s'", oper
);
4319 if (*idb
== CONVERT0
|| *idb
== CONVERT1
|| *idb
== CONVERT2
4320 || *idb
== VIEW_CONVERT0
|| *idb
== VIEW_CONVERT1
4321 || *idb
== VIEW_CONVERT2
)
4322 fatal_at (token
, "conditional operators cannot be used inside for");
4326 else if (idb
->nargs
== -1)
4328 else if (idb
->nargs
!= arity
)
4329 fatal_at (token
, "operator '%s' with arity %d does not match "
4330 "others with arity %d", oper
, idb
->nargs
, arity
);
4332 user_id
*p
= dyn_cast
<user_id
*> (idb
);
4335 if (p
->is_oper_list
)
4336 op
->substitutes
.safe_splice (p
->substitutes
);
4338 fatal_at (token
, "iterator cannot be used as operator-list");
4341 op
->substitutes
.safe_push (idb
);
4344 token
= expect (CPP_CLOSE_PAREN
);
4346 unsigned nsubstitutes
= op
->substitutes
.length ();
4347 if (nsubstitutes
== 0)
4348 fatal_at (token
, "A user-defined operator must have at least "
4349 "one substitution");
4350 if (max_n_opers
== 0)
4352 min_n_opers
= nsubstitutes
;
4353 max_n_opers
= nsubstitutes
;
4357 if (nsubstitutes
% min_n_opers
!= 0
4358 && min_n_opers
% nsubstitutes
!= 0)
4359 fatal_at (token
, "All user-defined identifiers must have a "
4360 "multiple number of operator substitutions of the "
4361 "smallest number of substitutions");
4362 if (nsubstitutes
< min_n_opers
)
4363 min_n_opers
= nsubstitutes
;
4364 else if (nsubstitutes
> max_n_opers
)
4365 max_n_opers
= nsubstitutes
;
4369 unsigned n_ids
= user_ids
.length ();
4371 fatal_at (token
, "for requires at least one user-defined identifier");
4374 if (token
->type
== CPP_CLOSE_PAREN
)
4375 fatal_at (token
, "no pattern defined in for");
4377 active_fors
.safe_push (user_ids
);
4381 if (token
->type
== CPP_CLOSE_PAREN
)
4387 /* Remove user-defined operators from the hash again. */
4388 for (unsigned i
= 0; i
< user_ids
.length (); ++i
)
4390 if (!user_ids
[i
]->used
)
4391 warning_at (user_id_tokens
[i
],
4392 "operator %s defined but not used", user_ids
[i
]->id
);
4393 operators
->remove_elt (user_ids
[i
]);
4397 /* Parse an identifier associated with a list of operators.
4398 oprs = '(' 'define_operator_list' <ident> <ident>... ')' */
4401 parser::parse_operator_list (source_location
)
4403 const cpp_token
*token
= peek ();
4404 const char *id
= get_ident ();
4406 if (get_operator (id
, true) != 0)
4407 fatal_at (token
, "operator %s already defined", id
);
4409 user_id
*op
= new user_id (id
, true);
4412 while ((token
= peek_ident ()) != 0)
4415 const char *oper
= get_ident ();
4416 id_base
*idb
= get_operator (oper
, true);
4419 fatal_at (token
, "no such operator '%s'", oper
);
4423 else if (idb
->nargs
== -1)
4425 else if (arity
!= idb
->nargs
)
4426 fatal_at (token
, "operator '%s' with arity %d does not match "
4427 "others with arity %d", oper
, idb
->nargs
, arity
);
4429 /* We allow composition of multiple operator lists. */
4430 if (user_id
*p
= dyn_cast
<user_id
*> (idb
))
4431 op
->substitutes
.safe_splice (p
->substitutes
);
4433 op
->substitutes
.safe_push (idb
);
4436 // Check that there is no junk after id-list
4438 if (token
->type
!= CPP_CLOSE_PAREN
)
4439 fatal_at (token
, "expected identifier got %s", cpp_type2name (token
->type
, 0));
4441 if (op
->substitutes
.length () == 0)
4442 fatal_at (token
, "operator-list cannot be empty");
4445 id_base
**slot
= operators
->find_slot_with_hash (op
, op
->hashval
, INSERT
);
4449 /* Parse an outer if expression.
4450 if = '(' 'if' '(' <c-expr> ')' <pattern> ')' */
4453 parser::parse_if (source_location
)
4455 c_expr
*ifexpr
= parse_c_expr (CPP_OPEN_PAREN
);
4457 const cpp_token
*token
= peek ();
4458 if (token
->type
== CPP_CLOSE_PAREN
)
4459 fatal_at (token
, "no pattern defined in if");
4461 active_ifs
.safe_push (ifexpr
);
4464 const cpp_token
*token
= peek ();
4465 if (token
->type
== CPP_CLOSE_PAREN
)
4473 /* Parse a list of predefined predicate identifiers.
4474 preds = '(' 'define_predicates' <ident>... ')' */
4477 parser::parse_predicates (source_location
)
4481 const cpp_token
*token
= peek ();
4482 if (token
->type
!= CPP_NAME
)
4485 add_predicate (get_ident ());
4490 /* Parse outer control structures.
4491 pattern = <preds>|<for>|<if>|<simplify>|<match> */
4494 parser::parse_pattern ()
4496 /* All clauses start with '('. */
4497 eat_token (CPP_OPEN_PAREN
);
4498 const cpp_token
*token
= peek ();
4499 const char *id
= get_ident ();
4500 if (strcmp (id
, "simplify") == 0)
4502 parse_simplify (simplify::SIMPLIFY
, simplifiers
, NULL
, NULL
);
4505 else if (strcmp (id
, "match") == 0)
4507 bool with_args
= false;
4508 source_location e_loc
= peek ()->src_loc
;
4509 if (peek ()->type
== CPP_OPEN_PAREN
)
4511 eat_token (CPP_OPEN_PAREN
);
4514 const char *name
= get_ident ();
4515 id_base
*id
= get_operator (name
);
4519 p
= add_predicate (name
);
4520 user_predicates
.safe_push (p
);
4522 else if ((p
= dyn_cast
<predicate_id
*> (id
)))
4525 fatal_at (token
, "cannot add a match to a non-predicate ID");
4526 /* Parse (match <id> <arg>... (match-expr)) here. */
4530 capture_ids
= new cid_map_t
;
4531 e
= new expr (p
, e_loc
);
4532 while (peek ()->type
== CPP_ATSIGN
)
4533 e
->append_op (parse_capture (NULL
, false));
4534 eat_token (CPP_CLOSE_PAREN
);
4537 && ((e
&& e
->ops
.length () != (unsigned)p
->nargs
)
4538 || (!e
&& p
->nargs
!= 0)))
4539 fatal_at (token
, "non-matching number of match operands");
4540 p
->nargs
= e
? e
->ops
.length () : 0;
4541 parse_simplify (simplify::MATCH
, p
->matchers
, p
, e
);
4544 else if (strcmp (id
, "for") == 0)
4545 parse_for (token
->src_loc
);
4546 else if (strcmp (id
, "if") == 0)
4547 parse_if (token
->src_loc
);
4548 else if (strcmp (id
, "define_predicates") == 0)
4550 if (active_ifs
.length () > 0
4551 || active_fors
.length () > 0)
4552 fatal_at (token
, "define_predicates inside if or for is not supported");
4553 parse_predicates (token
->src_loc
);
4555 else if (strcmp (id
, "define_operator_list") == 0)
4557 if (active_ifs
.length () > 0
4558 || active_fors
.length () > 0)
4559 fatal_at (token
, "operator-list inside if or for is not supported");
4560 parse_operator_list (token
->src_loc
);
4563 fatal_at (token
, "expected %s'simplify', 'match', 'for' or 'if'",
4564 active_ifs
.length () == 0 && active_fors
.length () == 0
4565 ? "'define_predicates', " : "");
4567 eat_token (CPP_CLOSE_PAREN
);
4570 /* Main entry of the parser. Repeatedly parse outer control structures. */
4572 parser::parser (cpp_reader
*r_
)
4576 active_fors
= vNULL
;
4577 simplifiers
= vNULL
;
4578 oper_lists_set
= NULL
;
4581 user_predicates
= vNULL
;
4582 parsing_match_operand
= false;
4584 const cpp_token
*token
= next ();
4585 while (token
->type
!= CPP_EOF
)
4587 _cpp_backup_tokens (r
, 1);
4594 /* Helper for the linemap code. */
4597 round_alloc_size (size_t s
)
4603 /* The genmatch generator progam. It reads from a pattern description
4604 and outputs GIMPLE or GENERIC IL matching and simplification routines. */
4607 main (int argc
, char **argv
)
4611 progname
= "genmatch";
4617 char *input
= argv
[argc
-1];
4618 for (int i
= 1; i
< argc
- 1; ++i
)
4620 if (strcmp (argv
[i
], "--gimple") == 0)
4622 else if (strcmp (argv
[i
], "--generic") == 0)
4624 else if (strcmp (argv
[i
], "-v") == 0)
4626 else if (strcmp (argv
[i
], "-vv") == 0)
4630 fprintf (stderr
, "Usage: genmatch "
4631 "[--gimple] [--generic] [-v[v]] input\n");
4636 line_table
= XCNEW (struct line_maps
);
4637 linemap_init (line_table
, 0);
4638 line_table
->reallocator
= xrealloc
;
4639 line_table
->round_alloc_size
= round_alloc_size
;
4641 r
= cpp_create_reader (CLK_GNUC99
, NULL
, line_table
);
4642 cpp_callbacks
*cb
= cpp_get_callbacks (r
);
4643 cb
->error
= error_cb
;
4645 /* Add the build directory to the #include "" search path. */
4646 cpp_dir
*dir
= XCNEW (cpp_dir
);
4647 dir
->name
= getpwd ();
4649 dir
->name
= ASTRDUP (".");
4650 cpp_set_include_chains (r
, dir
, NULL
, false);
4652 if (!cpp_read_main_file (r
, input
))
4654 cpp_define (r
, gimple
? "GIMPLE=1": "GENERIC=1");
4655 cpp_define (r
, gimple
? "GENERIC=0": "GIMPLE=0");
4657 null_id
= new id_base (id_base::NULL_ID
, "null");
4659 /* Pre-seed operators. */
4660 operators
= new hash_table
<id_base
> (1024);
4661 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
4662 add_operator (SYM, # SYM, # TYPE, NARGS);
4663 #define END_OF_BASE_TREE_CODES
4665 add_operator (CONVERT0
, "convert0", "tcc_unary", 1);
4666 add_operator (CONVERT1
, "convert1", "tcc_unary", 1);
4667 add_operator (CONVERT2
, "convert2", "tcc_unary", 1);
4668 add_operator (VIEW_CONVERT0
, "view_convert0", "tcc_unary", 1);
4669 add_operator (VIEW_CONVERT1
, "view_convert1", "tcc_unary", 1);
4670 add_operator (VIEW_CONVERT2
, "view_convert2", "tcc_unary", 1);
4671 #undef END_OF_BASE_TREE_CODES
4674 /* Pre-seed builtin functions.
4675 ??? Cannot use N (name) as that is targetm.emultls.get_address
4676 for BUILT_IN_EMUTLS_GET_ADDRESS ... */
4677 #define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) \
4678 add_function (ENUM, "CFN_" # ENUM);
4679 #include "builtins.def"
4681 #define DEF_INTERNAL_FN(CODE, NAME, FNSPEC) \
4682 add_function (IFN_##CODE, "CFN_" #CODE);
4683 #include "internal-fn.def"
4689 write_header (stdout
, "gimple-match-head.c");
4691 write_header (stdout
, "generic-match-head.c");
4693 /* Go over all predicates defined with patterns and perform
4694 lowering and code generation. */
4695 for (unsigned i
= 0; i
< p
.user_predicates
.length (); ++i
)
4697 predicate_id
*pred
= p
.user_predicates
[i
];
4698 lower (pred
->matchers
, gimple
);
4701 for (unsigned i
= 0; i
< pred
->matchers
.length (); ++i
)
4702 print_matches (pred
->matchers
[i
]);
4705 for (unsigned i
= 0; i
< pred
->matchers
.length (); ++i
)
4706 dt
.insert (pred
->matchers
[i
], i
);
4711 write_predicate (stdout
, pred
, dt
, gimple
);
4714 /* Lower the main simplifiers and generate code for them. */
4715 lower (p
.simplifiers
, gimple
);
4718 for (unsigned i
= 0; i
< p
.simplifiers
.length (); ++i
)
4719 print_matches (p
.simplifiers
[i
]);
4722 for (unsigned i
= 0; i
< p
.simplifiers
.length (); ++i
)
4723 dt
.insert (p
.simplifiers
[i
], i
);
4728 dt
.gen (stdout
, gimple
);
4731 cpp_finish (r
, NULL
);