1 /* Passes for transactional memory support.
2 Copyright (C) 2008-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
23 #include "hash-table.h"
26 #include "gimple-iterator.h"
27 #include "gimple-walk.h"
28 #include "gimple-ssa.h"
31 #include "tree-ssanames.h"
32 #include "tree-into-ssa.h"
33 #include "tree-pass.h"
34 #include "tree-inline.h"
35 #include "diagnostic-core.h"
38 #include "trans-mem.h"
41 #include "langhooks.h"
42 #include "gimple-pretty-print.h"
44 #include "tree-ssa-address.h"
47 #define PROB_VERY_UNLIKELY (REG_BR_PROB_BASE / 2000 - 1)
48 #define PROB_VERY_LIKELY (PROB_ALWAYS - PROB_VERY_UNLIKELY)
49 #define PROB_UNLIKELY (REG_BR_PROB_BASE / 5 - 1)
50 #define PROB_LIKELY (PROB_ALWAYS - PROB_VERY_LIKELY)
51 #define PROB_ALWAYS (REG_BR_PROB_BASE)
53 #define A_RUNINSTRUMENTEDCODE 0x0001
54 #define A_RUNUNINSTRUMENTEDCODE 0x0002
55 #define A_SAVELIVEVARIABLES 0x0004
56 #define A_RESTORELIVEVARIABLES 0x0008
57 #define A_ABORTTRANSACTION 0x0010
59 #define AR_USERABORT 0x0001
60 #define AR_USERRETRY 0x0002
61 #define AR_TMCONFLICT 0x0004
62 #define AR_EXCEPTIONBLOCKABORT 0x0008
63 #define AR_OUTERABORT 0x0010
65 #define MODE_SERIALIRREVOCABLE 0x0000
68 /* The representation of a transaction changes several times during the
69 lowering process. In the beginning, in the front-end we have the
70 GENERIC tree TRANSACTION_EXPR. For example,
78 During initial gimplification (gimplify.c) the TRANSACTION_EXPR node is
79 trivially replaced with a GIMPLE_TRANSACTION node.
81 During pass_lower_tm, we examine the body of transactions looking
82 for aborts. Transactions that do not contain an abort may be
83 merged into an outer transaction. We also add a TRY-FINALLY node
84 to arrange for the transaction to be committed on any exit.
86 [??? Think about how this arrangement affects throw-with-commit
87 and throw-with-abort operations. In this case we want the TRY to
88 handle gotos, but not to catch any exceptions because the transaction
89 will already be closed.]
91 GIMPLE_TRANSACTION [label=NULL] {
98 __builtin___tm_abort ();
100 __builtin___tm_commit ();
104 During pass_lower_eh, we create EH regions for the transactions,
105 intermixed with the regular EH stuff. This gives us a nice persistent
106 mapping (all the way through rtl) from transactional memory operation
107 back to the transaction, which allows us to get the abnormal edges
108 correct to model transaction aborts and restarts:
110 GIMPLE_TRANSACTION [label=over]
116 __builtin___tm_abort ();
117 __builtin___tm_commit ();
120 This is the end of all_lowering_passes, and so is what is present
121 during the IPA passes, and through all of the optimization passes.
123 During pass_ipa_tm, we examine all GIMPLE_TRANSACTION blocks in all
124 functions and mark functions for cloning.
126 At the end of gimple optimization, before exiting SSA form,
127 pass_tm_edges replaces statements that perform transactional
128 memory operations with the appropriate TM builtins, and swap
129 out function calls with their transactional clones. At this
130 point we introduce the abnormal transaction restart edges and
131 complete lowering of the GIMPLE_TRANSACTION node.
133 x = __builtin___tm_start (MAY_ABORT);
135 if (x & abort_transaction)
138 t0 = __builtin___tm_load (global);
140 __builtin___tm_store (&global, t1);
142 __builtin___tm_abort ();
143 __builtin___tm_commit ();
147 static void *expand_regions (struct tm_region *,
148 void *(*callback)(struct tm_region *, void *),
152 /* Return the attributes we want to examine for X, or NULL if it's not
153 something we examine. We look at function types, but allow pointers
154 to function types and function decls and peek through. */
157 get_attrs_for (const_tree x)
159 switch (TREE_CODE (x))
162 return TYPE_ATTRIBUTES (TREE_TYPE (x));
169 if (TREE_CODE (x) != POINTER_TYPE)
175 if (TREE_CODE (x) != FUNCTION_TYPE && TREE_CODE (x) != METHOD_TYPE)
181 return TYPE_ATTRIBUTES (x);
185 /* Return true if X has been marked TM_PURE. */
188 is_tm_pure (const_tree x)
192 switch (TREE_CODE (x))
203 if (TREE_CODE (x) != POINTER_TYPE)
209 if (TREE_CODE (x) != FUNCTION_TYPE && TREE_CODE (x) != METHOD_TYPE)
214 flags = flags_from_decl_or_type (x);
215 return (flags & ECF_TM_PURE) != 0;
218 /* Return true if X has been marked TM_IRREVOCABLE. */
221 is_tm_irrevocable (tree x)
223 tree attrs = get_attrs_for (x);
225 if (attrs && lookup_attribute ("transaction_unsafe", attrs))
228 /* A call to the irrevocable builtin is by definition,
230 if (TREE_CODE (x) == ADDR_EXPR)
231 x = TREE_OPERAND (x, 0);
232 if (TREE_CODE (x) == FUNCTION_DECL
233 && DECL_BUILT_IN_CLASS (x) == BUILT_IN_NORMAL
234 && DECL_FUNCTION_CODE (x) == BUILT_IN_TM_IRREVOCABLE)
240 /* Return true if X has been marked TM_SAFE. */
243 is_tm_safe (const_tree x)
247 tree attrs = get_attrs_for (x);
250 if (lookup_attribute ("transaction_safe", attrs))
252 if (lookup_attribute ("transaction_may_cancel_outer", attrs))
259 /* Return true if CALL is const, or tm_pure. */
262 is_tm_pure_call (gimple call)
264 tree fn = gimple_call_fn (call);
266 if (TREE_CODE (fn) == ADDR_EXPR)
268 fn = TREE_OPERAND (fn, 0);
269 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
274 return is_tm_pure (fn);
277 /* Return true if X has been marked TM_CALLABLE. */
280 is_tm_callable (tree x)
282 tree attrs = get_attrs_for (x);
285 if (lookup_attribute ("transaction_callable", attrs))
287 if (lookup_attribute ("transaction_safe", attrs))
289 if (lookup_attribute ("transaction_may_cancel_outer", attrs))
295 /* Return true if X has been marked TRANSACTION_MAY_CANCEL_OUTER. */
298 is_tm_may_cancel_outer (tree x)
300 tree attrs = get_attrs_for (x);
302 return lookup_attribute ("transaction_may_cancel_outer", attrs) != NULL;
306 /* Return true for built in functions that "end" a transaction. */
309 is_tm_ending_fndecl (tree fndecl)
311 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
312 switch (DECL_FUNCTION_CODE (fndecl))
314 case BUILT_IN_TM_COMMIT:
315 case BUILT_IN_TM_COMMIT_EH:
316 case BUILT_IN_TM_ABORT:
317 case BUILT_IN_TM_IRREVOCABLE:
326 /* Return true if STMT is a built in function call that "ends" a
330 is_tm_ending (gimple stmt)
334 if (gimple_code (stmt) != GIMPLE_CALL)
337 fndecl = gimple_call_fndecl (stmt);
338 return (fndecl != NULL_TREE
339 && is_tm_ending_fndecl (fndecl));
342 /* Return true if STMT is a TM load. */
345 is_tm_load (gimple stmt)
349 if (gimple_code (stmt) != GIMPLE_CALL)
352 fndecl = gimple_call_fndecl (stmt);
353 return (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
354 && BUILTIN_TM_LOAD_P (DECL_FUNCTION_CODE (fndecl)));
357 /* Same as above, but for simple TM loads, that is, not the
358 after-write, after-read, etc optimized variants. */
361 is_tm_simple_load (gimple stmt)
365 if (gimple_code (stmt) != GIMPLE_CALL)
368 fndecl = gimple_call_fndecl (stmt);
369 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
371 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
372 return (fcode == BUILT_IN_TM_LOAD_1
373 || fcode == BUILT_IN_TM_LOAD_2
374 || fcode == BUILT_IN_TM_LOAD_4
375 || fcode == BUILT_IN_TM_LOAD_8
376 || fcode == BUILT_IN_TM_LOAD_FLOAT
377 || fcode == BUILT_IN_TM_LOAD_DOUBLE
378 || fcode == BUILT_IN_TM_LOAD_LDOUBLE
379 || fcode == BUILT_IN_TM_LOAD_M64
380 || fcode == BUILT_IN_TM_LOAD_M128
381 || fcode == BUILT_IN_TM_LOAD_M256);
386 /* Return true if STMT is a TM store. */
389 is_tm_store (gimple stmt)
393 if (gimple_code (stmt) != GIMPLE_CALL)
396 fndecl = gimple_call_fndecl (stmt);
397 return (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
398 && BUILTIN_TM_STORE_P (DECL_FUNCTION_CODE (fndecl)));
401 /* Same as above, but for simple TM stores, that is, not the
402 after-write, after-read, etc optimized variants. */
405 is_tm_simple_store (gimple stmt)
409 if (gimple_code (stmt) != GIMPLE_CALL)
412 fndecl = gimple_call_fndecl (stmt);
413 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
415 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
416 return (fcode == BUILT_IN_TM_STORE_1
417 || fcode == BUILT_IN_TM_STORE_2
418 || fcode == BUILT_IN_TM_STORE_4
419 || fcode == BUILT_IN_TM_STORE_8
420 || fcode == BUILT_IN_TM_STORE_FLOAT
421 || fcode == BUILT_IN_TM_STORE_DOUBLE
422 || fcode == BUILT_IN_TM_STORE_LDOUBLE
423 || fcode == BUILT_IN_TM_STORE_M64
424 || fcode == BUILT_IN_TM_STORE_M128
425 || fcode == BUILT_IN_TM_STORE_M256);
430 /* Return true if FNDECL is BUILT_IN_TM_ABORT. */
433 is_tm_abort (tree fndecl)
436 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
437 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_TM_ABORT);
440 /* Build a GENERIC tree for a user abort. This is called by front ends
441 while transforming the __tm_abort statement. */
444 build_tm_abort_call (location_t loc, bool is_outer)
446 return build_call_expr_loc (loc, builtin_decl_explicit (BUILT_IN_TM_ABORT), 1,
447 build_int_cst (integer_type_node,
449 | (is_outer ? AR_OUTERABORT : 0)));
452 /* Common gateing function for several of the TM passes. */
460 /* Map for aribtrary function replacement under TM, as created
461 by the tm_wrap attribute. */
463 static GTY((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
467 record_tm_replacement (tree from, tree to)
469 struct tree_map **slot, *h;
471 /* Do not inline wrapper functions that will get replaced in the TM
474 Suppose you have foo() that will get replaced into tmfoo(). Make
475 sure the inliner doesn't try to outsmart us and inline foo()
476 before we get a chance to do the TM replacement. */
477 DECL_UNINLINABLE (from) = 1;
479 if (tm_wrap_map == NULL)
480 tm_wrap_map = htab_create_ggc (32, tree_map_hash, tree_map_eq, 0);
482 h = ggc_alloc_tree_map ();
483 h->hash = htab_hash_pointer (from);
487 slot = (struct tree_map **)
488 htab_find_slot_with_hash (tm_wrap_map, h, h->hash, INSERT);
492 /* Return a TM-aware replacement function for DECL. */
495 find_tm_replacement_function (tree fndecl)
499 struct tree_map *h, in;
501 in.base.from = fndecl;
502 in.hash = htab_hash_pointer (fndecl);
503 h = (struct tree_map *) htab_find_with_hash (tm_wrap_map, &in, in.hash);
508 /* ??? We may well want TM versions of most of the common <string.h>
509 functions. For now, we've already these two defined. */
510 /* Adjust expand_call_tm() attributes as necessary for the cases
512 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
513 switch (DECL_FUNCTION_CODE (fndecl))
515 case BUILT_IN_MEMCPY:
516 return builtin_decl_explicit (BUILT_IN_TM_MEMCPY);
517 case BUILT_IN_MEMMOVE:
518 return builtin_decl_explicit (BUILT_IN_TM_MEMMOVE);
519 case BUILT_IN_MEMSET:
520 return builtin_decl_explicit (BUILT_IN_TM_MEMSET);
528 /* When appropriate, record TM replacement for memory allocation functions.
530 FROM is the FNDECL to wrap. */
532 tm_malloc_replacement (tree from)
537 if (TREE_CODE (from) != FUNCTION_DECL)
540 /* If we have a previous replacement, the user must be explicitly
541 wrapping malloc/calloc/free. They better know what they're
543 if (find_tm_replacement_function (from))
546 str = IDENTIFIER_POINTER (DECL_NAME (from));
548 if (!strcmp (str, "malloc"))
549 to = builtin_decl_explicit (BUILT_IN_TM_MALLOC);
550 else if (!strcmp (str, "calloc"))
551 to = builtin_decl_explicit (BUILT_IN_TM_CALLOC);
552 else if (!strcmp (str, "free"))
553 to = builtin_decl_explicit (BUILT_IN_TM_FREE);
557 TREE_NOTHROW (to) = 0;
559 record_tm_replacement (from, to);
562 /* Diagnostics for tm_safe functions/regions. Called by the front end
563 once we've lowered the function to high-gimple. */
565 /* Subroutine of diagnose_tm_safe_errors, called through walk_gimple_seq.
566 Process exactly one statement. WI->INFO is set to non-null when in
567 the context of a tm_safe function, and null for a __transaction block. */
569 #define DIAG_TM_OUTER 1
570 #define DIAG_TM_SAFE 2
571 #define DIAG_TM_RELAXED 4
575 unsigned int summary_flags : 8;
576 unsigned int block_flags : 8;
577 unsigned int func_flags : 8;
578 unsigned int saw_volatile : 1;
582 /* Return true if T is a volatile variable of some kind. */
585 volatile_var_p (tree t)
587 return (SSA_VAR_P (t)
588 && TREE_THIS_VOLATILE (TREE_TYPE (t)));
591 /* Tree callback function for diagnose_tm pass. */
594 diagnose_tm_1_op (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
597 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
598 struct diagnose_tm *d = (struct diagnose_tm *) wi->info;
600 if (volatile_var_p (*tp)
601 && d->block_flags & DIAG_TM_SAFE
605 error_at (gimple_location (d->stmt),
606 "invalid volatile use of %qD inside transaction",
614 is_tm_safe_or_pure (const_tree x)
616 return is_tm_safe (x) || is_tm_pure (x);
620 diagnose_tm_1 (gimple_stmt_iterator *gsi, bool *handled_ops_p,
621 struct walk_stmt_info *wi)
623 gimple stmt = gsi_stmt (*gsi);
624 struct diagnose_tm *d = (struct diagnose_tm *) wi->info;
626 /* Save stmt for use in leaf analysis. */
629 switch (gimple_code (stmt))
633 tree fn = gimple_call_fn (stmt);
635 if ((d->summary_flags & DIAG_TM_OUTER) == 0
636 && is_tm_may_cancel_outer (fn))
637 error_at (gimple_location (stmt),
638 "%<transaction_may_cancel_outer%> function call not within"
639 " outer transaction or %<transaction_may_cancel_outer%>");
641 if (d->summary_flags & DIAG_TM_SAFE)
643 bool is_safe, direct_call_p;
646 if (TREE_CODE (fn) == ADDR_EXPR
647 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL)
649 direct_call_p = true;
650 replacement = TREE_OPERAND (fn, 0);
651 replacement = find_tm_replacement_function (replacement);
657 direct_call_p = false;
658 replacement = NULL_TREE;
661 if (is_tm_safe_or_pure (fn))
663 else if (is_tm_callable (fn) || is_tm_irrevocable (fn))
665 /* A function explicitly marked transaction_callable as
666 opposed to transaction_safe is being defined to be
667 unsafe as part of its ABI, regardless of its contents. */
670 else if (direct_call_p)
672 if (flags_from_decl_or_type (fn) & ECF_TM_BUILTIN)
674 else if (replacement)
676 /* ??? At present we've been considering replacements
677 merely transaction_callable, and therefore might
678 enter irrevocable. The tm_wrap attribute has not
679 yet made it into the new language spec. */
684 /* ??? Diagnostics for unmarked direct calls moved into
685 the IPA pass. Section 3.2 of the spec details how
686 functions not marked should be considered "implicitly
687 safe" based on having examined the function body. */
693 /* An unmarked indirect call. Consider it unsafe even
694 though optimization may yet figure out how to inline. */
700 if (TREE_CODE (fn) == ADDR_EXPR)
701 fn = TREE_OPERAND (fn, 0);
702 if (d->block_flags & DIAG_TM_SAFE)
705 error_at (gimple_location (stmt),
706 "unsafe function call %qD within "
707 "atomic transaction", fn);
710 if (!DECL_P (fn) || DECL_NAME (fn))
711 error_at (gimple_location (stmt),
712 "unsafe function call %qE within "
713 "atomic transaction", fn);
715 error_at (gimple_location (stmt),
716 "unsafe indirect function call within "
717 "atomic transaction");
723 error_at (gimple_location (stmt),
724 "unsafe function call %qD within "
725 "%<transaction_safe%> function", fn);
728 if (!DECL_P (fn) || DECL_NAME (fn))
729 error_at (gimple_location (stmt),
730 "unsafe function call %qE within "
731 "%<transaction_safe%> function", fn);
733 error_at (gimple_location (stmt),
734 "unsafe indirect function call within "
735 "%<transaction_safe%> function");
744 /* ??? We ought to come up with a way to add attributes to
745 asm statements, and then add "transaction_safe" to it.
746 Either that or get the language spec to resurrect __tm_waiver. */
747 if (d->block_flags & DIAG_TM_SAFE)
748 error_at (gimple_location (stmt),
749 "asm not allowed in atomic transaction");
750 else if (d->func_flags & DIAG_TM_SAFE)
751 error_at (gimple_location (stmt),
752 "asm not allowed in %<transaction_safe%> function");
755 case GIMPLE_TRANSACTION:
757 unsigned char inner_flags = DIAG_TM_SAFE;
759 if (gimple_transaction_subcode (stmt) & GTMA_IS_RELAXED)
761 if (d->block_flags & DIAG_TM_SAFE)
762 error_at (gimple_location (stmt),
763 "relaxed transaction in atomic transaction");
764 else if (d->func_flags & DIAG_TM_SAFE)
765 error_at (gimple_location (stmt),
766 "relaxed transaction in %<transaction_safe%> function");
767 inner_flags = DIAG_TM_RELAXED;
769 else if (gimple_transaction_subcode (stmt) & GTMA_IS_OUTER)
772 error_at (gimple_location (stmt),
773 "outer transaction in transaction");
774 else if (d->func_flags & DIAG_TM_OUTER)
775 error_at (gimple_location (stmt),
776 "outer transaction in "
777 "%<transaction_may_cancel_outer%> function");
778 else if (d->func_flags & DIAG_TM_SAFE)
779 error_at (gimple_location (stmt),
780 "outer transaction in %<transaction_safe%> function");
781 inner_flags |= DIAG_TM_OUTER;
784 *handled_ops_p = true;
785 if (gimple_transaction_body (stmt))
787 struct walk_stmt_info wi_inner;
788 struct diagnose_tm d_inner;
790 memset (&d_inner, 0, sizeof (d_inner));
791 d_inner.func_flags = d->func_flags;
792 d_inner.block_flags = d->block_flags | inner_flags;
793 d_inner.summary_flags = d_inner.func_flags | d_inner.block_flags;
795 memset (&wi_inner, 0, sizeof (wi_inner));
796 wi_inner.info = &d_inner;
798 walk_gimple_seq (gimple_transaction_body (stmt),
799 diagnose_tm_1, diagnose_tm_1_op, &wi_inner);
812 diagnose_tm_blocks (void)
814 struct walk_stmt_info wi;
815 struct diagnose_tm d;
817 memset (&d, 0, sizeof (d));
818 if (is_tm_may_cancel_outer (current_function_decl))
819 d.func_flags = DIAG_TM_OUTER | DIAG_TM_SAFE;
820 else if (is_tm_safe (current_function_decl))
821 d.func_flags = DIAG_TM_SAFE;
822 d.summary_flags = d.func_flags;
824 memset (&wi, 0, sizeof (wi));
827 walk_gimple_seq (gimple_body (current_function_decl),
828 diagnose_tm_1, diagnose_tm_1_op, &wi);
835 const pass_data pass_data_diagnose_tm_blocks =
837 GIMPLE_PASS, /* type */
838 "*diagnose_tm_blocks", /* name */
839 OPTGROUP_NONE, /* optinfo_flags */
841 true, /* has_execute */
842 TV_TRANS_MEM, /* tv_id */
843 PROP_gimple_any, /* properties_required */
844 0, /* properties_provided */
845 0, /* properties_destroyed */
846 0, /* todo_flags_start */
847 0, /* todo_flags_finish */
850 class pass_diagnose_tm_blocks : public gimple_opt_pass
853 pass_diagnose_tm_blocks (gcc::context *ctxt)
854 : gimple_opt_pass (pass_data_diagnose_tm_blocks, ctxt)
857 /* opt_pass methods: */
858 bool gate () { return gate_tm (); }
859 unsigned int execute () { return diagnose_tm_blocks (); }
861 }; // class pass_diagnose_tm_blocks
866 make_pass_diagnose_tm_blocks (gcc::context *ctxt)
868 return new pass_diagnose_tm_blocks (ctxt);
871 /* Instead of instrumenting thread private memory, we save the
872 addresses in a log which we later use to save/restore the addresses
873 upon transaction start/restart.
875 The log is keyed by address, where each element contains individual
876 statements among different code paths that perform the store.
878 This log is later used to generate either plain save/restore of the
879 addresses upon transaction start/restart, or calls to the ITM_L*
882 So for something like:
884 struct large { int x[1000]; };
885 struct large lala = { 0 };
891 We can either save/restore:
894 trxn = _ITM_startTransaction ();
895 if (trxn & a_saveLiveVariables)
896 tmp_lala1 = lala.x[i];
897 else if (a & a_restoreLiveVariables)
898 lala.x[i] = tmp_lala1;
900 or use the logging functions:
903 trxn = _ITM_startTransaction ();
904 _ITM_LU4 (&lala.x[i]);
906 Obviously, if we use _ITM_L* to log, we prefer to call _ITM_L* as
907 far up the dominator tree to shadow all of the writes to a given
908 location (thus reducing the total number of logging calls), but not
909 so high as to be called on a path that does not perform a
912 /* One individual log entry. We may have multiple statements for the
913 same location if neither dominate each other (on different
915 typedef struct tm_log_entry
917 /* Address to save. */
919 /* Entry block for the transaction this address occurs in. */
920 basic_block entry_block;
921 /* Dominating statements the store occurs in. */
923 /* Initially, while we are building the log, we place a nonzero
924 value here to mean that this address *will* be saved with a
925 save/restore sequence. Later, when generating the save sequence
926 we place the SSA temp generated here. */
931 /* Log entry hashtable helpers. */
933 struct log_entry_hasher
935 typedef tm_log_entry value_type;
936 typedef tm_log_entry compare_type;
937 static inline hashval_t hash (const value_type *);
938 static inline bool equal (const value_type *, const compare_type *);
939 static inline void remove (value_type *);
942 /* Htab support. Return hash value for a `tm_log_entry'. */
944 log_entry_hasher::hash (const value_type *log)
946 return iterative_hash_expr (log->addr, 0);
949 /* Htab support. Return true if two log entries are the same. */
951 log_entry_hasher::equal (const value_type *log1, const compare_type *log2)
955 rth: I suggest that we get rid of the component refs etc.
956 I.e. resolve the reference to base + offset.
958 We may need to actually finish a merge with mainline for this,
959 since we'd like to be presented with Richi's MEM_REF_EXPRs more
960 often than not. But in the meantime your tm_log_entry could save
961 the results of get_inner_reference.
963 See: g++.dg/tm/pr46653.C
966 /* Special case plain equality because operand_equal_p() below will
967 return FALSE if the addresses are equal but they have
968 side-effects (e.g. a volatile address). */
969 if (log1->addr == log2->addr)
972 return operand_equal_p (log1->addr, log2->addr, 0);
975 /* Htab support. Free one tm_log_entry. */
977 log_entry_hasher::remove (value_type *lp)
979 lp->stmts.release ();
984 /* The actual log. */
985 static hash_table <log_entry_hasher> tm_log;
987 /* Addresses to log with a save/restore sequence. These should be in
989 static vec<tree> tm_log_save_addresses;
991 enum thread_memory_type
995 mem_transaction_local,
999 typedef struct tm_new_mem_map
1001 /* SSA_NAME being dereferenced. */
1003 enum thread_memory_type local_new_memory;
1006 /* Hashtable helpers. */
1008 struct tm_mem_map_hasher : typed_free_remove <tm_new_mem_map_t>
1010 typedef tm_new_mem_map_t value_type;
1011 typedef tm_new_mem_map_t compare_type;
1012 static inline hashval_t hash (const value_type *);
1013 static inline bool equal (const value_type *, const compare_type *);
1017 tm_mem_map_hasher::hash (const value_type *v)
1019 return (intptr_t)v->val >> 4;
1023 tm_mem_map_hasher::equal (const value_type *v, const compare_type *c)
1025 return v->val == c->val;
1028 /* Map for an SSA_NAME originally pointing to a non aliased new piece
1029 of memory (malloc, alloc, etc). */
1030 static hash_table <tm_mem_map_hasher> tm_new_mem_hash;
1032 /* Initialize logging data structures. */
1037 tm_new_mem_hash.create (5);
1038 tm_log_save_addresses.create (5);
1041 /* Free logging data structures. */
1043 tm_log_delete (void)
1046 tm_new_mem_hash.dispose ();
1047 tm_log_save_addresses.release ();
1050 /* Return true if MEM is a transaction invariant memory for the TM
1051 region starting at REGION_ENTRY_BLOCK. */
1053 transaction_invariant_address_p (const_tree mem, basic_block region_entry_block)
1055 if ((TREE_CODE (mem) == INDIRECT_REF || TREE_CODE (mem) == MEM_REF)
1056 && TREE_CODE (TREE_OPERAND (mem, 0)) == SSA_NAME)
1060 def_bb = gimple_bb (SSA_NAME_DEF_STMT (TREE_OPERAND (mem, 0)));
1061 return def_bb != region_entry_block
1062 && dominated_by_p (CDI_DOMINATORS, region_entry_block, def_bb);
1065 mem = strip_invariant_refs (mem);
1066 return mem && (CONSTANT_CLASS_P (mem) || decl_address_invariant_p (mem));
1069 /* Given an address ADDR in STMT, find it in the memory log or add it,
1070 making sure to keep only the addresses highest in the dominator
1073 ENTRY_BLOCK is the entry_block for the transaction.
1075 If we find the address in the log, make sure it's either the same
1076 address, or an equivalent one that dominates ADDR.
1078 If we find the address, but neither ADDR dominates the found
1079 address, nor the found one dominates ADDR, we're on different
1080 execution paths. Add it.
1082 If known, ENTRY_BLOCK is the entry block for the region, otherwise
1085 tm_log_add (basic_block entry_block, tree addr, gimple stmt)
1087 tm_log_entry **slot;
1088 struct tm_log_entry l, *lp;
1091 slot = tm_log.find_slot (&l, INSERT);
1094 tree type = TREE_TYPE (addr);
1096 lp = XNEW (struct tm_log_entry);
1100 /* Small invariant addresses can be handled as save/restores. */
1102 && transaction_invariant_address_p (lp->addr, entry_block)
1103 && TYPE_SIZE_UNIT (type) != NULL
1104 && host_integerp (TYPE_SIZE_UNIT (type), 1)
1105 && (tree_low_cst (TYPE_SIZE_UNIT (type), 1)
1106 < PARAM_VALUE (PARAM_TM_MAX_AGGREGATE_SIZE))
1107 /* We must be able to copy this type normally. I.e., no
1108 special constructors and the like. */
1109 && !TREE_ADDRESSABLE (type))
1111 lp->save_var = create_tmp_reg (TREE_TYPE (lp->addr), "tm_save");
1112 lp->stmts.create (0);
1113 lp->entry_block = entry_block;
1114 /* Save addresses separately in dominator order so we don't
1115 get confused by overlapping addresses in the save/restore
1117 tm_log_save_addresses.safe_push (lp->addr);
1121 /* Use the logging functions. */
1122 lp->stmts.create (5);
1123 lp->stmts.quick_push (stmt);
1124 lp->save_var = NULL;
1134 /* If we're generating a save/restore sequence, we don't care
1135 about statements. */
1139 for (i = 0; lp->stmts.iterate (i, &oldstmt); ++i)
1141 if (stmt == oldstmt)
1143 /* We already have a store to the same address, higher up the
1144 dominator tree. Nothing to do. */
1145 if (dominated_by_p (CDI_DOMINATORS,
1146 gimple_bb (stmt), gimple_bb (oldstmt)))
1148 /* We should be processing blocks in dominator tree order. */
1149 gcc_assert (!dominated_by_p (CDI_DOMINATORS,
1150 gimple_bb (oldstmt), gimple_bb (stmt)));
1152 /* Store is on a different code path. */
1153 lp->stmts.safe_push (stmt);
1157 /* Gimplify the address of a TARGET_MEM_REF. Return the SSA_NAME
1158 result, insert the new statements before GSI. */
1161 gimplify_addr (gimple_stmt_iterator *gsi, tree x)
1163 if (TREE_CODE (x) == TARGET_MEM_REF)
1164 x = tree_mem_ref_addr (build_pointer_type (TREE_TYPE (x)), x);
1166 x = build_fold_addr_expr (x);
1167 return force_gimple_operand_gsi (gsi, x, true, NULL, true, GSI_SAME_STMT);
1170 /* Instrument one address with the logging functions.
1171 ADDR is the address to save.
1172 STMT is the statement before which to place it. */
1174 tm_log_emit_stmt (tree addr, gimple stmt)
1176 tree type = TREE_TYPE (addr);
1177 tree size = TYPE_SIZE_UNIT (type);
1178 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
1180 enum built_in_function code = BUILT_IN_TM_LOG;
1182 if (type == float_type_node)
1183 code = BUILT_IN_TM_LOG_FLOAT;
1184 else if (type == double_type_node)
1185 code = BUILT_IN_TM_LOG_DOUBLE;
1186 else if (type == long_double_type_node)
1187 code = BUILT_IN_TM_LOG_LDOUBLE;
1188 else if (host_integerp (size, 1))
1190 unsigned int n = tree_low_cst (size, 1);
1194 code = BUILT_IN_TM_LOG_1;
1197 code = BUILT_IN_TM_LOG_2;
1200 code = BUILT_IN_TM_LOG_4;
1203 code = BUILT_IN_TM_LOG_8;
1206 code = BUILT_IN_TM_LOG;
1207 if (TREE_CODE (type) == VECTOR_TYPE)
1209 if (n == 8 && builtin_decl_explicit (BUILT_IN_TM_LOG_M64))
1210 code = BUILT_IN_TM_LOG_M64;
1211 else if (n == 16 && builtin_decl_explicit (BUILT_IN_TM_LOG_M128))
1212 code = BUILT_IN_TM_LOG_M128;
1213 else if (n == 32 && builtin_decl_explicit (BUILT_IN_TM_LOG_M256))
1214 code = BUILT_IN_TM_LOG_M256;
1220 addr = gimplify_addr (&gsi, addr);
1221 if (code == BUILT_IN_TM_LOG)
1222 log = gimple_build_call (builtin_decl_explicit (code), 2, addr, size);
1224 log = gimple_build_call (builtin_decl_explicit (code), 1, addr);
1225 gsi_insert_before (&gsi, log, GSI_SAME_STMT);
1228 /* Go through the log and instrument address that must be instrumented
1229 with the logging functions. Leave the save/restore addresses for
1234 hash_table <log_entry_hasher>::iterator hi;
1235 struct tm_log_entry *lp;
1237 FOR_EACH_HASH_TABLE_ELEMENT (tm_log, lp, tm_log_entry_t, hi)
1244 fprintf (dump_file, "TM thread private mem logging: ");
1245 print_generic_expr (dump_file, lp->addr, 0);
1246 fprintf (dump_file, "\n");
1252 fprintf (dump_file, "DUMPING to variable\n");
1258 fprintf (dump_file, "DUMPING with logging functions\n");
1259 for (i = 0; lp->stmts.iterate (i, &stmt); ++i)
1260 tm_log_emit_stmt (lp->addr, stmt);
1265 /* Emit the save sequence for the corresponding addresses in the log.
1266 ENTRY_BLOCK is the entry block for the transaction.
1267 BB is the basic block to insert the code in. */
1269 tm_log_emit_saves (basic_block entry_block, basic_block bb)
1272 gimple_stmt_iterator gsi = gsi_last_bb (bb);
1274 struct tm_log_entry l, *lp;
1276 for (i = 0; i < tm_log_save_addresses.length (); ++i)
1278 l.addr = tm_log_save_addresses[i];
1279 lp = *(tm_log.find_slot (&l, NO_INSERT));
1280 gcc_assert (lp->save_var != NULL);
1282 /* We only care about variables in the current transaction. */
1283 if (lp->entry_block != entry_block)
1286 stmt = gimple_build_assign (lp->save_var, unshare_expr (lp->addr));
1288 /* Make sure we can create an SSA_NAME for this type. For
1289 instance, aggregates aren't allowed, in which case the system
1290 will create a VOP for us and everything will just work. */
1291 if (is_gimple_reg_type (TREE_TYPE (lp->save_var)))
1293 lp->save_var = make_ssa_name (lp->save_var, stmt);
1294 gimple_assign_set_lhs (stmt, lp->save_var);
1297 gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
1301 /* Emit the restore sequence for the corresponding addresses in the log.
1302 ENTRY_BLOCK is the entry block for the transaction.
1303 BB is the basic block to insert the code in. */
1305 tm_log_emit_restores (basic_block entry_block, basic_block bb)
1308 struct tm_log_entry l, *lp;
1309 gimple_stmt_iterator gsi;
1312 for (i = tm_log_save_addresses.length () - 1; i >= 0; i--)
1314 l.addr = tm_log_save_addresses[i];
1315 lp = *(tm_log.find_slot (&l, NO_INSERT));
1316 gcc_assert (lp->save_var != NULL);
1318 /* We only care about variables in the current transaction. */
1319 if (lp->entry_block != entry_block)
1322 /* Restores are in LIFO order from the saves in case we have
1324 gsi = gsi_start_bb (bb);
1326 stmt = gimple_build_assign (unshare_expr (lp->addr), lp->save_var);
1327 gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
1332 static tree lower_sequence_tm (gimple_stmt_iterator *, bool *,
1333 struct walk_stmt_info *);
1334 static tree lower_sequence_no_tm (gimple_stmt_iterator *, bool *,
1335 struct walk_stmt_info *);
1337 /* Evaluate an address X being dereferenced and determine if it
1338 originally points to a non aliased new chunk of memory (malloc,
1341 Return MEM_THREAD_LOCAL if it points to a thread-local address.
1342 Return MEM_TRANSACTION_LOCAL if it points to a transaction-local address.
1343 Return MEM_NON_LOCAL otherwise.
1345 ENTRY_BLOCK is the entry block to the transaction containing the
1346 dereference of X. */
1347 static enum thread_memory_type
1348 thread_private_new_memory (basic_block entry_block, tree x)
1351 enum tree_code code;
1352 tm_new_mem_map_t **slot;
1353 tm_new_mem_map_t elt, *elt_p;
1355 enum thread_memory_type retval = mem_transaction_local;
1358 || TREE_CODE (x) != SSA_NAME
1359 /* Possible uninitialized use, or a function argument. In
1360 either case, we don't care. */
1361 || SSA_NAME_IS_DEFAULT_DEF (x))
1362 return mem_non_local;
1364 /* Look in cache first. */
1366 slot = tm_new_mem_hash.find_slot (&elt, INSERT);
1369 return elt_p->local_new_memory;
1371 /* Optimistically assume the memory is transaction local during
1372 processing. This catches recursion into this variable. */
1373 *slot = elt_p = XNEW (tm_new_mem_map_t);
1375 elt_p->local_new_memory = mem_transaction_local;
1377 /* Search DEF chain to find the original definition of this address. */
1380 if (ptr_deref_may_alias_global_p (x))
1382 /* Address escapes. This is not thread-private. */
1383 retval = mem_non_local;
1384 goto new_memory_ret;
1387 stmt = SSA_NAME_DEF_STMT (x);
1389 /* If the malloc call is outside the transaction, this is
1391 if (retval != mem_thread_local
1392 && !dominated_by_p (CDI_DOMINATORS, gimple_bb (stmt), entry_block))
1393 retval = mem_thread_local;
1395 if (is_gimple_assign (stmt))
1397 code = gimple_assign_rhs_code (stmt);
1398 /* x = foo ==> foo */
1399 if (code == SSA_NAME)
1400 x = gimple_assign_rhs1 (stmt);
1401 /* x = foo + n ==> foo */
1402 else if (code == POINTER_PLUS_EXPR)
1403 x = gimple_assign_rhs1 (stmt);
1404 /* x = (cast*) foo ==> foo */
1405 else if (code == VIEW_CONVERT_EXPR || code == NOP_EXPR)
1406 x = gimple_assign_rhs1 (stmt);
1407 /* x = c ? op1 : op2 == > op1 or op2 just like a PHI */
1408 else if (code == COND_EXPR)
1410 tree op1 = gimple_assign_rhs2 (stmt);
1411 tree op2 = gimple_assign_rhs3 (stmt);
1412 enum thread_memory_type mem;
1413 retval = thread_private_new_memory (entry_block, op1);
1414 if (retval == mem_non_local)
1415 goto new_memory_ret;
1416 mem = thread_private_new_memory (entry_block, op2);
1417 retval = MIN (retval, mem);
1418 goto new_memory_ret;
1422 retval = mem_non_local;
1423 goto new_memory_ret;
1428 if (gimple_code (stmt) == GIMPLE_PHI)
1431 enum thread_memory_type mem;
1432 tree phi_result = gimple_phi_result (stmt);
1434 /* If any of the ancestors are non-local, we are sure to
1435 be non-local. Otherwise we can avoid doing anything
1436 and inherit what has already been generated. */
1438 for (i = 0; i < gimple_phi_num_args (stmt); ++i)
1440 tree op = PHI_ARG_DEF (stmt, i);
1442 /* Exclude self-assignment. */
1443 if (phi_result == op)
1446 mem = thread_private_new_memory (entry_block, op);
1447 if (mem == mem_non_local)
1450 goto new_memory_ret;
1452 retval = MIN (retval, mem);
1454 goto new_memory_ret;
1459 while (TREE_CODE (x) == SSA_NAME);
1461 if (stmt && is_gimple_call (stmt) && gimple_call_flags (stmt) & ECF_MALLOC)
1462 /* Thread-local or transaction-local. */
1465 retval = mem_non_local;
1468 elt_p->local_new_memory = retval;
1472 /* Determine whether X has to be instrumented using a read
1475 ENTRY_BLOCK is the entry block for the region where stmt resides
1476 in. NULL if unknown.
1478 STMT is the statement in which X occurs in. It is used for thread
1479 private memory instrumentation. If no TPM instrumentation is
1480 desired, STMT should be null. */
1482 requires_barrier (basic_block entry_block, tree x, gimple stmt)
1485 while (handled_component_p (x))
1486 x = TREE_OPERAND (x, 0);
1488 switch (TREE_CODE (x))
1493 enum thread_memory_type ret;
1495 ret = thread_private_new_memory (entry_block, TREE_OPERAND (x, 0));
1496 if (ret == mem_non_local)
1498 if (stmt && ret == mem_thread_local)
1499 /* ?? Should we pass `orig', or the INDIRECT_REF X. ?? */
1500 tm_log_add (entry_block, orig, stmt);
1502 /* Transaction-locals require nothing at all. For malloc, a
1503 transaction restart frees the memory and we reallocate.
1504 For alloca, the stack pointer gets reset by the retry and
1509 case TARGET_MEM_REF:
1510 if (TREE_CODE (TMR_BASE (x)) != ADDR_EXPR)
1512 x = TREE_OPERAND (TMR_BASE (x), 0);
1513 if (TREE_CODE (x) == PARM_DECL)
1515 gcc_assert (TREE_CODE (x) == VAR_DECL);
1521 if (DECL_BY_REFERENCE (x))
1523 /* ??? This value is a pointer, but aggregate_value_p has been
1524 jigged to return true which confuses needs_to_live_in_memory.
1525 This ought to be cleaned up generically.
1527 FIXME: Verify this still happens after the next mainline
1528 merge. Testcase ie g++.dg/tm/pr47554.C.
1533 if (is_global_var (x))
1534 return !TREE_READONLY (x);
1535 if (/* FIXME: This condition should actually go below in the
1536 tm_log_add() call, however is_call_clobbered() depends on
1537 aliasing info which is not available during
1538 gimplification. Since requires_barrier() gets called
1539 during lower_sequence_tm/gimplification, leave the call
1540 to needs_to_live_in_memory until we eliminate
1541 lower_sequence_tm altogether. */
1542 needs_to_live_in_memory (x))
1546 /* For local memory that doesn't escape (aka thread private
1547 memory), we can either save the value at the beginning of
1548 the transaction and restore on restart, or call a tm
1549 function to dynamically save and restore on restart
1552 tm_log_add (entry_block, orig, stmt);
1561 /* Mark the GIMPLE_ASSIGN statement as appropriate for being inside
1562 a transaction region. */
1565 examine_assign_tm (unsigned *state, gimple_stmt_iterator *gsi)
1567 gimple stmt = gsi_stmt (*gsi);
1569 if (requires_barrier (/*entry_block=*/NULL, gimple_assign_rhs1 (stmt), NULL))
1570 *state |= GTMA_HAVE_LOAD;
1571 if (requires_barrier (/*entry_block=*/NULL, gimple_assign_lhs (stmt), NULL))
1572 *state |= GTMA_HAVE_STORE;
1575 /* Mark a GIMPLE_CALL as appropriate for being inside a transaction. */
1578 examine_call_tm (unsigned *state, gimple_stmt_iterator *gsi)
1580 gimple stmt = gsi_stmt (*gsi);
1583 if (is_tm_pure_call (stmt))
1586 /* Check if this call is a transaction abort. */
1587 fn = gimple_call_fndecl (stmt);
1588 if (is_tm_abort (fn))
1589 *state |= GTMA_HAVE_ABORT;
1591 /* Note that something may happen. */
1592 *state |= GTMA_HAVE_LOAD | GTMA_HAVE_STORE;
1595 /* Lower a GIMPLE_TRANSACTION statement. */
1598 lower_transaction (gimple_stmt_iterator *gsi, struct walk_stmt_info *wi)
1600 gimple g, stmt = gsi_stmt (*gsi);
1601 unsigned int *outer_state = (unsigned int *) wi->info;
1602 unsigned int this_state = 0;
1603 struct walk_stmt_info this_wi;
1605 /* First, lower the body. The scanning that we do inside gives
1606 us some idea of what we're dealing with. */
1607 memset (&this_wi, 0, sizeof (this_wi));
1608 this_wi.info = (void *) &this_state;
1609 walk_gimple_seq_mod (gimple_transaction_body_ptr (stmt),
1610 lower_sequence_tm, NULL, &this_wi);
1612 /* If there was absolutely nothing transaction related inside the
1613 transaction, we may elide it. Likewise if this is a nested
1614 transaction and does not contain an abort. */
1616 || (!(this_state & GTMA_HAVE_ABORT) && outer_state != NULL))
1619 *outer_state |= this_state;
1621 gsi_insert_seq_before (gsi, gimple_transaction_body (stmt),
1623 gimple_transaction_set_body (stmt, NULL);
1625 gsi_remove (gsi, true);
1626 wi->removed_stmt = true;
1630 /* Wrap the body of the transaction in a try-finally node so that
1631 the commit call is always properly called. */
1632 g = gimple_build_call (builtin_decl_explicit (BUILT_IN_TM_COMMIT), 0);
1633 if (flag_exceptions)
1636 gimple_seq n_seq, e_seq;
1638 n_seq = gimple_seq_alloc_with_stmt (g);
1641 g = gimple_build_call (builtin_decl_explicit (BUILT_IN_EH_POINTER),
1642 1, integer_zero_node);
1643 ptr = create_tmp_var (ptr_type_node, NULL);
1644 gimple_call_set_lhs (g, ptr);
1645 gimple_seq_add_stmt (&e_seq, g);
1647 g = gimple_build_call (builtin_decl_explicit (BUILT_IN_TM_COMMIT_EH),
1649 gimple_seq_add_stmt (&e_seq, g);
1651 g = gimple_build_eh_else (n_seq, e_seq);
1654 g = gimple_build_try (gimple_transaction_body (stmt),
1655 gimple_seq_alloc_with_stmt (g), GIMPLE_TRY_FINALLY);
1656 gsi_insert_after (gsi, g, GSI_CONTINUE_LINKING);
1658 gimple_transaction_set_body (stmt, NULL);
1660 /* If the transaction calls abort or if this is an outer transaction,
1661 add an "over" label afterwards. */
1662 if ((this_state & (GTMA_HAVE_ABORT))
1663 || (gimple_transaction_subcode (stmt) & GTMA_IS_OUTER))
1665 tree label = create_artificial_label (UNKNOWN_LOCATION);
1666 gimple_transaction_set_label (stmt, label);
1667 gsi_insert_after (gsi, gimple_build_label (label), GSI_CONTINUE_LINKING);
1670 /* Record the set of operations found for use later. */
1671 this_state |= gimple_transaction_subcode (stmt) & GTMA_DECLARATION_MASK;
1672 gimple_transaction_set_subcode (stmt, this_state);
1675 /* Iterate through the statements in the sequence, lowering them all
1676 as appropriate for being in a transaction. */
1679 lower_sequence_tm (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1680 struct walk_stmt_info *wi)
1682 unsigned int *state = (unsigned int *) wi->info;
1683 gimple stmt = gsi_stmt (*gsi);
1685 *handled_ops_p = true;
1686 switch (gimple_code (stmt))
1689 /* Only memory reads/writes need to be instrumented. */
1690 if (gimple_assign_single_p (stmt))
1691 examine_assign_tm (state, gsi);
1695 examine_call_tm (state, gsi);
1699 *state |= GTMA_MAY_ENTER_IRREVOCABLE;
1702 case GIMPLE_TRANSACTION:
1703 lower_transaction (gsi, wi);
1707 *handled_ops_p = !gimple_has_substatements (stmt);
1714 /* Iterate through the statements in the sequence, lowering them all
1715 as appropriate for being outside of a transaction. */
1718 lower_sequence_no_tm (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1719 struct walk_stmt_info * wi)
1721 gimple stmt = gsi_stmt (*gsi);
1723 if (gimple_code (stmt) == GIMPLE_TRANSACTION)
1725 *handled_ops_p = true;
1726 lower_transaction (gsi, wi);
1729 *handled_ops_p = !gimple_has_substatements (stmt);
1734 /* Main entry point for flattening GIMPLE_TRANSACTION constructs. After
1735 this, GIMPLE_TRANSACTION nodes still exist, but the nested body has
1736 been moved out, and all the data required for constructing a proper
1737 CFG has been recorded. */
1740 execute_lower_tm (void)
1742 struct walk_stmt_info wi;
1745 /* Transactional clones aren't created until a later pass. */
1746 gcc_assert (!decl_is_tm_clone (current_function_decl));
1748 body = gimple_body (current_function_decl);
1749 memset (&wi, 0, sizeof (wi));
1750 walk_gimple_seq_mod (&body, lower_sequence_no_tm, NULL, &wi);
1751 gimple_set_body (current_function_decl, body);
1758 const pass_data pass_data_lower_tm =
1760 GIMPLE_PASS, /* type */
1761 "tmlower", /* name */
1762 OPTGROUP_NONE, /* optinfo_flags */
1763 true, /* has_gate */
1764 true, /* has_execute */
1765 TV_TRANS_MEM, /* tv_id */
1766 PROP_gimple_lcf, /* properties_required */
1767 0, /* properties_provided */
1768 0, /* properties_destroyed */
1769 0, /* todo_flags_start */
1770 0, /* todo_flags_finish */
1773 class pass_lower_tm : public gimple_opt_pass
1776 pass_lower_tm (gcc::context *ctxt)
1777 : gimple_opt_pass (pass_data_lower_tm, ctxt)
1780 /* opt_pass methods: */
1781 bool gate () { return gate_tm (); }
1782 unsigned int execute () { return execute_lower_tm (); }
1784 }; // class pass_lower_tm
1789 make_pass_lower_tm (gcc::context *ctxt)
1791 return new pass_lower_tm (ctxt);
1794 /* Collect region information for each transaction. */
1798 /* Link to the next unnested transaction. */
1799 struct tm_region *next;
1801 /* Link to the next inner transaction. */
1802 struct tm_region *inner;
1804 /* Link to the next outer transaction. */
1805 struct tm_region *outer;
1807 /* The GIMPLE_TRANSACTION statement beginning this transaction.
1808 After TM_MARK, this gets replaced by a call to
1809 BUILT_IN_TM_START. */
1810 gimple transaction_stmt;
1812 /* After TM_MARK expands the GIMPLE_TRANSACTION into a call to
1813 BUILT_IN_TM_START, this field is true if the transaction is an
1814 outer transaction. */
1815 bool original_transaction_was_outer;
1817 /* Return value from BUILT_IN_TM_START. */
1820 /* The entry block to this region. This will always be the first
1821 block of the body of the transaction. */
1822 basic_block entry_block;
1824 /* The first block after an expanded call to _ITM_beginTransaction. */
1825 basic_block restart_block;
1827 /* The set of all blocks that end the region; NULL if only EXIT_BLOCK.
1828 These blocks are still a part of the region (i.e., the border is
1829 inclusive). Note that this set is only complete for paths in the CFG
1830 starting at ENTRY_BLOCK, and that there is no exit block recorded for
1831 the edge to the "over" label. */
1834 /* The set of all blocks that have an TM_IRREVOCABLE call. */
1838 typedef struct tm_region *tm_region_p;
1840 /* True if there are pending edge statements to be committed for the
1841 current function being scanned in the tmmark pass. */
1842 bool pending_edge_inserts_p;
1844 static struct tm_region *all_tm_regions;
1845 static bitmap_obstack tm_obstack;
1848 /* A subroutine of tm_region_init. Record the existence of the
1849 GIMPLE_TRANSACTION statement in a tree of tm_region elements. */
1851 static struct tm_region *
1852 tm_region_init_0 (struct tm_region *outer, basic_block bb, gimple stmt)
1854 struct tm_region *region;
1856 region = (struct tm_region *)
1857 obstack_alloc (&tm_obstack.obstack, sizeof (struct tm_region));
1861 region->next = outer->inner;
1862 outer->inner = region;
1866 region->next = all_tm_regions;
1867 all_tm_regions = region;
1869 region->inner = NULL;
1870 region->outer = outer;
1872 region->transaction_stmt = stmt;
1873 region->original_transaction_was_outer = false;
1874 region->tm_state = NULL;
1876 /* There are either one or two edges out of the block containing
1877 the GIMPLE_TRANSACTION, one to the actual region and one to the
1878 "over" label if the region contains an abort. The former will
1879 always be the one marked FALLTHRU. */
1880 region->entry_block = FALLTHRU_EDGE (bb)->dest;
1882 region->exit_blocks = BITMAP_ALLOC (&tm_obstack);
1883 region->irr_blocks = BITMAP_ALLOC (&tm_obstack);
1888 /* A subroutine of tm_region_init. Record all the exit and
1889 irrevocable blocks in BB into the region's exit_blocks and
1890 irr_blocks bitmaps. Returns the new region being scanned. */
1892 static struct tm_region *
1893 tm_region_init_1 (struct tm_region *region, basic_block bb)
1895 gimple_stmt_iterator gsi;
1899 || (!region->irr_blocks && !region->exit_blocks))
1902 /* Check to see if this is the end of a region by seeing if it
1903 contains a call to __builtin_tm_commit{,_eh}. Note that the
1904 outermost region for DECL_IS_TM_CLONE need not collect this. */
1905 for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
1908 if (gimple_code (g) == GIMPLE_CALL)
1910 tree fn = gimple_call_fndecl (g);
1911 if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
1913 if ((DECL_FUNCTION_CODE (fn) == BUILT_IN_TM_COMMIT
1914 || DECL_FUNCTION_CODE (fn) == BUILT_IN_TM_COMMIT_EH)
1915 && region->exit_blocks)
1917 bitmap_set_bit (region->exit_blocks, bb->index);
1918 region = region->outer;
1921 if (DECL_FUNCTION_CODE (fn) == BUILT_IN_TM_IRREVOCABLE)
1922 bitmap_set_bit (region->irr_blocks, bb->index);
1929 /* Collect all of the transaction regions within the current function
1930 and record them in ALL_TM_REGIONS. The REGION parameter may specify
1931 an "outermost" region for use by tm clones. */
1934 tm_region_init (struct tm_region *region)
1940 vec<basic_block> queue = vNULL;
1941 bitmap visited_blocks = BITMAP_ALLOC (NULL);
1942 struct tm_region *old_region;
1943 vec<tm_region_p> bb_regions = vNULL;
1945 all_tm_regions = region;
1946 bb = single_succ (ENTRY_BLOCK_PTR);
1948 /* We could store this information in bb->aux, but we may get called
1949 through get_all_tm_blocks() from another pass that may be already
1951 bb_regions.safe_grow_cleared (last_basic_block);
1953 queue.safe_push (bb);
1954 bb_regions[bb->index] = region;
1958 region = bb_regions[bb->index];
1959 bb_regions[bb->index] = NULL;
1961 /* Record exit and irrevocable blocks. */
1962 region = tm_region_init_1 (region, bb);
1964 /* Check for the last statement in the block beginning a new region. */
1966 old_region = region;
1967 if (g && gimple_code (g) == GIMPLE_TRANSACTION)
1968 region = tm_region_init_0 (region, bb, g);
1970 /* Process subsequent blocks. */
1971 FOR_EACH_EDGE (e, ei, bb->succs)
1972 if (!bitmap_bit_p (visited_blocks, e->dest->index))
1974 bitmap_set_bit (visited_blocks, e->dest->index);
1975 queue.safe_push (e->dest);
1977 /* If the current block started a new region, make sure that only
1978 the entry block of the new region is associated with this region.
1979 Other successors are still part of the old region. */
1980 if (old_region != region && e->dest != region->entry_block)
1981 bb_regions[e->dest->index] = old_region;
1983 bb_regions[e->dest->index] = region;
1986 while (!queue.is_empty ());
1988 BITMAP_FREE (visited_blocks);
1989 bb_regions.release ();
1992 /* The "gate" function for all transactional memory expansion and optimization
1993 passes. We collect region information for each top-level transaction, and
1994 if we don't find any, we skip all of the TM passes. Each region will have
1995 all of the exit blocks recorded, and the originating statement. */
2003 calculate_dominance_info (CDI_DOMINATORS);
2004 bitmap_obstack_initialize (&tm_obstack);
2006 /* If the function is a TM_CLONE, then the entire function is the region. */
2007 if (decl_is_tm_clone (current_function_decl))
2009 struct tm_region *region = (struct tm_region *)
2010 obstack_alloc (&tm_obstack.obstack, sizeof (struct tm_region));
2011 memset (region, 0, sizeof (*region));
2012 region->entry_block = single_succ (ENTRY_BLOCK_PTR);
2013 /* For a clone, the entire function is the region. But even if
2014 we don't need to record any exit blocks, we may need to
2015 record irrevocable blocks. */
2016 region->irr_blocks = BITMAP_ALLOC (&tm_obstack);
2018 tm_region_init (region);
2022 tm_region_init (NULL);
2024 /* If we didn't find any regions, cleanup and skip the whole tree
2025 of tm-related optimizations. */
2026 if (all_tm_regions == NULL)
2028 bitmap_obstack_release (&tm_obstack);
2038 const pass_data pass_data_tm_init =
2040 GIMPLE_PASS, /* type */
2041 "*tminit", /* name */
2042 OPTGROUP_NONE, /* optinfo_flags */
2043 true, /* has_gate */
2044 false, /* has_execute */
2045 TV_TRANS_MEM, /* tv_id */
2046 ( PROP_ssa | PROP_cfg ), /* properties_required */
2047 0, /* properties_provided */
2048 0, /* properties_destroyed */
2049 0, /* todo_flags_start */
2050 0, /* todo_flags_finish */
2053 class pass_tm_init : public gimple_opt_pass
2056 pass_tm_init (gcc::context *ctxt)
2057 : gimple_opt_pass (pass_data_tm_init, ctxt)
2060 /* opt_pass methods: */
2061 bool gate () { return gate_tm_init (); }
2063 }; // class pass_tm_init
2068 make_pass_tm_init (gcc::context *ctxt)
2070 return new pass_tm_init (ctxt);
2073 /* Add FLAGS to the GIMPLE_TRANSACTION subcode for the transaction region
2074 represented by STATE. */
2077 transaction_subcode_ior (struct tm_region *region, unsigned flags)
2079 if (region && region->transaction_stmt)
2081 flags |= gimple_transaction_subcode (region->transaction_stmt);
2082 gimple_transaction_set_subcode (region->transaction_stmt, flags);
2086 /* Construct a memory load in a transactional context. Return the
2087 gimple statement performing the load, or NULL if there is no
2088 TM_LOAD builtin of the appropriate size to do the load.
2090 LOC is the location to use for the new statement(s). */
2093 build_tm_load (location_t loc, tree lhs, tree rhs, gimple_stmt_iterator *gsi)
2095 enum built_in_function code = END_BUILTINS;
2096 tree t, type = TREE_TYPE (rhs), decl;
2099 if (type == float_type_node)
2100 code = BUILT_IN_TM_LOAD_FLOAT;
2101 else if (type == double_type_node)
2102 code = BUILT_IN_TM_LOAD_DOUBLE;
2103 else if (type == long_double_type_node)
2104 code = BUILT_IN_TM_LOAD_LDOUBLE;
2105 else if (TYPE_SIZE_UNIT (type) != NULL
2106 && host_integerp (TYPE_SIZE_UNIT (type), 1))
2108 switch (tree_low_cst (TYPE_SIZE_UNIT (type), 1))
2111 code = BUILT_IN_TM_LOAD_1;
2114 code = BUILT_IN_TM_LOAD_2;
2117 code = BUILT_IN_TM_LOAD_4;
2120 code = BUILT_IN_TM_LOAD_8;
2125 if (code == END_BUILTINS)
2127 decl = targetm.vectorize.builtin_tm_load (type);
2132 decl = builtin_decl_explicit (code);
2134 t = gimplify_addr (gsi, rhs);
2135 gcall = gimple_build_call (decl, 1, t);
2136 gimple_set_location (gcall, loc);
2138 t = TREE_TYPE (TREE_TYPE (decl));
2139 if (useless_type_conversion_p (type, t))
2141 gimple_call_set_lhs (gcall, lhs);
2142 gsi_insert_before (gsi, gcall, GSI_SAME_STMT);
2149 temp = create_tmp_reg (t, NULL);
2150 gimple_call_set_lhs (gcall, temp);
2151 gsi_insert_before (gsi, gcall, GSI_SAME_STMT);
2153 t = fold_build1 (VIEW_CONVERT_EXPR, type, temp);
2154 g = gimple_build_assign (lhs, t);
2155 gsi_insert_before (gsi, g, GSI_SAME_STMT);
2162 /* Similarly for storing TYPE in a transactional context. */
2165 build_tm_store (location_t loc, tree lhs, tree rhs, gimple_stmt_iterator *gsi)
2167 enum built_in_function code = END_BUILTINS;
2168 tree t, fn, type = TREE_TYPE (rhs), simple_type;
2171 if (type == float_type_node)
2172 code = BUILT_IN_TM_STORE_FLOAT;
2173 else if (type == double_type_node)
2174 code = BUILT_IN_TM_STORE_DOUBLE;
2175 else if (type == long_double_type_node)
2176 code = BUILT_IN_TM_STORE_LDOUBLE;
2177 else if (TYPE_SIZE_UNIT (type) != NULL
2178 && host_integerp (TYPE_SIZE_UNIT (type), 1))
2180 switch (tree_low_cst (TYPE_SIZE_UNIT (type), 1))
2183 code = BUILT_IN_TM_STORE_1;
2186 code = BUILT_IN_TM_STORE_2;
2189 code = BUILT_IN_TM_STORE_4;
2192 code = BUILT_IN_TM_STORE_8;
2197 if (code == END_BUILTINS)
2199 fn = targetm.vectorize.builtin_tm_store (type);
2204 fn = builtin_decl_explicit (code);
2206 simple_type = TREE_VALUE (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn))));
2208 if (TREE_CODE (rhs) == CONSTRUCTOR)
2210 /* Handle the easy initialization to zero. */
2211 if (!CONSTRUCTOR_ELTS (rhs))
2212 rhs = build_int_cst (simple_type, 0);
2215 /* ...otherwise punt to the caller and probably use
2216 BUILT_IN_TM_MEMMOVE, because we can't wrap a
2217 VIEW_CONVERT_EXPR around a CONSTRUCTOR (below) and produce
2222 else if (!useless_type_conversion_p (simple_type, type))
2227 temp = create_tmp_reg (simple_type, NULL);
2228 t = fold_build1 (VIEW_CONVERT_EXPR, simple_type, rhs);
2229 g = gimple_build_assign (temp, t);
2230 gimple_set_location (g, loc);
2231 gsi_insert_before (gsi, g, GSI_SAME_STMT);
2236 t = gimplify_addr (gsi, lhs);
2237 gcall = gimple_build_call (fn, 2, t, rhs);
2238 gimple_set_location (gcall, loc);
2239 gsi_insert_before (gsi, gcall, GSI_SAME_STMT);
2245 /* Expand an assignment statement into transactional builtins. */
2248 expand_assign_tm (struct tm_region *region, gimple_stmt_iterator *gsi)
2250 gimple stmt = gsi_stmt (*gsi);
2251 location_t loc = gimple_location (stmt);
2252 tree lhs = gimple_assign_lhs (stmt);
2253 tree rhs = gimple_assign_rhs1 (stmt);
2254 bool store_p = requires_barrier (region->entry_block, lhs, NULL);
2255 bool load_p = requires_barrier (region->entry_block, rhs, NULL);
2256 gimple gcall = NULL;
2258 if (!load_p && !store_p)
2260 /* Add thread private addresses to log if applicable. */
2261 requires_barrier (region->entry_block, lhs, stmt);
2266 // Remove original load/store statement.
2267 gsi_remove (gsi, true);
2269 if (load_p && !store_p)
2271 transaction_subcode_ior (region, GTMA_HAVE_LOAD);
2272 gcall = build_tm_load (loc, lhs, rhs, gsi);
2274 else if (store_p && !load_p)
2276 transaction_subcode_ior (region, GTMA_HAVE_STORE);
2277 gcall = build_tm_store (loc, lhs, rhs, gsi);
2281 tree lhs_addr, rhs_addr, tmp;
2284 transaction_subcode_ior (region, GTMA_HAVE_LOAD);
2286 transaction_subcode_ior (region, GTMA_HAVE_STORE);
2288 /* ??? Figure out if there's any possible overlap between the LHS
2289 and the RHS and if not, use MEMCPY. */
2291 if (load_p && is_gimple_reg (lhs))
2293 tmp = create_tmp_var (TREE_TYPE (lhs), NULL);
2294 lhs_addr = build_fold_addr_expr (tmp);
2299 lhs_addr = gimplify_addr (gsi, lhs);
2301 rhs_addr = gimplify_addr (gsi, rhs);
2302 gcall = gimple_build_call (builtin_decl_explicit (BUILT_IN_TM_MEMMOVE),
2303 3, lhs_addr, rhs_addr,
2304 TYPE_SIZE_UNIT (TREE_TYPE (lhs)));
2305 gimple_set_location (gcall, loc);
2306 gsi_insert_before (gsi, gcall, GSI_SAME_STMT);
2310 gcall = gimple_build_assign (lhs, tmp);
2311 gsi_insert_before (gsi, gcall, GSI_SAME_STMT);
2315 /* Now that we have the load/store in its instrumented form, add
2316 thread private addresses to the log if applicable. */
2318 requires_barrier (region->entry_block, lhs, gcall);
2320 // The calls to build_tm_{store,load} above inserted the instrumented
2321 // call into the stream.
2322 // gsi_insert_before (gsi, gcall, GSI_SAME_STMT);
2326 /* Expand a call statement as appropriate for a transaction. That is,
2327 either verify that the call does not affect the transaction, or
2328 redirect the call to a clone that handles transactions, or change
2329 the transaction state to IRREVOCABLE. Return true if the call is
2330 one of the builtins that end a transaction. */
2333 expand_call_tm (struct tm_region *region,
2334 gimple_stmt_iterator *gsi)
2336 gimple stmt = gsi_stmt (*gsi);
2337 tree lhs = gimple_call_lhs (stmt);
2339 struct cgraph_node *node;
2340 bool retval = false;
2342 fn_decl = gimple_call_fndecl (stmt);
2344 if (fn_decl == builtin_decl_explicit (BUILT_IN_TM_MEMCPY)
2345 || fn_decl == builtin_decl_explicit (BUILT_IN_TM_MEMMOVE))
2346 transaction_subcode_ior (region, GTMA_HAVE_STORE | GTMA_HAVE_LOAD);
2347 if (fn_decl == builtin_decl_explicit (BUILT_IN_TM_MEMSET))
2348 transaction_subcode_ior (region, GTMA_HAVE_STORE);
2350 if (is_tm_pure_call (stmt))
2354 retval = is_tm_ending_fndecl (fn_decl);
2357 /* Assume all non-const/pure calls write to memory, except
2358 transaction ending builtins. */
2359 transaction_subcode_ior (region, GTMA_HAVE_STORE);
2362 /* For indirect calls, we already generated a call into the runtime. */
2365 tree fn = gimple_call_fn (stmt);
2367 /* We are guaranteed never to go irrevocable on a safe or pure
2368 call, and the pure call was handled above. */
2369 if (is_tm_safe (fn))
2372 transaction_subcode_ior (region, GTMA_MAY_ENTER_IRREVOCABLE);
2377 node = cgraph_get_node (fn_decl);
2378 /* All calls should have cgraph here. */
2381 /* We can have a nodeless call here if some pass after IPA-tm
2382 added uninstrumented calls. For example, loop distribution
2383 can transform certain loop constructs into __builtin_mem*
2384 calls. In this case, see if we have a suitable TM
2385 replacement and fill in the gaps. */
2386 gcc_assert (DECL_BUILT_IN_CLASS (fn_decl) == BUILT_IN_NORMAL);
2387 enum built_in_function code = DECL_FUNCTION_CODE (fn_decl);
2388 gcc_assert (code == BUILT_IN_MEMCPY
2389 || code == BUILT_IN_MEMMOVE
2390 || code == BUILT_IN_MEMSET);
2392 tree repl = find_tm_replacement_function (fn_decl);
2395 gimple_call_set_fndecl (stmt, repl);
2397 node = cgraph_create_node (repl);
2398 node->local.tm_may_enter_irr = false;
2399 return expand_call_tm (region, gsi);
2403 if (node->local.tm_may_enter_irr)
2404 transaction_subcode_ior (region, GTMA_MAY_ENTER_IRREVOCABLE);
2406 if (is_tm_abort (fn_decl))
2408 transaction_subcode_ior (region, GTMA_HAVE_ABORT);
2412 /* Instrument the store if needed.
2414 If the assignment happens inside the function call (return slot
2415 optimization), there is no instrumentation to be done, since
2416 the callee should have done the right thing. */
2417 if (lhs && requires_barrier (region->entry_block, lhs, stmt)
2418 && !gimple_call_return_slot_opt_p (stmt))
2420 tree tmp = create_tmp_reg (TREE_TYPE (lhs), NULL);
2421 location_t loc = gimple_location (stmt);
2422 edge fallthru_edge = NULL;
2424 /* Remember if the call was going to throw. */
2425 if (stmt_can_throw_internal (stmt))
2429 basic_block bb = gimple_bb (stmt);
2431 FOR_EACH_EDGE (e, ei, bb->succs)
2432 if (e->flags & EDGE_FALLTHRU)
2439 gimple_call_set_lhs (stmt, tmp);
2441 stmt = gimple_build_assign (lhs, tmp);
2442 gimple_set_location (stmt, loc);
2444 /* We cannot throw in the middle of a BB. If the call was going
2445 to throw, place the instrumentation on the fallthru edge, so
2446 the call remains the last statement in the block. */
2449 gimple_seq fallthru_seq = gimple_seq_alloc_with_stmt (stmt);
2450 gimple_stmt_iterator fallthru_gsi = gsi_start (fallthru_seq);
2451 expand_assign_tm (region, &fallthru_gsi);
2452 gsi_insert_seq_on_edge (fallthru_edge, fallthru_seq);
2453 pending_edge_inserts_p = true;
2457 gsi_insert_after (gsi, stmt, GSI_CONTINUE_LINKING);
2458 expand_assign_tm (region, gsi);
2461 transaction_subcode_ior (region, GTMA_HAVE_STORE);
2468 /* Expand all statements in BB as appropriate for being inside
2472 expand_block_tm (struct tm_region *region, basic_block bb)
2474 gimple_stmt_iterator gsi;
2476 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
2478 gimple stmt = gsi_stmt (gsi);
2479 switch (gimple_code (stmt))
2482 /* Only memory reads/writes need to be instrumented. */
2483 if (gimple_assign_single_p (stmt)
2484 && !gimple_clobber_p (stmt))
2486 expand_assign_tm (region, &gsi);
2492 if (expand_call_tm (region, &gsi))
2502 if (!gsi_end_p (gsi))
2507 /* Return the list of basic-blocks in REGION.
2509 STOP_AT_IRREVOCABLE_P is true if caller is uninterested in blocks
2510 following a TM_IRREVOCABLE call.
2512 INCLUDE_UNINSTRUMENTED_P is TRUE if we should include the
2513 uninstrumented code path blocks in the list of basic blocks
2514 returned, false otherwise. */
2516 static vec<basic_block>
2517 get_tm_region_blocks (basic_block entry_block,
2520 bitmap all_region_blocks,
2521 bool stop_at_irrevocable_p,
2522 bool include_uninstrumented_p = true)
2524 vec<basic_block> bbs = vNULL;
2528 bitmap visited_blocks = BITMAP_ALLOC (NULL);
2531 bbs.safe_push (entry_block);
2532 bitmap_set_bit (visited_blocks, entry_block->index);
2536 basic_block bb = bbs[i++];
2539 bitmap_bit_p (exit_blocks, bb->index))
2542 if (stop_at_irrevocable_p
2544 && bitmap_bit_p (irr_blocks, bb->index))
2547 FOR_EACH_EDGE (e, ei, bb->succs)
2548 if ((include_uninstrumented_p
2549 || !(e->flags & EDGE_TM_UNINSTRUMENTED))
2550 && !bitmap_bit_p (visited_blocks, e->dest->index))
2552 bitmap_set_bit (visited_blocks, e->dest->index);
2553 bbs.safe_push (e->dest);
2556 while (i < bbs.length ());
2558 if (all_region_blocks)
2559 bitmap_ior_into (all_region_blocks, visited_blocks);
2561 BITMAP_FREE (visited_blocks);
2565 // Callback data for collect_bb2reg.
2568 vec<tm_region_p> *bb2reg;
2569 bool include_uninstrumented_p;
2572 // Callback for expand_regions, collect innermost region data for each bb.
2574 collect_bb2reg (struct tm_region *region, void *data)
2576 struct bb2reg_stuff *stuff = (struct bb2reg_stuff *)data;
2577 vec<tm_region_p> *bb2reg = stuff->bb2reg;
2578 vec<basic_block> queue;
2582 queue = get_tm_region_blocks (region->entry_block,
2583 region->exit_blocks,
2586 /*stop_at_irr_p=*/true,
2587 stuff->include_uninstrumented_p);
2589 // We expect expand_region to perform a post-order traversal of the region
2590 // tree. Therefore the last region seen for any bb is the innermost.
2591 FOR_EACH_VEC_ELT (queue, i, bb)
2592 (*bb2reg)[bb->index] = region;
2598 // Returns a vector, indexed by BB->INDEX, of the innermost tm_region to
2599 // which a basic block belongs. Note that we only consider the instrumented
2600 // code paths for the region; the uninstrumented code paths are ignored if
2601 // INCLUDE_UNINSTRUMENTED_P is false.
2603 // ??? This data is very similar to the bb_regions array that is collected
2604 // during tm_region_init. Or, rather, this data is similar to what could
2605 // be used within tm_region_init. The actual computation in tm_region_init
2606 // begins and ends with bb_regions entirely full of NULL pointers, due to
2607 // the way in which pointers are swapped in and out of the array.
2609 // ??? Our callers expect that blocks are not shared between transactions.
2610 // When the optimizers get too smart, and blocks are shared, then during
2611 // the tm_mark phase we'll add log entries to only one of the two transactions,
2612 // and in the tm_edge phase we'll add edges to the CFG that create invalid
2613 // cycles. The symptom being SSA defs that do not dominate their uses.
2614 // Note that the optimizers were locally correct with their transformation,
2615 // as we have no info within the program that suggests that the blocks cannot
2618 // ??? There is currently a hack inside tree-ssa-pre.c to work around the
2619 // only known instance of this block sharing.
2621 static vec<tm_region_p>
2622 get_bb_regions_instrumented (bool traverse_clones,
2623 bool include_uninstrumented_p)
2625 unsigned n = last_basic_block;
2626 struct bb2reg_stuff stuff;
2627 vec<tm_region_p> ret;
2630 ret.safe_grow_cleared (n);
2631 stuff.bb2reg = &ret;
2632 stuff.include_uninstrumented_p = include_uninstrumented_p;
2633 expand_regions (all_tm_regions, collect_bb2reg, &stuff, traverse_clones);
2638 /* Set the IN_TRANSACTION for all gimple statements that appear in a
2642 compute_transaction_bits (void)
2644 struct tm_region *region;
2645 vec<basic_block> queue;
2649 /* ?? Perhaps we need to abstract gate_tm_init further, because we
2650 certainly don't need it to calculate CDI_DOMINATOR info. */
2654 bb->flags &= ~BB_IN_TRANSACTION;
2656 for (region = all_tm_regions; region; region = region->next)
2658 queue = get_tm_region_blocks (region->entry_block,
2659 region->exit_blocks,
2662 /*stop_at_irr_p=*/true);
2663 for (i = 0; queue.iterate (i, &bb); ++i)
2664 bb->flags |= BB_IN_TRANSACTION;
2669 bitmap_obstack_release (&tm_obstack);
2672 /* Replace the GIMPLE_TRANSACTION in this region with the corresponding
2673 call to BUILT_IN_TM_START. */
2676 expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED)
2678 tree tm_start = builtin_decl_explicit (BUILT_IN_TM_START);
2679 basic_block transaction_bb = gimple_bb (region->transaction_stmt);
2680 tree tm_state = region->tm_state;
2681 tree tm_state_type = TREE_TYPE (tm_state);
2682 edge abort_edge = NULL;
2683 edge inst_edge = NULL;
2684 edge uninst_edge = NULL;
2685 edge fallthru_edge = NULL;
2687 // Identify the various successors of the transaction start.
2691 FOR_EACH_EDGE (e, i, transaction_bb->succs)
2693 if (e->flags & EDGE_TM_ABORT)
2695 else if (e->flags & EDGE_TM_UNINSTRUMENTED)
2699 if (e->flags & EDGE_FALLTHRU)
2704 /* ??? There are plenty of bits here we're not computing. */
2706 int subcode = gimple_transaction_subcode (region->transaction_stmt);
2708 if (subcode & GTMA_DOES_GO_IRREVOCABLE)
2709 flags |= PR_DOESGOIRREVOCABLE;
2710 if ((subcode & GTMA_MAY_ENTER_IRREVOCABLE) == 0)
2711 flags |= PR_HASNOIRREVOCABLE;
2712 /* If the transaction does not have an abort in lexical scope and is not
2713 marked as an outer transaction, then it will never abort. */
2714 if ((subcode & GTMA_HAVE_ABORT) == 0 && (subcode & GTMA_IS_OUTER) == 0)
2715 flags |= PR_HASNOABORT;
2716 if ((subcode & GTMA_HAVE_STORE) == 0)
2717 flags |= PR_READONLY;
2718 if (inst_edge && !(subcode & GTMA_HAS_NO_INSTRUMENTATION))
2719 flags |= PR_INSTRUMENTEDCODE;
2721 flags |= PR_UNINSTRUMENTEDCODE;
2722 if (subcode & GTMA_IS_OUTER)
2723 region->original_transaction_was_outer = true;
2724 tree t = build_int_cst (tm_state_type, flags);
2725 gimple call = gimple_build_call (tm_start, 1, t);
2726 gimple_call_set_lhs (call, tm_state);
2727 gimple_set_location (call, gimple_location (region->transaction_stmt));
2729 // Replace the GIMPLE_TRANSACTION with the call to BUILT_IN_TM_START.
2730 gimple_stmt_iterator gsi = gsi_last_bb (transaction_bb);
2731 gcc_assert (gsi_stmt (gsi) == region->transaction_stmt);
2732 gsi_insert_before (&gsi, call, GSI_SAME_STMT);
2733 gsi_remove (&gsi, true);
2734 region->transaction_stmt = call;
2737 // Generate log saves.
2738 if (!tm_log_save_addresses.is_empty ())
2739 tm_log_emit_saves (region->entry_block, transaction_bb);
2741 // In the beginning, we've no tests to perform on transaction restart.
2742 // Note that after this point, transaction_bb becomes the "most recent
2743 // block containing tests for the transaction".
2744 region->restart_block = region->entry_block;
2746 // Generate log restores.
2747 if (!tm_log_save_addresses.is_empty ())
2749 basic_block test_bb = create_empty_bb (transaction_bb);
2750 basic_block code_bb = create_empty_bb (test_bb);
2751 basic_block join_bb = create_empty_bb (code_bb);
2752 if (current_loops && transaction_bb->loop_father)
2754 add_bb_to_loop (test_bb, transaction_bb->loop_father);
2755 add_bb_to_loop (code_bb, transaction_bb->loop_father);
2756 add_bb_to_loop (join_bb, transaction_bb->loop_father);
2758 if (region->restart_block == region->entry_block)
2759 region->restart_block = test_bb;
2761 tree t1 = create_tmp_reg (tm_state_type, NULL);
2762 tree t2 = build_int_cst (tm_state_type, A_RESTORELIVEVARIABLES);
2763 gimple stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
2765 gimple_stmt_iterator gsi = gsi_last_bb (test_bb);
2766 gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
2768 t2 = build_int_cst (tm_state_type, 0);
2769 stmt = gimple_build_cond (NE_EXPR, t1, t2, NULL, NULL);
2770 gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
2772 tm_log_emit_restores (region->entry_block, code_bb);
2774 edge ei = make_edge (transaction_bb, test_bb, EDGE_FALLTHRU);
2775 edge et = make_edge (test_bb, code_bb, EDGE_TRUE_VALUE);
2776 edge ef = make_edge (test_bb, join_bb, EDGE_FALSE_VALUE);
2777 redirect_edge_pred (fallthru_edge, join_bb);
2779 join_bb->frequency = test_bb->frequency = transaction_bb->frequency;
2780 join_bb->count = test_bb->count = transaction_bb->count;
2782 ei->probability = PROB_ALWAYS;
2783 et->probability = PROB_LIKELY;
2784 ef->probability = PROB_UNLIKELY;
2785 et->count = apply_probability (test_bb->count, et->probability);
2786 ef->count = apply_probability (test_bb->count, ef->probability);
2788 code_bb->count = et->count;
2789 code_bb->frequency = EDGE_FREQUENCY (et);
2791 transaction_bb = join_bb;
2794 // If we have an ABORT edge, create a test to perform the abort.
2797 basic_block test_bb = create_empty_bb (transaction_bb);
2798 if (current_loops && transaction_bb->loop_father)
2799 add_bb_to_loop (test_bb, transaction_bb->loop_father);
2800 if (region->restart_block == region->entry_block)
2801 region->restart_block = test_bb;
2803 tree t1 = create_tmp_reg (tm_state_type, NULL);
2804 tree t2 = build_int_cst (tm_state_type, A_ABORTTRANSACTION);
2805 gimple stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
2807 gimple_stmt_iterator gsi = gsi_last_bb (test_bb);
2808 gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
2810 t2 = build_int_cst (tm_state_type, 0);
2811 stmt = gimple_build_cond (NE_EXPR, t1, t2, NULL, NULL);
2812 gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
2814 edge ei = make_edge (transaction_bb, test_bb, EDGE_FALLTHRU);
2815 test_bb->frequency = transaction_bb->frequency;
2816 test_bb->count = transaction_bb->count;
2817 ei->probability = PROB_ALWAYS;
2819 // Not abort edge. If both are live, chose one at random as we'll
2820 // we'll be fixing that up below.
2821 redirect_edge_pred (fallthru_edge, test_bb);
2822 fallthru_edge->flags = EDGE_FALSE_VALUE;
2823 fallthru_edge->probability = PROB_VERY_LIKELY;
2824 fallthru_edge->count
2825 = apply_probability (test_bb->count, fallthru_edge->probability);
2828 redirect_edge_pred (abort_edge, test_bb);
2829 abort_edge->flags = EDGE_TRUE_VALUE;
2830 abort_edge->probability = PROB_VERY_UNLIKELY;
2832 = apply_probability (test_bb->count, abort_edge->probability);
2834 transaction_bb = test_bb;
2837 // If we have both instrumented and uninstrumented code paths, select one.
2838 if (inst_edge && uninst_edge)
2840 basic_block test_bb = create_empty_bb (transaction_bb);
2841 if (current_loops && transaction_bb->loop_father)
2842 add_bb_to_loop (test_bb, transaction_bb->loop_father);
2843 if (region->restart_block == region->entry_block)
2844 region->restart_block = test_bb;
2846 tree t1 = create_tmp_reg (tm_state_type, NULL);
2847 tree t2 = build_int_cst (tm_state_type, A_RUNUNINSTRUMENTEDCODE);
2849 gimple stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
2851 gimple_stmt_iterator gsi = gsi_last_bb (test_bb);
2852 gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
2854 t2 = build_int_cst (tm_state_type, 0);
2855 stmt = gimple_build_cond (NE_EXPR, t1, t2, NULL, NULL);
2856 gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
2858 // Create the edge into test_bb first, as we want to copy values
2859 // out of the fallthru edge.
2860 edge e = make_edge (transaction_bb, test_bb, fallthru_edge->flags);
2861 e->probability = fallthru_edge->probability;
2862 test_bb->count = e->count = fallthru_edge->count;
2863 test_bb->frequency = EDGE_FREQUENCY (e);
2865 // Now update the edges to the inst/uninist implementations.
2866 // For now assume that the paths are equally likely. When using HTM,
2867 // we'll try the uninst path first and fallback to inst path if htm
2868 // buffers are exceeded. Without HTM we start with the inst path and
2869 // use the uninst path when falling back to serial mode.
2870 redirect_edge_pred (inst_edge, test_bb);
2871 inst_edge->flags = EDGE_FALSE_VALUE;
2872 inst_edge->probability = REG_BR_PROB_BASE / 2;
2874 = apply_probability (test_bb->count, inst_edge->probability);
2876 redirect_edge_pred (uninst_edge, test_bb);
2877 uninst_edge->flags = EDGE_TRUE_VALUE;
2878 uninst_edge->probability = REG_BR_PROB_BASE / 2;
2880 = apply_probability (test_bb->count, uninst_edge->probability);
2883 // If we have no previous special cases, and we have PHIs at the beginning
2884 // of the atomic region, this means we have a loop at the beginning of the
2885 // atomic region that shares the first block. This can cause problems with
2886 // the transaction restart abnormal edges to be added in the tm_edges pass.
2887 // Solve this by adding a new empty block to receive the abnormal edges.
2888 if (region->restart_block == region->entry_block
2889 && phi_nodes (region->entry_block))
2891 basic_block empty_bb = create_empty_bb (transaction_bb);
2892 region->restart_block = empty_bb;
2893 if (current_loops && transaction_bb->loop_father)
2894 add_bb_to_loop (empty_bb, transaction_bb->loop_father);
2896 redirect_edge_pred (fallthru_edge, empty_bb);
2897 make_edge (transaction_bb, empty_bb, EDGE_FALLTHRU);
2903 /* Generate the temporary to be used for the return value of
2904 BUILT_IN_TM_START. */
2907 generate_tm_state (struct tm_region *region, void *data ATTRIBUTE_UNUSED)
2909 tree tm_start = builtin_decl_explicit (BUILT_IN_TM_START);
2911 create_tmp_reg (TREE_TYPE (TREE_TYPE (tm_start)), "tm_state");
2913 // Reset the subcode, post optimizations. We'll fill this in
2914 // again as we process blocks.
2915 if (region->exit_blocks)
2917 unsigned int subcode
2918 = gimple_transaction_subcode (region->transaction_stmt);
2920 if (subcode & GTMA_DOES_GO_IRREVOCABLE)
2921 subcode &= (GTMA_DECLARATION_MASK | GTMA_DOES_GO_IRREVOCABLE
2922 | GTMA_MAY_ENTER_IRREVOCABLE
2923 | GTMA_HAS_NO_INSTRUMENTATION);
2925 subcode &= GTMA_DECLARATION_MASK;
2926 gimple_transaction_set_subcode (region->transaction_stmt, subcode);
2932 // Propagate flags from inner transactions outwards.
2934 propagate_tm_flags_out (struct tm_region *region)
2938 propagate_tm_flags_out (region->inner);
2940 if (region->outer && region->outer->transaction_stmt)
2942 unsigned s = gimple_transaction_subcode (region->transaction_stmt);
2943 s &= (GTMA_HAVE_ABORT | GTMA_HAVE_LOAD | GTMA_HAVE_STORE
2944 | GTMA_MAY_ENTER_IRREVOCABLE);
2945 s |= gimple_transaction_subcode (region->outer->transaction_stmt);
2946 gimple_transaction_set_subcode (region->outer->transaction_stmt, s);
2949 propagate_tm_flags_out (region->next);
2952 /* Entry point to the MARK phase of TM expansion. Here we replace
2953 transactional memory statements with calls to builtins, and function
2954 calls with their transactional clones (if available). But we don't
2955 yet lower GIMPLE_TRANSACTION or add the transaction restart back-edges. */
2958 execute_tm_mark (void)
2960 pending_edge_inserts_p = false;
2962 expand_regions (all_tm_regions, generate_tm_state, NULL,
2963 /*traverse_clones=*/true);
2967 vec<tm_region_p> bb_regions
2968 = get_bb_regions_instrumented (/*traverse_clones=*/true,
2969 /*include_uninstrumented_p=*/false);
2970 struct tm_region *r;
2973 // Expand memory operations into calls into the runtime.
2974 // This collects log entries as well.
2975 FOR_EACH_VEC_ELT (bb_regions, i, r)
2979 if (r->transaction_stmt)
2981 unsigned sub = gimple_transaction_subcode (r->transaction_stmt);
2983 /* If we're sure to go irrevocable, there won't be
2984 anything to expand, since the run-time will go
2985 irrevocable right away. */
2986 if (sub & GTMA_DOES_GO_IRREVOCABLE
2987 && sub & GTMA_MAY_ENTER_IRREVOCABLE)
2990 expand_block_tm (r, BASIC_BLOCK (i));
2994 bb_regions.release ();
2996 // Propagate flags from inner transactions outwards.
2997 propagate_tm_flags_out (all_tm_regions);
2999 // Expand GIMPLE_TRANSACTIONs into calls into the runtime.
3000 expand_regions (all_tm_regions, expand_transaction, NULL,
3001 /*traverse_clones=*/false);
3006 if (pending_edge_inserts_p)
3007 gsi_commit_edge_inserts ();
3008 free_dominance_info (CDI_DOMINATORS);
3014 const pass_data pass_data_tm_mark =
3016 GIMPLE_PASS, /* type */
3017 "tmmark", /* name */
3018 OPTGROUP_NONE, /* optinfo_flags */
3019 false, /* has_gate */
3020 true, /* has_execute */
3021 TV_TRANS_MEM, /* tv_id */
3022 ( PROP_ssa | PROP_cfg ), /* properties_required */
3023 0, /* properties_provided */
3024 0, /* properties_destroyed */
3025 0, /* todo_flags_start */
3026 ( TODO_update_ssa | TODO_verify_ssa ), /* todo_flags_finish */
3029 class pass_tm_mark : public gimple_opt_pass
3032 pass_tm_mark (gcc::context *ctxt)
3033 : gimple_opt_pass (pass_data_tm_mark, ctxt)
3036 /* opt_pass methods: */
3037 unsigned int execute () { return execute_tm_mark (); }
3039 }; // class pass_tm_mark
3044 make_pass_tm_mark (gcc::context *ctxt)
3046 return new pass_tm_mark (ctxt);
3050 /* Create an abnormal edge from STMT at iter, splitting the block
3051 as necessary. Adjust *PNEXT as needed for the split block. */
3054 split_bb_make_tm_edge (gimple stmt, basic_block dest_bb,
3055 gimple_stmt_iterator iter, gimple_stmt_iterator *pnext)
3057 basic_block bb = gimple_bb (stmt);
3058 if (!gsi_one_before_end_p (iter))
3060 edge e = split_block (bb, stmt);
3061 *pnext = gsi_start_bb (e->dest);
3063 make_edge (bb, dest_bb, EDGE_ABNORMAL);
3065 // Record the need for the edge for the benefit of the rtl passes.
3066 if (cfun->gimple_df->tm_restart == NULL)
3067 cfun->gimple_df->tm_restart = htab_create_ggc (31, struct_ptr_hash,
3068 struct_ptr_eq, ggc_free);
3070 struct tm_restart_node dummy;
3072 dummy.label_or_list = gimple_block_label (dest_bb);
3074 void **slot = htab_find_slot (cfun->gimple_df->tm_restart, &dummy, INSERT);
3075 struct tm_restart_node *n = (struct tm_restart_node *) *slot;
3078 n = ggc_alloc_tm_restart_node ();
3083 tree old = n->label_or_list;
3084 if (TREE_CODE (old) == LABEL_DECL)
3085 old = tree_cons (NULL, old, NULL);
3086 n->label_or_list = tree_cons (NULL, dummy.label_or_list, old);
3090 /* Split block BB as necessary for every builtin function we added, and
3091 wire up the abnormal back edges implied by the transaction restart. */
3094 expand_block_edges (struct tm_region *const region, basic_block bb)
3096 gimple_stmt_iterator gsi, next_gsi;
3098 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi = next_gsi)
3100 gimple stmt = gsi_stmt (gsi);
3103 gsi_next (&next_gsi);
3105 // ??? Shouldn't we split for any non-pure, non-irrevocable function?
3106 if (gimple_code (stmt) != GIMPLE_CALL
3107 || (gimple_call_flags (stmt) & ECF_TM_BUILTIN) == 0)
3110 if (DECL_FUNCTION_CODE (gimple_call_fndecl (stmt)) == BUILT_IN_TM_ABORT)
3112 // If we have a ``_transaction_cancel [[outer]]'', there is only
3113 // one abnormal edge: to the transaction marked OUTER.
3114 // All compiler-generated instances of BUILT_IN_TM_ABORT have a
3115 // constant argument, which we can examine here. Users invoking
3116 // TM_ABORT directly get what they deserve.
3117 tree arg = gimple_call_arg (stmt, 0);
3118 if (TREE_CODE (arg) == INTEGER_CST
3119 && (TREE_INT_CST_LOW (arg) & AR_OUTERABORT) != 0
3120 && !decl_is_tm_clone (current_function_decl))
3122 // Find the GTMA_IS_OUTER transaction.
3123 for (struct tm_region *o = region; o; o = o->outer)
3124 if (o->original_transaction_was_outer)
3126 split_bb_make_tm_edge (stmt, o->restart_block,
3131 // Otherwise, the front-end should have semantically checked
3132 // outer aborts, but in either case the target region is not
3133 // within this function.
3137 // Non-outer, TM aborts have an abnormal edge to the inner-most
3138 // transaction, the one being aborted;
3139 split_bb_make_tm_edge (stmt, region->restart_block, gsi, &next_gsi);
3142 // All TM builtins have an abnormal edge to the outer-most transaction.
3143 // We never restart inner transactions. For tm clones, we know a-priori
3144 // that the outer-most transaction is outside the function.
3145 if (decl_is_tm_clone (current_function_decl))
3148 if (cfun->gimple_df->tm_restart == NULL)
3149 cfun->gimple_df->tm_restart
3150 = htab_create_ggc (31, struct_ptr_hash, struct_ptr_eq, ggc_free);
3152 // All TM builtins have an abnormal edge to the outer-most transaction.
3153 // We never restart inner transactions.
3154 for (struct tm_region *o = region; o; o = o->outer)
3157 split_bb_make_tm_edge (stmt, o->restart_block, gsi, &next_gsi);
3161 // Delete any tail-call annotation that may have been added.
3162 // The tail-call pass may have mis-identified the commit as being
3163 // a candidate because we had not yet added this restart edge.
3164 gimple_call_set_tail (stmt, false);
3168 /* Entry point to the final expansion of transactional nodes. */
3171 execute_tm_edges (void)
3173 vec<tm_region_p> bb_regions
3174 = get_bb_regions_instrumented (/*traverse_clones=*/false,
3175 /*include_uninstrumented_p=*/true);
3176 struct tm_region *r;
3179 FOR_EACH_VEC_ELT (bb_regions, i, r)
3181 expand_block_edges (r, BASIC_BLOCK (i));
3183 bb_regions.release ();
3185 /* We've got to release the dominance info now, to indicate that it
3186 must be rebuilt completely. Otherwise we'll crash trying to update
3187 the SSA web in the TODO section following this pass. */
3188 free_dominance_info (CDI_DOMINATORS);
3189 bitmap_obstack_release (&tm_obstack);
3190 all_tm_regions = NULL;
3197 const pass_data pass_data_tm_edges =
3199 GIMPLE_PASS, /* type */
3200 "tmedge", /* name */
3201 OPTGROUP_NONE, /* optinfo_flags */
3202 false, /* has_gate */
3203 true, /* has_execute */
3204 TV_TRANS_MEM, /* tv_id */
3205 ( PROP_ssa | PROP_cfg ), /* properties_required */
3206 0, /* properties_provided */
3207 0, /* properties_destroyed */
3208 0, /* todo_flags_start */
3209 ( TODO_update_ssa | TODO_verify_ssa ), /* todo_flags_finish */
3212 class pass_tm_edges : public gimple_opt_pass
3215 pass_tm_edges (gcc::context *ctxt)
3216 : gimple_opt_pass (pass_data_tm_edges, ctxt)
3219 /* opt_pass methods: */
3220 unsigned int execute () { return execute_tm_edges (); }
3222 }; // class pass_tm_edges
3227 make_pass_tm_edges (gcc::context *ctxt)
3229 return new pass_tm_edges (ctxt);
3232 /* Helper function for expand_regions. Expand REGION and recurse to
3233 the inner region. Call CALLBACK on each region. CALLBACK returns
3234 NULL to continue the traversal, otherwise a non-null value which
3235 this function will return as well. TRAVERSE_CLONES is true if we
3236 should traverse transactional clones. */
3239 expand_regions_1 (struct tm_region *region,
3240 void *(*callback)(struct tm_region *, void *),
3242 bool traverse_clones)
3244 void *retval = NULL;
3245 if (region->exit_blocks
3246 || (traverse_clones && decl_is_tm_clone (current_function_decl)))
3248 retval = callback (region, data);
3254 retval = expand_regions (region->inner, callback, data, traverse_clones);
3261 /* Traverse the regions enclosed and including REGION. Execute
3262 CALLBACK for each region, passing DATA. CALLBACK returns NULL to
3263 continue the traversal, otherwise a non-null value which this
3264 function will return as well. TRAVERSE_CLONES is true if we should
3265 traverse transactional clones. */
3268 expand_regions (struct tm_region *region,
3269 void *(*callback)(struct tm_region *, void *),
3271 bool traverse_clones)
3273 void *retval = NULL;
3276 retval = expand_regions_1 (region, callback, data, traverse_clones);
3279 region = region->next;
3285 /* A unique TM memory operation. */
3286 typedef struct tm_memop
3288 /* Unique ID that all memory operations to the same location have. */
3289 unsigned int value_id;
3290 /* Address of load/store. */
3294 /* TM memory operation hashtable helpers. */
3296 struct tm_memop_hasher : typed_free_remove <tm_memop>
3298 typedef tm_memop value_type;
3299 typedef tm_memop compare_type;
3300 static inline hashval_t hash (const value_type *);
3301 static inline bool equal (const value_type *, const compare_type *);
3304 /* Htab support. Return a hash value for a `tm_memop'. */
3306 tm_memop_hasher::hash (const value_type *mem)
3308 tree addr = mem->addr;
3309 /* We drill down to the SSA_NAME/DECL for the hash, but equality is
3310 actually done with operand_equal_p (see tm_memop_eq). */
3311 if (TREE_CODE (addr) == ADDR_EXPR)
3312 addr = TREE_OPERAND (addr, 0);
3313 return iterative_hash_expr (addr, 0);
3316 /* Htab support. Return true if two tm_memop's are the same. */
3318 tm_memop_hasher::equal (const value_type *mem1, const compare_type *mem2)
3320 return operand_equal_p (mem1->addr, mem2->addr, 0);
3323 /* Sets for solving data flow equations in the memory optimization pass. */
3324 struct tm_memopt_bitmaps
3326 /* Stores available to this BB upon entry. Basically, stores that
3327 dominate this BB. */
3328 bitmap store_avail_in;
3329 /* Stores available at the end of this BB. */
3330 bitmap store_avail_out;
3331 bitmap store_antic_in;
3332 bitmap store_antic_out;
3333 /* Reads available to this BB upon entry. Basically, reads that
3334 dominate this BB. */
3335 bitmap read_avail_in;
3336 /* Reads available at the end of this BB. */
3337 bitmap read_avail_out;
3338 /* Reads performed in this BB. */
3340 /* Writes performed in this BB. */
3343 /* Temporary storage for pass. */
3344 /* Is the current BB in the worklist? */
3345 bool avail_in_worklist_p;
3346 /* Have we visited this BB? */
3350 static bitmap_obstack tm_memopt_obstack;
3352 /* Unique counter for TM loads and stores. Loads and stores of the
3353 same address get the same ID. */
3354 static unsigned int tm_memopt_value_id;
3355 static hash_table <tm_memop_hasher> tm_memopt_value_numbers;
3357 #define STORE_AVAIL_IN(BB) \
3358 ((struct tm_memopt_bitmaps *) ((BB)->aux))->store_avail_in
3359 #define STORE_AVAIL_OUT(BB) \
3360 ((struct tm_memopt_bitmaps *) ((BB)->aux))->store_avail_out
3361 #define STORE_ANTIC_IN(BB) \
3362 ((struct tm_memopt_bitmaps *) ((BB)->aux))->store_antic_in
3363 #define STORE_ANTIC_OUT(BB) \
3364 ((struct tm_memopt_bitmaps *) ((BB)->aux))->store_antic_out
3365 #define READ_AVAIL_IN(BB) \
3366 ((struct tm_memopt_bitmaps *) ((BB)->aux))->read_avail_in
3367 #define READ_AVAIL_OUT(BB) \
3368 ((struct tm_memopt_bitmaps *) ((BB)->aux))->read_avail_out
3369 #define READ_LOCAL(BB) \
3370 ((struct tm_memopt_bitmaps *) ((BB)->aux))->read_local
3371 #define STORE_LOCAL(BB) \
3372 ((struct tm_memopt_bitmaps *) ((BB)->aux))->store_local
3373 #define AVAIL_IN_WORKLIST_P(BB) \
3374 ((struct tm_memopt_bitmaps *) ((BB)->aux))->avail_in_worklist_p
3375 #define BB_VISITED_P(BB) \
3376 ((struct tm_memopt_bitmaps *) ((BB)->aux))->visited_p
3378 /* Given a TM load/store in STMT, return the value number for the address
3382 tm_memopt_value_number (gimple stmt, enum insert_option op)
3384 struct tm_memop tmpmem, *mem;
3387 gcc_assert (is_tm_load (stmt) || is_tm_store (stmt));
3388 tmpmem.addr = gimple_call_arg (stmt, 0);
3389 slot = tm_memopt_value_numbers.find_slot (&tmpmem, op);
3392 else if (op == INSERT)
3394 mem = XNEW (struct tm_memop);
3396 mem->value_id = tm_memopt_value_id++;
3397 mem->addr = tmpmem.addr;
3401 return mem->value_id;
3404 /* Accumulate TM memory operations in BB into STORE_LOCAL and READ_LOCAL. */
3407 tm_memopt_accumulate_memops (basic_block bb)
3409 gimple_stmt_iterator gsi;
3411 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
3413 gimple stmt = gsi_stmt (gsi);
3417 if (is_tm_store (stmt))
3418 bits = STORE_LOCAL (bb);
3419 else if (is_tm_load (stmt))
3420 bits = READ_LOCAL (bb);
3424 loc = tm_memopt_value_number (stmt, INSERT);
3425 bitmap_set_bit (bits, loc);
3428 fprintf (dump_file, "TM memopt (%s): value num=%d, BB=%d, addr=",
3429 is_tm_load (stmt) ? "LOAD" : "STORE", loc,
3430 gimple_bb (stmt)->index);
3431 print_generic_expr (dump_file, gimple_call_arg (stmt, 0), 0);
3432 fprintf (dump_file, "\n");
3437 /* Prettily dump one of the memopt sets. BITS is the bitmap to dump. */
3440 dump_tm_memopt_set (const char *set_name, bitmap bits)
3444 const char *comma = "";
3446 fprintf (dump_file, "TM memopt: %s: [", set_name);
3447 EXECUTE_IF_SET_IN_BITMAP (bits, 0, i, bi)
3449 hash_table <tm_memop_hasher>::iterator hi;
3450 struct tm_memop *mem = NULL;
3452 /* Yeah, yeah, yeah. Whatever. This is just for debugging. */
3453 FOR_EACH_HASH_TABLE_ELEMENT (tm_memopt_value_numbers, mem, tm_memop_t, hi)
3454 if (mem->value_id == i)
3456 gcc_assert (mem->value_id == i);
3457 fprintf (dump_file, "%s", comma);
3459 print_generic_expr (dump_file, mem->addr, 0);
3461 fprintf (dump_file, "]\n");
3464 /* Prettily dump all of the memopt sets in BLOCKS. */
3467 dump_tm_memopt_sets (vec<basic_block> blocks)
3472 for (i = 0; blocks.iterate (i, &bb); ++i)
3474 fprintf (dump_file, "------------BB %d---------\n", bb->index);
3475 dump_tm_memopt_set ("STORE_LOCAL", STORE_LOCAL (bb));
3476 dump_tm_memopt_set ("READ_LOCAL", READ_LOCAL (bb));
3477 dump_tm_memopt_set ("STORE_AVAIL_IN", STORE_AVAIL_IN (bb));
3478 dump_tm_memopt_set ("STORE_AVAIL_OUT", STORE_AVAIL_OUT (bb));
3479 dump_tm_memopt_set ("READ_AVAIL_IN", READ_AVAIL_IN (bb));
3480 dump_tm_memopt_set ("READ_AVAIL_OUT", READ_AVAIL_OUT (bb));
3484 /* Compute {STORE,READ}_AVAIL_IN for the basic block BB. */
3487 tm_memopt_compute_avin (basic_block bb)
3492 /* Seed with the AVOUT of any predecessor. */
3493 for (ix = 0; ix < EDGE_COUNT (bb->preds); ix++)
3495 e = EDGE_PRED (bb, ix);
3496 /* Make sure we have already visited this BB, and is thus
3499 If e->src->aux is NULL, this predecessor is actually on an
3500 enclosing transaction. We only care about the current
3501 transaction, so ignore it. */
3502 if (e->src->aux && BB_VISITED_P (e->src))
3504 bitmap_copy (STORE_AVAIL_IN (bb), STORE_AVAIL_OUT (e->src));
3505 bitmap_copy (READ_AVAIL_IN (bb), READ_AVAIL_OUT (e->src));
3510 for (; ix < EDGE_COUNT (bb->preds); ix++)
3512 e = EDGE_PRED (bb, ix);
3513 if (e->src->aux && BB_VISITED_P (e->src))
3515 bitmap_and_into (STORE_AVAIL_IN (bb), STORE_AVAIL_OUT (e->src));
3516 bitmap_and_into (READ_AVAIL_IN (bb), READ_AVAIL_OUT (e->src));
3520 BB_VISITED_P (bb) = true;
3523 /* Compute the STORE_ANTIC_IN for the basic block BB. */
3526 tm_memopt_compute_antin (basic_block bb)
3531 /* Seed with the ANTIC_OUT of any successor. */
3532 for (ix = 0; ix < EDGE_COUNT (bb->succs); ix++)
3534 e = EDGE_SUCC (bb, ix);
3535 /* Make sure we have already visited this BB, and is thus
3537 if (BB_VISITED_P (e->dest))
3539 bitmap_copy (STORE_ANTIC_IN (bb), STORE_ANTIC_OUT (e->dest));
3544 for (; ix < EDGE_COUNT (bb->succs); ix++)
3546 e = EDGE_SUCC (bb, ix);
3547 if (BB_VISITED_P (e->dest))
3548 bitmap_and_into (STORE_ANTIC_IN (bb), STORE_ANTIC_OUT (e->dest));
3551 BB_VISITED_P (bb) = true;
3554 /* Compute the AVAIL sets for every basic block in BLOCKS.
3556 We compute {STORE,READ}_AVAIL_{OUT,IN} as follows:
3558 AVAIL_OUT[bb] = union (AVAIL_IN[bb], LOCAL[bb])
3559 AVAIL_IN[bb] = intersect (AVAIL_OUT[predecessors])
3561 This is basically what we do in lcm's compute_available(), but here
3562 we calculate two sets of sets (one for STOREs and one for READs),
3563 and we work on a region instead of the entire CFG.
3565 REGION is the TM region.
3566 BLOCKS are the basic blocks in the region. */
3569 tm_memopt_compute_available (struct tm_region *region,
3570 vec<basic_block> blocks)
3573 basic_block *worklist, *qin, *qout, *qend, bb;
3574 unsigned int qlen, i;
3578 /* Allocate a worklist array/queue. Entries are only added to the
3579 list if they were not already on the list. So the size is
3580 bounded by the number of basic blocks in the region. */
3581 qlen = blocks.length () - 1;
3582 qin = qout = worklist =
3583 XNEWVEC (basic_block, qlen);
3585 /* Put every block in the region on the worklist. */
3586 for (i = 0; blocks.iterate (i, &bb); ++i)
3588 /* Seed AVAIL_OUT with the LOCAL set. */
3589 bitmap_ior_into (STORE_AVAIL_OUT (bb), STORE_LOCAL (bb));
3590 bitmap_ior_into (READ_AVAIL_OUT (bb), READ_LOCAL (bb));
3592 AVAIL_IN_WORKLIST_P (bb) = true;
3593 /* No need to insert the entry block, since it has an AVIN of
3594 null, and an AVOUT that has already been seeded in. */
3595 if (bb != region->entry_block)
3599 /* The entry block has been initialized with the local sets. */
3600 BB_VISITED_P (region->entry_block) = true;
3603 qend = &worklist[qlen];
3605 /* Iterate until the worklist is empty. */
3608 /* Take the first entry off the worklist. */
3615 /* This block can be added to the worklist again if necessary. */
3616 AVAIL_IN_WORKLIST_P (bb) = false;
3617 tm_memopt_compute_avin (bb);
3619 /* Note: We do not add the LOCAL sets here because we already
3620 seeded the AVAIL_OUT sets with them. */
3621 changed = bitmap_ior_into (STORE_AVAIL_OUT (bb), STORE_AVAIL_IN (bb));
3622 changed |= bitmap_ior_into (READ_AVAIL_OUT (bb), READ_AVAIL_IN (bb));
3624 && (region->exit_blocks == NULL
3625 || !bitmap_bit_p (region->exit_blocks, bb->index)))
3626 /* If the out state of this block changed, then we need to add
3627 its successors to the worklist if they are not already in. */
3628 FOR_EACH_EDGE (e, ei, bb->succs)
3629 if (!AVAIL_IN_WORKLIST_P (e->dest) && e->dest != EXIT_BLOCK_PTR)
3632 AVAIL_IN_WORKLIST_P (e->dest) = true;
3643 dump_tm_memopt_sets (blocks);
3646 /* Compute ANTIC sets for every basic block in BLOCKS.
3648 We compute STORE_ANTIC_OUT as follows:
3650 STORE_ANTIC_OUT[bb] = union(STORE_ANTIC_IN[bb], STORE_LOCAL[bb])
3651 STORE_ANTIC_IN[bb] = intersect(STORE_ANTIC_OUT[successors])
3653 REGION is the TM region.
3654 BLOCKS are the basic blocks in the region. */
3657 tm_memopt_compute_antic (struct tm_region *region,
3658 vec<basic_block> blocks)
3661 basic_block *worklist, *qin, *qout, *qend, bb;
3666 /* Allocate a worklist array/queue. Entries are only added to the
3667 list if they were not already on the list. So the size is
3668 bounded by the number of basic blocks in the region. */
3669 qin = qout = worklist = XNEWVEC (basic_block, blocks.length ());
3671 for (qlen = 0, i = blocks.length () - 1; i >= 0; --i)
3675 /* Seed ANTIC_OUT with the LOCAL set. */
3676 bitmap_ior_into (STORE_ANTIC_OUT (bb), STORE_LOCAL (bb));
3678 /* Put every block in the region on the worklist. */
3679 AVAIL_IN_WORKLIST_P (bb) = true;
3680 /* No need to insert exit blocks, since their ANTIC_IN is NULL,
3681 and their ANTIC_OUT has already been seeded in. */
3682 if (region->exit_blocks
3683 && !bitmap_bit_p (region->exit_blocks, bb->index))
3690 /* The exit blocks have been initialized with the local sets. */
3691 if (region->exit_blocks)
3695 EXECUTE_IF_SET_IN_BITMAP (region->exit_blocks, 0, i, bi)
3696 BB_VISITED_P (BASIC_BLOCK (i)) = true;
3700 qend = &worklist[qlen];
3702 /* Iterate until the worklist is empty. */
3705 /* Take the first entry off the worklist. */
3712 /* This block can be added to the worklist again if necessary. */
3713 AVAIL_IN_WORKLIST_P (bb) = false;
3714 tm_memopt_compute_antin (bb);
3716 /* Note: We do not add the LOCAL sets here because we already
3717 seeded the ANTIC_OUT sets with them. */
3718 if (bitmap_ior_into (STORE_ANTIC_OUT (bb), STORE_ANTIC_IN (bb))
3719 && bb != region->entry_block)
3720 /* If the out state of this block changed, then we need to add
3721 its predecessors to the worklist if they are not already in. */
3722 FOR_EACH_EDGE (e, ei, bb->preds)
3723 if (!AVAIL_IN_WORKLIST_P (e->src))
3726 AVAIL_IN_WORKLIST_P (e->src) = true;
3737 dump_tm_memopt_sets (blocks);
3740 /* Offsets of load variants from TM_LOAD. For example,
3741 BUILT_IN_TM_LOAD_RAR* is an offset of 1 from BUILT_IN_TM_LOAD*.
3742 See gtm-builtins.def. */
3743 #define TRANSFORM_RAR 1
3744 #define TRANSFORM_RAW 2
3745 #define TRANSFORM_RFW 3
3746 /* Offsets of store variants from TM_STORE. */
3747 #define TRANSFORM_WAR 1
3748 #define TRANSFORM_WAW 2
3750 /* Inform about a load/store optimization. */
3753 dump_tm_memopt_transform (gimple stmt)
3757 fprintf (dump_file, "TM memopt: transforming: ");
3758 print_gimple_stmt (dump_file, stmt, 0, 0);
3759 fprintf (dump_file, "\n");
3763 /* Perform a read/write optimization. Replaces the TM builtin in STMT
3764 by a builtin that is OFFSET entries down in the builtins table in
3765 gtm-builtins.def. */
3768 tm_memopt_transform_stmt (unsigned int offset,
3770 gimple_stmt_iterator *gsi)
3772 tree fn = gimple_call_fn (stmt);
3773 gcc_assert (TREE_CODE (fn) == ADDR_EXPR);
3774 TREE_OPERAND (fn, 0)
3775 = builtin_decl_explicit ((enum built_in_function)
3776 (DECL_FUNCTION_CODE (TREE_OPERAND (fn, 0))
3778 gimple_call_set_fn (stmt, fn);
3779 gsi_replace (gsi, stmt, true);
3780 dump_tm_memopt_transform (stmt);
3783 /* Perform the actual TM memory optimization transformations in the
3784 basic blocks in BLOCKS. */
3787 tm_memopt_transform_blocks (vec<basic_block> blocks)
3791 gimple_stmt_iterator gsi;
3793 for (i = 0; blocks.iterate (i, &bb); ++i)
3795 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
3797 gimple stmt = gsi_stmt (gsi);
3798 bitmap read_avail = READ_AVAIL_IN (bb);
3799 bitmap store_avail = STORE_AVAIL_IN (bb);
3800 bitmap store_antic = STORE_ANTIC_OUT (bb);
3803 if (is_tm_simple_load (stmt))
3805 loc = tm_memopt_value_number (stmt, NO_INSERT);
3806 if (store_avail && bitmap_bit_p (store_avail, loc))
3807 tm_memopt_transform_stmt (TRANSFORM_RAW, stmt, &gsi);
3808 else if (store_antic && bitmap_bit_p (store_antic, loc))
3810 tm_memopt_transform_stmt (TRANSFORM_RFW, stmt, &gsi);
3811 bitmap_set_bit (store_avail, loc);
3813 else if (read_avail && bitmap_bit_p (read_avail, loc))
3814 tm_memopt_transform_stmt (TRANSFORM_RAR, stmt, &gsi);
3816 bitmap_set_bit (read_avail, loc);
3818 else if (is_tm_simple_store (stmt))
3820 loc = tm_memopt_value_number (stmt, NO_INSERT);
3821 if (store_avail && bitmap_bit_p (store_avail, loc))
3822 tm_memopt_transform_stmt (TRANSFORM_WAW, stmt, &gsi);
3825 if (read_avail && bitmap_bit_p (read_avail, loc))
3826 tm_memopt_transform_stmt (TRANSFORM_WAR, stmt, &gsi);
3827 bitmap_set_bit (store_avail, loc);
3834 /* Return a new set of bitmaps for a BB. */
3836 static struct tm_memopt_bitmaps *
3837 tm_memopt_init_sets (void)
3839 struct tm_memopt_bitmaps *b
3840 = XOBNEW (&tm_memopt_obstack.obstack, struct tm_memopt_bitmaps);
3841 b->store_avail_in = BITMAP_ALLOC (&tm_memopt_obstack);
3842 b->store_avail_out = BITMAP_ALLOC (&tm_memopt_obstack);
3843 b->store_antic_in = BITMAP_ALLOC (&tm_memopt_obstack);
3844 b->store_antic_out = BITMAP_ALLOC (&tm_memopt_obstack);
3845 b->store_avail_out = BITMAP_ALLOC (&tm_memopt_obstack);
3846 b->read_avail_in = BITMAP_ALLOC (&tm_memopt_obstack);
3847 b->read_avail_out = BITMAP_ALLOC (&tm_memopt_obstack);
3848 b->read_local = BITMAP_ALLOC (&tm_memopt_obstack);
3849 b->store_local = BITMAP_ALLOC (&tm_memopt_obstack);
3853 /* Free sets computed for each BB. */
3856 tm_memopt_free_sets (vec<basic_block> blocks)
3861 for (i = 0; blocks.iterate (i, &bb); ++i)
3865 /* Clear the visited bit for every basic block in BLOCKS. */
3868 tm_memopt_clear_visited (vec<basic_block> blocks)
3873 for (i = 0; blocks.iterate (i, &bb); ++i)
3874 BB_VISITED_P (bb) = false;
3877 /* Replace TM load/stores with hints for the runtime. We handle
3878 things like read-after-write, write-after-read, read-after-read,
3879 read-for-write, etc. */
3882 execute_tm_memopt (void)
3884 struct tm_region *region;
3885 vec<basic_block> bbs;
3887 tm_memopt_value_id = 0;
3888 tm_memopt_value_numbers.create (10);
3890 for (region = all_tm_regions; region; region = region->next)
3892 /* All the TM stores/loads in the current region. */
3896 bitmap_obstack_initialize (&tm_memopt_obstack);
3898 /* Save all BBs for the current region. */
3899 bbs = get_tm_region_blocks (region->entry_block,
3900 region->exit_blocks,
3905 /* Collect all the memory operations. */
3906 for (i = 0; bbs.iterate (i, &bb); ++i)
3908 bb->aux = tm_memopt_init_sets ();
3909 tm_memopt_accumulate_memops (bb);
3912 /* Solve data flow equations and transform each block accordingly. */
3913 tm_memopt_clear_visited (bbs);
3914 tm_memopt_compute_available (region, bbs);
3915 tm_memopt_clear_visited (bbs);
3916 tm_memopt_compute_antic (region, bbs);
3917 tm_memopt_transform_blocks (bbs);
3919 tm_memopt_free_sets (bbs);
3921 bitmap_obstack_release (&tm_memopt_obstack);
3922 tm_memopt_value_numbers.empty ();
3925 tm_memopt_value_numbers.dispose ();
3930 gate_tm_memopt (void)
3932 return flag_tm && optimize > 0;
3937 const pass_data pass_data_tm_memopt =
3939 GIMPLE_PASS, /* type */
3940 "tmmemopt", /* name */
3941 OPTGROUP_NONE, /* optinfo_flags */
3942 true, /* has_gate */
3943 true, /* has_execute */
3944 TV_TRANS_MEM, /* tv_id */
3945 ( PROP_ssa | PROP_cfg ), /* properties_required */
3946 0, /* properties_provided */
3947 0, /* properties_destroyed */
3948 0, /* todo_flags_start */
3949 0, /* todo_flags_finish */
3952 class pass_tm_memopt : public gimple_opt_pass
3955 pass_tm_memopt (gcc::context *ctxt)
3956 : gimple_opt_pass (pass_data_tm_memopt, ctxt)
3959 /* opt_pass methods: */
3960 bool gate () { return gate_tm_memopt (); }
3961 unsigned int execute () { return execute_tm_memopt (); }
3963 }; // class pass_tm_memopt
3968 make_pass_tm_memopt (gcc::context *ctxt)
3970 return new pass_tm_memopt (ctxt);
3974 /* Interprocedual analysis for the creation of transactional clones.
3975 The aim of this pass is to find which functions are referenced in
3976 a non-irrevocable transaction context, and for those over which
3977 we have control (or user directive), create a version of the
3978 function which uses only the transactional interface to reference
3979 protected memories. This analysis proceeds in several steps:
3981 (1) Collect the set of all possible transactional clones:
3983 (a) For all local public functions marked tm_callable, push
3984 it onto the tm_callee queue.
3986 (b) For all local functions, scan for calls in transaction blocks.
3987 Push the caller and callee onto the tm_caller and tm_callee
3988 queues. Count the number of callers for each callee.
3990 (c) For each local function on the callee list, assume we will
3991 create a transactional clone. Push *all* calls onto the
3992 callee queues; count the number of clone callers separately
3993 to the number of original callers.
3995 (2) Propagate irrevocable status up the dominator tree:
3997 (a) Any external function on the callee list that is not marked
3998 tm_callable is irrevocable. Push all callers of such onto
4001 (b) For each function on the worklist, mark each block that
4002 contains an irrevocable call. Use the AND operator to
4003 propagate that mark up the dominator tree.
4005 (c) If we reach the entry block for a possible transactional
4006 clone, then the transactional clone is irrevocable, and
4007 we should not create the clone after all. Push all
4008 callers onto the worklist.
4010 (d) Place tm_irrevocable calls at the beginning of the relevant
4011 blocks. Special case here is the entry block for the entire
4012 transaction region; there we mark it GTMA_DOES_GO_IRREVOCABLE for
4013 the library to begin the region in serial mode. Decrement
4014 the call count for all callees in the irrevocable region.
4016 (3) Create the transactional clones:
4018 Any tm_callee that still has a non-zero call count is cloned.
4021 /* This structure is stored in the AUX field of each cgraph_node. */
4022 struct tm_ipa_cg_data
4024 /* The clone of the function that got created. */
4025 struct cgraph_node *clone;
4027 /* The tm regions in the normal function. */
4028 struct tm_region *all_tm_regions;
4030 /* The blocks of the normal/clone functions that contain irrevocable
4031 calls, or blocks that are post-dominated by irrevocable calls. */
4032 bitmap irrevocable_blocks_normal;
4033 bitmap irrevocable_blocks_clone;
4035 /* The blocks of the normal function that are involved in transactions. */
4036 bitmap transaction_blocks_normal;
4038 /* The number of callers to the transactional clone of this function
4039 from normal and transactional clones respectively. */
4040 unsigned tm_callers_normal;
4041 unsigned tm_callers_clone;
4043 /* True if all calls to this function's transactional clone
4044 are irrevocable. Also automatically true if the function
4045 has no transactional clone. */
4046 bool is_irrevocable;
4048 /* Flags indicating the presence of this function in various queues. */
4049 bool in_callee_queue;
4052 /* Flags indicating the kind of scan desired while in the worklist. */
4053 bool want_irr_scan_normal;
4056 typedef vec<cgraph_node_ptr> cgraph_node_queue;
4058 /* Return the ipa data associated with NODE, allocating zeroed memory
4059 if necessary. TRAVERSE_ALIASES is true if we must traverse aliases
4060 and set *NODE accordingly. */
4062 static struct tm_ipa_cg_data *
4063 get_cg_data (struct cgraph_node **node, bool traverse_aliases)
4065 struct tm_ipa_cg_data *d;
4067 if (traverse_aliases && (*node)->alias)
4068 *node = cgraph_alias_target (*node);
4070 d = (struct tm_ipa_cg_data *) (*node)->aux;
4074 d = (struct tm_ipa_cg_data *)
4075 obstack_alloc (&tm_obstack.obstack, sizeof (*d));
4076 (*node)->aux = (void *) d;
4077 memset (d, 0, sizeof (*d));
4083 /* Add NODE to the end of QUEUE, unless IN_QUEUE_P indicates that
4084 it is already present. */
4087 maybe_push_queue (struct cgraph_node *node,
4088 cgraph_node_queue *queue_p, bool *in_queue_p)
4093 queue_p->safe_push (node);
4097 /* Duplicate the basic blocks in QUEUE for use in the uninstrumented
4098 code path. QUEUE are the basic blocks inside the transaction
4099 represented in REGION.
4101 Later in split_code_paths() we will add the conditional to choose
4102 between the two alternatives. */
4105 ipa_uninstrument_transaction (struct tm_region *region,
4106 vec<basic_block> queue)
4108 gimple transaction = region->transaction_stmt;
4109 basic_block transaction_bb = gimple_bb (transaction);
4110 int n = queue.length ();
4111 basic_block *new_bbs = XNEWVEC (basic_block, n);
4113 copy_bbs (queue.address (), n, new_bbs, NULL, 0, NULL, NULL, transaction_bb,
4115 edge e = make_edge (transaction_bb, new_bbs[0], EDGE_TM_UNINSTRUMENTED);
4116 add_phi_args_after_copy (new_bbs, n, e);
4118 // Now we will have a GIMPLE_ATOMIC with 3 possible edges out of it.
4119 // a) EDGE_FALLTHRU into the transaction
4120 // b) EDGE_TM_ABORT out of the transaction
4121 // c) EDGE_TM_UNINSTRUMENTED into the uninstrumented blocks.
4126 /* A subroutine of ipa_tm_scan_calls_transaction and ipa_tm_scan_calls_clone.
4127 Queue all callees within block BB. */
4130 ipa_tm_scan_calls_block (cgraph_node_queue *callees_p,
4131 basic_block bb, bool for_clone)
4133 gimple_stmt_iterator gsi;
4135 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
4137 gimple stmt = gsi_stmt (gsi);
4138 if (is_gimple_call (stmt) && !is_tm_pure_call (stmt))
4140 tree fndecl = gimple_call_fndecl (stmt);
4143 struct tm_ipa_cg_data *d;
4145 struct cgraph_node *node;
4147 if (is_tm_ending_fndecl (fndecl))
4149 if (find_tm_replacement_function (fndecl))
4152 node = cgraph_get_node (fndecl);
4153 gcc_assert (node != NULL);
4154 d = get_cg_data (&node, true);
4156 pcallers = (for_clone ? &d->tm_callers_clone
4157 : &d->tm_callers_normal);
4160 maybe_push_queue (node, callees_p, &d->in_callee_queue);
4166 /* Scan all calls in NODE that are within a transaction region,
4167 and push the resulting nodes into the callee queue. */
4170 ipa_tm_scan_calls_transaction (struct tm_ipa_cg_data *d,
4171 cgraph_node_queue *callees_p)
4173 struct tm_region *r;
4175 d->transaction_blocks_normal = BITMAP_ALLOC (&tm_obstack);
4176 d->all_tm_regions = all_tm_regions;
4178 for (r = all_tm_regions; r; r = r->next)
4180 vec<basic_block> bbs;
4184 bbs = get_tm_region_blocks (r->entry_block, r->exit_blocks, NULL,
4185 d->transaction_blocks_normal, false);
4187 // Generate the uninstrumented code path for this transaction.
4188 ipa_uninstrument_transaction (r, bbs);
4190 FOR_EACH_VEC_ELT (bbs, i, bb)
4191 ipa_tm_scan_calls_block (callees_p, bb, false);
4196 // ??? copy_bbs should maintain cgraph edges for the blocks as it is
4197 // copying them, rather than forcing us to do this externally.
4198 rebuild_cgraph_edges ();
4200 // ??? In ipa_uninstrument_transaction we don't try to update dominators
4201 // because copy_bbs doesn't return a VEC like iterate_fix_dominators expects.
4202 // Instead, just release dominators here so update_ssa recomputes them.
4203 free_dominance_info (CDI_DOMINATORS);
4205 // When building the uninstrumented code path, copy_bbs will have invoked
4206 // create_new_def_for starting an "ssa update context". There is only one
4207 // instance of this context, so resolve ssa updates before moving on to
4208 // the next function.
4209 update_ssa (TODO_update_ssa);
4212 /* Scan all calls in NODE as if this is the transactional clone,
4213 and push the destinations into the callee queue. */
4216 ipa_tm_scan_calls_clone (struct cgraph_node *node,
4217 cgraph_node_queue *callees_p)
4219 struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
4222 FOR_EACH_BB_FN (bb, fn)
4223 ipa_tm_scan_calls_block (callees_p, bb, true);
4226 /* The function NODE has been detected to be irrevocable. Push all
4227 of its callers onto WORKLIST for the purpose of re-scanning them. */
4230 ipa_tm_note_irrevocable (struct cgraph_node *node,
4231 cgraph_node_queue *worklist_p)
4233 struct tm_ipa_cg_data *d = get_cg_data (&node, true);
4234 struct cgraph_edge *e;
4236 d->is_irrevocable = true;
4238 for (e = node->callers; e ; e = e->next_caller)
4241 struct cgraph_node *caller;
4243 /* Don't examine recursive calls. */
4244 if (e->caller == node)
4246 /* Even if we think we can go irrevocable, believe the user
4248 if (is_tm_safe_or_pure (e->caller->decl))
4252 d = get_cg_data (&caller, true);
4254 /* Check if the callee is in a transactional region. If so,
4255 schedule the function for normal re-scan as well. */
4256 bb = gimple_bb (e->call_stmt);
4257 gcc_assert (bb != NULL);
4258 if (d->transaction_blocks_normal
4259 && bitmap_bit_p (d->transaction_blocks_normal, bb->index))
4260 d->want_irr_scan_normal = true;
4262 maybe_push_queue (caller, worklist_p, &d->in_worklist);
4266 /* A subroutine of ipa_tm_scan_irr_blocks; return true iff any statement
4267 within the block is irrevocable. */
4270 ipa_tm_scan_irr_block (basic_block bb)
4272 gimple_stmt_iterator gsi;
4275 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
4277 gimple stmt = gsi_stmt (gsi);
4278 switch (gimple_code (stmt))
4281 if (gimple_assign_single_p (stmt))
4283 tree lhs = gimple_assign_lhs (stmt);
4284 tree rhs = gimple_assign_rhs1 (stmt);
4285 if (volatile_var_p (lhs) || volatile_var_p (rhs))
4292 tree lhs = gimple_call_lhs (stmt);
4293 if (lhs && volatile_var_p (lhs))
4296 if (is_tm_pure_call (stmt))
4299 fn = gimple_call_fn (stmt);
4301 /* Functions with the attribute are by definition irrevocable. */
4302 if (is_tm_irrevocable (fn))
4305 /* For direct function calls, go ahead and check for replacement
4306 functions, or transitive irrevocable functions. For indirect
4307 functions, we'll ask the runtime. */
4308 if (TREE_CODE (fn) == ADDR_EXPR)
4310 struct tm_ipa_cg_data *d;
4311 struct cgraph_node *node;
4313 fn = TREE_OPERAND (fn, 0);
4314 if (is_tm_ending_fndecl (fn))
4316 if (find_tm_replacement_function (fn))
4319 node = cgraph_get_node (fn);
4320 d = get_cg_data (&node, true);
4322 /* Return true if irrevocable, but above all, believe
4324 if (d->is_irrevocable
4325 && !is_tm_safe_or_pure (fn))
4332 /* ??? The Approved Method of indicating that an inline
4333 assembly statement is not relevant to the transaction
4334 is to wrap it in a __tm_waiver block. This is not
4335 yet implemented, so we can't check for it. */
4336 if (is_tm_safe (current_function_decl))
4338 tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
4339 SET_EXPR_LOCATION (t, gimple_location (stmt));
4340 error ("%Kasm not allowed in %<transaction_safe%> function", t);
4352 /* For each of the blocks seeded witin PQUEUE, walk the CFG looking
4353 for new irrevocable blocks, marking them in NEW_IRR. Don't bother
4354 scanning past OLD_IRR or EXIT_BLOCKS. */
4357 ipa_tm_scan_irr_blocks (vec<basic_block> *pqueue, bitmap new_irr,
4358 bitmap old_irr, bitmap exit_blocks)
4360 bool any_new_irr = false;
4363 bitmap visited_blocks = BITMAP_ALLOC (NULL);
4367 basic_block bb = pqueue->pop ();
4369 /* Don't re-scan blocks we know already are irrevocable. */
4370 if (old_irr && bitmap_bit_p (old_irr, bb->index))
4373 if (ipa_tm_scan_irr_block (bb))
4375 bitmap_set_bit (new_irr, bb->index);
4378 else if (exit_blocks == NULL || !bitmap_bit_p (exit_blocks, bb->index))
4380 FOR_EACH_EDGE (e, ei, bb->succs)
4381 if (!bitmap_bit_p (visited_blocks, e->dest->index))
4383 bitmap_set_bit (visited_blocks, e->dest->index);
4384 pqueue->safe_push (e->dest);
4388 while (!pqueue->is_empty ());
4390 BITMAP_FREE (visited_blocks);
4395 /* Propagate the irrevocable property both up and down the dominator tree.
4396 BB is the current block being scanned; EXIT_BLOCKS are the edges of the
4397 TM regions; OLD_IRR are the results of a previous scan of the dominator
4398 tree which has been fully propagated; NEW_IRR is the set of new blocks
4399 which are gaining the irrevocable property during the current scan. */
4402 ipa_tm_propagate_irr (basic_block entry_block, bitmap new_irr,
4403 bitmap old_irr, bitmap exit_blocks)
4405 vec<basic_block> bbs;
4406 bitmap all_region_blocks;
4408 /* If this block is in the old set, no need to rescan. */
4409 if (old_irr && bitmap_bit_p (old_irr, entry_block->index))
4412 all_region_blocks = BITMAP_ALLOC (&tm_obstack);
4413 bbs = get_tm_region_blocks (entry_block, exit_blocks, NULL,
4414 all_region_blocks, false);
4417 basic_block bb = bbs.pop ();
4418 bool this_irr = bitmap_bit_p (new_irr, bb->index);
4419 bool all_son_irr = false;
4423 /* Propagate up. If my children are, I am too, but we must have
4424 at least one child that is. */
4427 FOR_EACH_EDGE (e, ei, bb->succs)
4429 if (!bitmap_bit_p (new_irr, e->dest->index))
4431 all_son_irr = false;
4439 /* Add block to new_irr if it hasn't already been processed. */
4440 if (!old_irr || !bitmap_bit_p (old_irr, bb->index))
4442 bitmap_set_bit (new_irr, bb->index);
4448 /* Propagate down to everyone we immediately dominate. */
4452 for (son = first_dom_son (CDI_DOMINATORS, bb);
4454 son = next_dom_son (CDI_DOMINATORS, son))
4456 /* Make sure block is actually in a TM region, and it
4457 isn't already in old_irr. */
4458 if ((!old_irr || !bitmap_bit_p (old_irr, son->index))
4459 && bitmap_bit_p (all_region_blocks, son->index))
4460 bitmap_set_bit (new_irr, son->index);
4464 while (!bbs.is_empty ());
4466 BITMAP_FREE (all_region_blocks);
4471 ipa_tm_decrement_clone_counts (basic_block bb, bool for_clone)
4473 gimple_stmt_iterator gsi;
4475 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
4477 gimple stmt = gsi_stmt (gsi);
4478 if (is_gimple_call (stmt) && !is_tm_pure_call (stmt))
4480 tree fndecl = gimple_call_fndecl (stmt);
4483 struct tm_ipa_cg_data *d;
4485 struct cgraph_node *tnode;
4487 if (is_tm_ending_fndecl (fndecl))
4489 if (find_tm_replacement_function (fndecl))
4492 tnode = cgraph_get_node (fndecl);
4493 d = get_cg_data (&tnode, true);
4495 pcallers = (for_clone ? &d->tm_callers_clone
4496 : &d->tm_callers_normal);
4498 gcc_assert (*pcallers > 0);
4505 /* (Re-)Scan the transaction blocks in NODE for calls to irrevocable functions,
4506 as well as other irrevocable actions such as inline assembly. Mark all
4507 such blocks as irrevocable and decrement the number of calls to
4508 transactional clones. Return true if, for the transactional clone, the
4509 entire function is irrevocable. */
4512 ipa_tm_scan_irr_function (struct cgraph_node *node, bool for_clone)
4514 struct tm_ipa_cg_data *d;
4515 bitmap new_irr, old_irr;
4516 vec<basic_block> queue;
4519 /* Builtin operators (operator new, and such). */
4520 if (DECL_STRUCT_FUNCTION (node->decl) == NULL
4521 || DECL_STRUCT_FUNCTION (node->decl)->cfg == NULL)
4524 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
4525 calculate_dominance_info (CDI_DOMINATORS);
4527 d = get_cg_data (&node, true);
4529 new_irr = BITMAP_ALLOC (&tm_obstack);
4531 /* Scan each tm region, propagating irrevocable status through the tree. */
4534 old_irr = d->irrevocable_blocks_clone;
4535 queue.quick_push (single_succ (ENTRY_BLOCK_PTR));
4536 if (ipa_tm_scan_irr_blocks (&queue, new_irr, old_irr, NULL))
4538 ipa_tm_propagate_irr (single_succ (ENTRY_BLOCK_PTR), new_irr,
4540 ret = bitmap_bit_p (new_irr, single_succ (ENTRY_BLOCK_PTR)->index);
4545 struct tm_region *region;
4547 old_irr = d->irrevocable_blocks_normal;
4548 for (region = d->all_tm_regions; region; region = region->next)
4550 queue.quick_push (region->entry_block);
4551 if (ipa_tm_scan_irr_blocks (&queue, new_irr, old_irr,
4552 region->exit_blocks))
4553 ipa_tm_propagate_irr (region->entry_block, new_irr, old_irr,
4554 region->exit_blocks);
4558 /* If we found any new irrevocable blocks, reduce the call count for
4559 transactional clones within the irrevocable blocks. Save the new
4560 set of irrevocable blocks for next time. */
4561 if (!bitmap_empty_p (new_irr))
4563 bitmap_iterator bmi;
4566 EXECUTE_IF_SET_IN_BITMAP (new_irr, 0, i, bmi)
4567 ipa_tm_decrement_clone_counts (BASIC_BLOCK (i), for_clone);
4571 bitmap_ior_into (old_irr, new_irr);
4572 BITMAP_FREE (new_irr);
4575 d->irrevocable_blocks_clone = new_irr;
4577 d->irrevocable_blocks_normal = new_irr;
4579 if (dump_file && new_irr)
4582 bitmap_iterator bmi;
4585 dname = lang_hooks.decl_printable_name (current_function_decl, 2);
4586 EXECUTE_IF_SET_IN_BITMAP (new_irr, 0, i, bmi)
4587 fprintf (dump_file, "%s: bb %d goes irrevocable\n", dname, i);
4591 BITMAP_FREE (new_irr);
4599 /* Return true if, for the transactional clone of NODE, any call
4600 may enter irrevocable mode. */
4603 ipa_tm_mayenterirr_function (struct cgraph_node *node)
4605 struct tm_ipa_cg_data *d;
4609 d = get_cg_data (&node, true);
4611 flags = flags_from_decl_or_type (decl);
4613 /* Handle some TM builtins. Ordinarily these aren't actually generated
4614 at this point, but handling these functions when written in by the
4615 user makes it easier to build unit tests. */
4616 if (flags & ECF_TM_BUILTIN)
4619 /* Filter out all functions that are marked. */
4620 if (flags & ECF_TM_PURE)
4622 if (is_tm_safe (decl))
4624 if (is_tm_irrevocable (decl))
4626 if (is_tm_callable (decl))
4628 if (find_tm_replacement_function (decl))
4631 /* If we aren't seeing the final version of the function we don't
4632 know what it will contain at runtime. */
4633 if (cgraph_function_body_availability (node) < AVAIL_AVAILABLE)
4636 /* If the function must go irrevocable, then of course true. */
4637 if (d->is_irrevocable)
4640 /* If there are any blocks marked irrevocable, then the function
4641 as a whole may enter irrevocable. */
4642 if (d->irrevocable_blocks_clone)
4645 /* We may have previously marked this function as tm_may_enter_irr;
4646 see pass_diagnose_tm_blocks. */
4647 if (node->local.tm_may_enter_irr)
4650 /* Recurse on the main body for aliases. In general, this will
4651 result in one of the bits above being set so that we will not
4652 have to recurse next time. */
4654 return ipa_tm_mayenterirr_function (cgraph_get_node (node->thunk.alias));
4656 /* What remains is unmarked local functions without items that force
4657 the function to go irrevocable. */
4661 /* Diagnose calls from transaction_safe functions to unmarked
4662 functions that are determined to not be safe. */
4665 ipa_tm_diagnose_tm_safe (struct cgraph_node *node)
4667 struct cgraph_edge *e;
4669 for (e = node->callees; e ; e = e->next_callee)
4670 if (!is_tm_callable (e->callee->decl)
4671 && e->callee->local.tm_may_enter_irr)
4672 error_at (gimple_location (e->call_stmt),
4673 "unsafe function call %qD within "
4674 "%<transaction_safe%> function", e->callee->decl);
4677 /* Diagnose call from atomic transactions to unmarked functions
4678 that are determined to not be safe. */
4681 ipa_tm_diagnose_transaction (struct cgraph_node *node,
4682 struct tm_region *all_tm_regions)
4684 struct tm_region *r;
4686 for (r = all_tm_regions; r ; r = r->next)
4687 if (gimple_transaction_subcode (r->transaction_stmt) & GTMA_IS_RELAXED)
4689 /* Atomic transactions can be nested inside relaxed. */
4691 ipa_tm_diagnose_transaction (node, r->inner);
4695 vec<basic_block> bbs;
4696 gimple_stmt_iterator gsi;
4700 bbs = get_tm_region_blocks (r->entry_block, r->exit_blocks,
4701 r->irr_blocks, NULL, false);
4703 for (i = 0; bbs.iterate (i, &bb); ++i)
4704 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
4706 gimple stmt = gsi_stmt (gsi);
4709 if (gimple_code (stmt) == GIMPLE_ASM)
4711 error_at (gimple_location (stmt),
4712 "asm not allowed in atomic transaction");
4716 if (!is_gimple_call (stmt))
4718 fndecl = gimple_call_fndecl (stmt);
4720 /* Indirect function calls have been diagnosed already. */
4724 /* Stop at the end of the transaction. */
4725 if (is_tm_ending_fndecl (fndecl))
4727 if (bitmap_bit_p (r->exit_blocks, bb->index))
4732 /* Marked functions have been diagnosed already. */
4733 if (is_tm_pure_call (stmt))
4735 if (is_tm_callable (fndecl))
4738 if (cgraph_local_info (fndecl)->tm_may_enter_irr)
4739 error_at (gimple_location (stmt),
4740 "unsafe function call %qD within "
4741 "atomic transaction", fndecl);
4748 /* Return a transactional mangled name for the DECL_ASSEMBLER_NAME in
4749 OLD_DECL. The returned value is a freshly malloced pointer that
4750 should be freed by the caller. */
4753 tm_mangle (tree old_asm_id)
4755 const char *old_asm_name;
4758 struct demangle_component *dc;
4761 /* Determine if the symbol is already a valid C++ mangled name. Do this
4762 even for C, which might be interfacing with C++ code via appropriately
4763 ugly identifiers. */
4764 /* ??? We could probably do just as well checking for "_Z" and be done. */
4765 old_asm_name = IDENTIFIER_POINTER (old_asm_id);
4766 dc = cplus_demangle_v3_components (old_asm_name, DMGL_NO_OPTS, &alloc);
4773 sprintf (length, "%u", IDENTIFIER_LENGTH (old_asm_id));
4774 tm_name = concat ("_ZGTt", length, old_asm_name, NULL);
4778 old_asm_name += 2; /* Skip _Z */
4782 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
4783 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
4784 /* Don't play silly games, you! */
4787 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
4788 /* I'd really like to know if we can ever be passed one of
4789 these from the C++ front end. The Logical Thing would
4790 seem that hidden-alias should be outer-most, so that we
4791 get hidden-alias of a transaction-clone and not vice-versa. */
4799 tm_name = concat ("_ZGTt", old_asm_name, NULL);
4803 new_asm_id = get_identifier (tm_name);
4810 ipa_tm_mark_force_output_node (struct cgraph_node *node)
4812 cgraph_mark_force_output_node (node);
4813 node->analyzed = true;
4817 ipa_tm_mark_forced_by_abi_node (struct cgraph_node *node)
4819 node->forced_by_abi = true;
4820 node->analyzed = true;
4823 /* Callback data for ipa_tm_create_version_alias. */
4824 struct create_version_alias_info
4826 struct cgraph_node *old_node;
4830 /* A subroutine of ipa_tm_create_version, called via
4831 cgraph_for_node_and_aliases. Create new tm clones for each of
4832 the existing aliases. */
4834 ipa_tm_create_version_alias (struct cgraph_node *node, void *data)
4836 struct create_version_alias_info *info
4837 = (struct create_version_alias_info *)data;
4838 tree old_decl, new_decl, tm_name;
4839 struct cgraph_node *new_node;
4841 if (!node->cpp_implicit_alias)
4844 old_decl = node->decl;
4845 tm_name = tm_mangle (DECL_ASSEMBLER_NAME (old_decl));
4846 new_decl = build_decl (DECL_SOURCE_LOCATION (old_decl),
4847 TREE_CODE (old_decl), tm_name,
4848 TREE_TYPE (old_decl));
4850 SET_DECL_ASSEMBLER_NAME (new_decl, tm_name);
4851 SET_DECL_RTL (new_decl, NULL);
4853 /* Based loosely on C++'s make_alias_for(). */
4854 TREE_PUBLIC (new_decl) = TREE_PUBLIC (old_decl);
4855 DECL_CONTEXT (new_decl) = DECL_CONTEXT (old_decl);
4856 DECL_LANG_SPECIFIC (new_decl) = DECL_LANG_SPECIFIC (old_decl);
4857 TREE_READONLY (new_decl) = TREE_READONLY (old_decl);
4858 DECL_EXTERNAL (new_decl) = 0;
4859 DECL_ARTIFICIAL (new_decl) = 1;
4860 TREE_ADDRESSABLE (new_decl) = 1;
4861 TREE_USED (new_decl) = 1;
4862 TREE_SYMBOL_REFERENCED (tm_name) = 1;
4864 /* Perform the same remapping to the comdat group. */
4865 if (DECL_ONE_ONLY (new_decl))
4866 DECL_COMDAT_GROUP (new_decl) = tm_mangle (DECL_COMDAT_GROUP (old_decl));
4868 new_node = cgraph_same_body_alias (NULL, new_decl, info->new_decl);
4869 new_node->tm_clone = true;
4870 new_node->externally_visible = info->old_node->externally_visible;
4871 /* ?? Do not traverse aliases here. */
4872 get_cg_data (&node, false)->clone = new_node;
4874 record_tm_clone_pair (old_decl, new_decl);
4876 if (info->old_node->force_output
4877 || ipa_ref_list_first_referring (&info->old_node->ref_list))
4878 ipa_tm_mark_force_output_node (new_node);
4879 if (info->old_node->forced_by_abi)
4880 ipa_tm_mark_forced_by_abi_node (new_node);
4884 /* Create a copy of the function (possibly declaration only) of OLD_NODE,
4885 appropriate for the transactional clone. */
4888 ipa_tm_create_version (struct cgraph_node *old_node)
4890 tree new_decl, old_decl, tm_name;
4891 struct cgraph_node *new_node;
4893 old_decl = old_node->decl;
4894 new_decl = copy_node (old_decl);
4896 /* DECL_ASSEMBLER_NAME needs to be set before we call
4897 cgraph_copy_node_for_versioning below, because cgraph_node will
4898 fill the assembler_name_hash. */
4899 tm_name = tm_mangle (DECL_ASSEMBLER_NAME (old_decl));
4900 SET_DECL_ASSEMBLER_NAME (new_decl, tm_name);
4901 SET_DECL_RTL (new_decl, NULL);
4902 TREE_SYMBOL_REFERENCED (tm_name) = 1;
4904 /* Perform the same remapping to the comdat group. */
4905 if (DECL_ONE_ONLY (new_decl))
4906 DECL_COMDAT_GROUP (new_decl) = tm_mangle (DECL_COMDAT_GROUP (old_decl));
4908 new_node = cgraph_copy_node_for_versioning (old_node, new_decl, vNULL, NULL);
4909 new_node->local.local = false;
4910 new_node->externally_visible = old_node->externally_visible;
4911 new_node->lowered = true;
4912 new_node->tm_clone = 1;
4913 get_cg_data (&old_node, true)->clone = new_node;
4915 if (cgraph_function_body_availability (old_node) >= AVAIL_OVERWRITABLE)
4917 /* Remap extern inline to static inline. */
4918 /* ??? Is it worth trying to use make_decl_one_only? */
4919 if (DECL_DECLARED_INLINE_P (new_decl) && DECL_EXTERNAL (new_decl))
4921 DECL_EXTERNAL (new_decl) = 0;
4922 TREE_PUBLIC (new_decl) = 0;
4923 DECL_WEAK (new_decl) = 0;
4926 tree_function_versioning (old_decl, new_decl,
4931 record_tm_clone_pair (old_decl, new_decl);
4933 cgraph_call_function_insertion_hooks (new_node);
4934 if (old_node->force_output
4935 || ipa_ref_list_first_referring (&old_node->ref_list))
4936 ipa_tm_mark_force_output_node (new_node);
4937 if (old_node->forced_by_abi)
4938 ipa_tm_mark_forced_by_abi_node (new_node);
4940 /* Do the same thing, but for any aliases of the original node. */
4942 struct create_version_alias_info data;
4943 data.old_node = old_node;
4944 data.new_decl = new_decl;
4945 cgraph_for_node_and_aliases (old_node, ipa_tm_create_version_alias,
4950 /* Construct a call to TM_IRREVOCABLE and insert it at the beginning of BB. */
4953 ipa_tm_insert_irr_call (struct cgraph_node *node, struct tm_region *region,
4956 gimple_stmt_iterator gsi;
4959 transaction_subcode_ior (region, GTMA_MAY_ENTER_IRREVOCABLE);
4961 g = gimple_build_call (builtin_decl_explicit (BUILT_IN_TM_IRREVOCABLE),
4962 1, build_int_cst (NULL_TREE, MODE_SERIALIRREVOCABLE));
4964 split_block_after_labels (bb);
4965 gsi = gsi_after_labels (bb);
4966 gsi_insert_before (&gsi, g, GSI_SAME_STMT);
4968 cgraph_create_edge (node,
4969 cgraph_get_create_node
4970 (builtin_decl_explicit (BUILT_IN_TM_IRREVOCABLE)),
4972 compute_call_stmt_bb_frequency (node->decl,
4976 /* Construct a call to TM_GETTMCLONE and insert it before GSI. */
4979 ipa_tm_insert_gettmclone_call (struct cgraph_node *node,
4980 struct tm_region *region,
4981 gimple_stmt_iterator *gsi, gimple stmt)
4983 tree gettm_fn, ret, old_fn, callfn;
4987 old_fn = gimple_call_fn (stmt);
4989 if (TREE_CODE (old_fn) == ADDR_EXPR)
4991 tree fndecl = TREE_OPERAND (old_fn, 0);
4992 tree clone = get_tm_clone_pair (fndecl);
4994 /* By transforming the call into a TM_GETTMCLONE, we are
4995 technically taking the address of the original function and
4996 its clone. Explain this so inlining will know this function
4998 cgraph_mark_address_taken_node (cgraph_get_node (fndecl));
5000 cgraph_mark_address_taken_node (cgraph_get_node (clone));
5003 safe = is_tm_safe (TREE_TYPE (old_fn));
5004 gettm_fn = builtin_decl_explicit (safe ? BUILT_IN_TM_GETTMCLONE_SAFE
5005 : BUILT_IN_TM_GETTMCLONE_IRR);
5006 ret = create_tmp_var (ptr_type_node, NULL);
5009 transaction_subcode_ior (region, GTMA_MAY_ENTER_IRREVOCABLE);
5011 /* Discard OBJ_TYPE_REF, since we weren't able to fold it. */
5012 if (TREE_CODE (old_fn) == OBJ_TYPE_REF)
5013 old_fn = OBJ_TYPE_REF_EXPR (old_fn);
5015 g = gimple_build_call (gettm_fn, 1, old_fn);
5016 ret = make_ssa_name (ret, g);
5017 gimple_call_set_lhs (g, ret);
5019 gsi_insert_before (gsi, g, GSI_SAME_STMT);
5021 cgraph_create_edge (node, cgraph_get_create_node (gettm_fn), g, 0,
5022 compute_call_stmt_bb_frequency (node->decl,
5025 /* Cast return value from tm_gettmclone* into appropriate function
5027 callfn = create_tmp_var (TREE_TYPE (old_fn), NULL);
5028 g2 = gimple_build_assign (callfn,
5029 fold_build1 (NOP_EXPR, TREE_TYPE (callfn), ret));
5030 callfn = make_ssa_name (callfn, g2);
5031 gimple_assign_set_lhs (g2, callfn);
5032 gsi_insert_before (gsi, g2, GSI_SAME_STMT);
5034 /* ??? This is a hack to preserve the NOTHROW bit on the call,
5035 which we would have derived from the decl. Failure to save
5036 this bit means we might have to split the basic block. */
5037 if (gimple_call_nothrow_p (stmt))
5038 gimple_call_set_nothrow (stmt, true);
5040 gimple_call_set_fn (stmt, callfn);
5042 /* Discarding OBJ_TYPE_REF above may produce incompatible LHS and RHS
5043 for a call statement. Fix it. */
5045 tree lhs = gimple_call_lhs (stmt);
5046 tree rettype = TREE_TYPE (gimple_call_fntype (stmt));
5048 && !useless_type_conversion_p (TREE_TYPE (lhs), rettype))
5052 temp = create_tmp_reg (rettype, 0);
5053 gimple_call_set_lhs (stmt, temp);
5055 g2 = gimple_build_assign (lhs,
5056 fold_build1 (VIEW_CONVERT_EXPR,
5057 TREE_TYPE (lhs), temp));
5058 gsi_insert_after (gsi, g2, GSI_SAME_STMT);
5067 /* Helper function for ipa_tm_transform_calls*. Given a call
5068 statement in GSI which resides inside transaction REGION, redirect
5069 the call to either its wrapper function, or its clone. */
5072 ipa_tm_transform_calls_redirect (struct cgraph_node *node,
5073 struct tm_region *region,
5074 gimple_stmt_iterator *gsi,
5075 bool *need_ssa_rename_p)
5077 gimple stmt = gsi_stmt (*gsi);
5078 struct cgraph_node *new_node;
5079 struct cgraph_edge *e = cgraph_edge (node, stmt);
5080 tree fndecl = gimple_call_fndecl (stmt);
5082 /* For indirect calls, pass the address through the runtime. */
5085 *need_ssa_rename_p |=
5086 ipa_tm_insert_gettmclone_call (node, region, gsi, stmt);
5090 /* Handle some TM builtins. Ordinarily these aren't actually generated
5091 at this point, but handling these functions when written in by the
5092 user makes it easier to build unit tests. */
5093 if (flags_from_decl_or_type (fndecl) & ECF_TM_BUILTIN)
5096 /* Fixup recursive calls inside clones. */
5097 /* ??? Why did cgraph_copy_node_for_versioning update the call edges
5098 for recursion but not update the call statements themselves? */
5099 if (e->caller == e->callee && decl_is_tm_clone (current_function_decl))
5101 gimple_call_set_fndecl (stmt, current_function_decl);
5105 /* If there is a replacement, use it. */
5106 fndecl = find_tm_replacement_function (fndecl);
5109 new_node = cgraph_get_create_node (fndecl);
5111 /* ??? Mark all transaction_wrap functions tm_may_enter_irr.
5113 We can't do this earlier in record_tm_replacement because
5114 cgraph_remove_unreachable_nodes is called before we inject
5115 references to the node. Further, we can't do this in some
5116 nice central place in ipa_tm_execute because we don't have
5117 the exact list of wrapper functions that would be used.
5118 Marking more wrappers than necessary results in the creation
5119 of unnecessary cgraph_nodes, which can cause some of the
5120 other IPA passes to crash.
5122 We do need to mark these nodes so that we get the proper
5123 result in expand_call_tm. */
5124 /* ??? This seems broken. How is it that we're marking the
5125 CALLEE as may_enter_irr? Surely we should be marking the
5126 CALLER. Also note that find_tm_replacement_function also
5127 contains mappings into the TM runtime, e.g. memcpy. These
5128 we know won't go irrevocable. */
5129 new_node->local.tm_may_enter_irr = 1;
5133 struct tm_ipa_cg_data *d;
5134 struct cgraph_node *tnode = e->callee;
5136 d = get_cg_data (&tnode, true);
5137 new_node = d->clone;
5139 /* As we've already skipped pure calls and appropriate builtins,
5140 and we've already marked irrevocable blocks, if we can't come
5141 up with a static replacement, then ask the runtime. */
5142 if (new_node == NULL)
5144 *need_ssa_rename_p |=
5145 ipa_tm_insert_gettmclone_call (node, region, gsi, stmt);
5149 fndecl = new_node->decl;
5152 cgraph_redirect_edge_callee (e, new_node);
5153 gimple_call_set_fndecl (stmt, fndecl);
5156 /* Helper function for ipa_tm_transform_calls. For a given BB,
5157 install calls to tm_irrevocable when IRR_BLOCKS are reached,
5158 redirect other calls to the generated transactional clone. */
5161 ipa_tm_transform_calls_1 (struct cgraph_node *node, struct tm_region *region,
5162 basic_block bb, bitmap irr_blocks)
5164 gimple_stmt_iterator gsi;
5165 bool need_ssa_rename = false;
5167 if (irr_blocks && bitmap_bit_p (irr_blocks, bb->index))
5169 ipa_tm_insert_irr_call (node, region, bb);
5173 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
5175 gimple stmt = gsi_stmt (gsi);
5177 if (!is_gimple_call (stmt))
5179 if (is_tm_pure_call (stmt))
5182 /* Redirect edges to the appropriate replacement or clone. */
5183 ipa_tm_transform_calls_redirect (node, region, &gsi, &need_ssa_rename);
5186 return need_ssa_rename;
5189 /* Walk the CFG for REGION, beginning at BB. Install calls to
5190 tm_irrevocable when IRR_BLOCKS are reached, redirect other calls to
5191 the generated transactional clone. */
5194 ipa_tm_transform_calls (struct cgraph_node *node, struct tm_region *region,
5195 basic_block bb, bitmap irr_blocks)
5197 bool need_ssa_rename = false;
5200 vec<basic_block> queue = vNULL;
5201 bitmap visited_blocks = BITMAP_ALLOC (NULL);
5203 queue.safe_push (bb);
5209 ipa_tm_transform_calls_1 (node, region, bb, irr_blocks);
5211 if (irr_blocks && bitmap_bit_p (irr_blocks, bb->index))
5214 if (region && bitmap_bit_p (region->exit_blocks, bb->index))
5217 FOR_EACH_EDGE (e, ei, bb->succs)
5218 if (!bitmap_bit_p (visited_blocks, e->dest->index))
5220 bitmap_set_bit (visited_blocks, e->dest->index);
5221 queue.safe_push (e->dest);
5224 while (!queue.is_empty ());
5227 BITMAP_FREE (visited_blocks);
5229 return need_ssa_rename;
5232 /* Transform the calls within the TM regions within NODE. */
5235 ipa_tm_transform_transaction (struct cgraph_node *node)
5237 struct tm_ipa_cg_data *d;
5238 struct tm_region *region;
5239 bool need_ssa_rename = false;
5241 d = get_cg_data (&node, true);
5243 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
5244 calculate_dominance_info (CDI_DOMINATORS);
5246 for (region = d->all_tm_regions; region; region = region->next)
5248 /* If we're sure to go irrevocable, don't transform anything. */
5249 if (d->irrevocable_blocks_normal
5250 && bitmap_bit_p (d->irrevocable_blocks_normal,
5251 region->entry_block->index))
5253 transaction_subcode_ior (region, GTMA_DOES_GO_IRREVOCABLE
5254 | GTMA_MAY_ENTER_IRREVOCABLE
5255 | GTMA_HAS_NO_INSTRUMENTATION);
5260 ipa_tm_transform_calls (node, region, region->entry_block,
5261 d->irrevocable_blocks_normal);
5264 if (need_ssa_rename)
5265 update_ssa (TODO_update_ssa_only_virtuals);
5270 /* Transform the calls within the transactional clone of NODE. */
5273 ipa_tm_transform_clone (struct cgraph_node *node)
5275 struct tm_ipa_cg_data *d;
5276 bool need_ssa_rename;
5278 d = get_cg_data (&node, true);
5280 /* If this function makes no calls and has no irrevocable blocks,
5281 then there's nothing to do. */
5282 /* ??? Remove non-aborting top-level transactions. */
5283 if (!node->callees && !node->indirect_calls && !d->irrevocable_blocks_clone)
5286 push_cfun (DECL_STRUCT_FUNCTION (d->clone->decl));
5287 calculate_dominance_info (CDI_DOMINATORS);
5290 ipa_tm_transform_calls (d->clone, NULL, single_succ (ENTRY_BLOCK_PTR),
5291 d->irrevocable_blocks_clone);
5293 if (need_ssa_rename)
5294 update_ssa (TODO_update_ssa_only_virtuals);
5299 /* Main entry point for the transactional memory IPA pass. */
5302 ipa_tm_execute (void)
5304 cgraph_node_queue tm_callees = cgraph_node_queue ();
5305 /* List of functions that will go irrevocable. */
5306 cgraph_node_queue irr_worklist = cgraph_node_queue ();
5308 struct cgraph_node *node;
5309 struct tm_ipa_cg_data *d;
5310 enum availability a;
5313 #ifdef ENABLE_CHECKING
5317 bitmap_obstack_initialize (&tm_obstack);
5318 initialize_original_copy_tables ();
5320 /* For all local functions marked tm_callable, queue them. */
5321 FOR_EACH_DEFINED_FUNCTION (node)
5322 if (is_tm_callable (node->decl)
5323 && cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
5325 d = get_cg_data (&node, true);
5326 maybe_push_queue (node, &tm_callees, &d->in_callee_queue);
5329 /* For all local reachable functions... */
5330 FOR_EACH_DEFINED_FUNCTION (node)
5332 && cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
5334 /* ... marked tm_pure, record that fact for the runtime by
5335 indicating that the pure function is its own tm_callable.
5336 No need to do this if the function's address can't be taken. */
5337 if (is_tm_pure (node->decl))
5339 if (!node->local.local)
5340 record_tm_clone_pair (node->decl, node->decl);
5344 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
5345 calculate_dominance_info (CDI_DOMINATORS);
5347 tm_region_init (NULL);
5350 d = get_cg_data (&node, true);
5352 /* Scan for calls that are in each transaction, and
5353 generate the uninstrumented code path. */
5354 ipa_tm_scan_calls_transaction (d, &tm_callees);
5356 /* Put it in the worklist so we can scan the function
5357 later (ipa_tm_scan_irr_function) and mark the
5358 irrevocable blocks. */
5359 maybe_push_queue (node, &irr_worklist, &d->in_worklist);
5360 d->want_irr_scan_normal = true;
5366 /* For every local function on the callee list, scan as if we will be
5367 creating a transactional clone, queueing all new functions we find
5369 for (i = 0; i < tm_callees.length (); ++i)
5371 node = tm_callees[i];
5372 a = cgraph_function_body_availability (node);
5373 d = get_cg_data (&node, true);
5375 /* Put it in the worklist so we can scan the function later
5376 (ipa_tm_scan_irr_function) and mark the irrevocable
5378 maybe_push_queue (node, &irr_worklist, &d->in_worklist);
5380 /* Some callees cannot be arbitrarily cloned. These will always be
5381 irrevocable. Mark these now, so that we need not scan them. */
5382 if (is_tm_irrevocable (node->decl))
5383 ipa_tm_note_irrevocable (node, &irr_worklist);
5384 else if (a <= AVAIL_NOT_AVAILABLE
5385 && !is_tm_safe_or_pure (node->decl))
5386 ipa_tm_note_irrevocable (node, &irr_worklist);
5387 else if (a >= AVAIL_OVERWRITABLE)
5389 if (!tree_versionable_function_p (node->decl))
5390 ipa_tm_note_irrevocable (node, &irr_worklist);
5391 else if (!d->is_irrevocable)
5393 /* If this is an alias, make sure its base is queued as well.
5394 we need not scan the callees now, as the base will do. */
5397 node = cgraph_get_node (node->thunk.alias);
5398 d = get_cg_data (&node, true);
5399 maybe_push_queue (node, &tm_callees, &d->in_callee_queue);
5403 /* Add all nodes called by this function into
5404 tm_callees as well. */
5405 ipa_tm_scan_calls_clone (node, &tm_callees);
5410 /* Iterate scans until no more work to be done. Prefer not to use
5411 vec::pop because the worklist tends to follow a breadth-first
5412 search of the callgraph, which should allow convergance with a
5413 minimum number of scans. But we also don't want the worklist
5414 array to grow without bound, so we shift the array up periodically. */
5415 for (i = 0; i < irr_worklist.length (); ++i)
5417 if (i > 256 && i == irr_worklist.length () / 8)
5419 irr_worklist.block_remove (0, i);
5423 node = irr_worklist[i];
5424 d = get_cg_data (&node, true);
5425 d->in_worklist = false;
5427 if (d->want_irr_scan_normal)
5429 d->want_irr_scan_normal = false;
5430 ipa_tm_scan_irr_function (node, false);
5432 if (d->in_callee_queue && ipa_tm_scan_irr_function (node, true))
5433 ipa_tm_note_irrevocable (node, &irr_worklist);
5436 /* For every function on the callee list, collect the tm_may_enter_irr
5438 irr_worklist.truncate (0);
5439 for (i = 0; i < tm_callees.length (); ++i)
5441 node = tm_callees[i];
5442 if (ipa_tm_mayenterirr_function (node))
5444 d = get_cg_data (&node, true);
5445 gcc_assert (d->in_worklist == false);
5446 maybe_push_queue (node, &irr_worklist, &d->in_worklist);
5450 /* Propagate the tm_may_enter_irr bit to callers until stable. */
5451 for (i = 0; i < irr_worklist.length (); ++i)
5453 struct cgraph_node *caller;
5454 struct cgraph_edge *e;
5455 struct ipa_ref *ref;
5458 if (i > 256 && i == irr_worklist.length () / 8)
5460 irr_worklist.block_remove (0, i);
5464 node = irr_worklist[i];
5465 d = get_cg_data (&node, true);
5466 d->in_worklist = false;
5467 node->local.tm_may_enter_irr = true;
5469 /* Propagate back to normal callers. */
5470 for (e = node->callers; e ; e = e->next_caller)
5473 if (!is_tm_safe_or_pure (caller->decl)
5474 && !caller->local.tm_may_enter_irr)
5476 d = get_cg_data (&caller, true);
5477 maybe_push_queue (caller, &irr_worklist, &d->in_worklist);
5481 /* Propagate back to referring aliases as well. */
5482 for (j = 0; ipa_ref_list_referring_iterate (&node->ref_list, j, ref); j++)
5484 caller = cgraph (ref->referring);
5485 if (ref->use == IPA_REF_ALIAS
5486 && !caller->local.tm_may_enter_irr)
5488 /* ?? Do not traverse aliases here. */
5489 d = get_cg_data (&caller, false);
5490 maybe_push_queue (caller, &irr_worklist, &d->in_worklist);
5495 /* Now validate all tm_safe functions, and all atomic regions in
5497 FOR_EACH_DEFINED_FUNCTION (node)
5499 && cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
5501 d = get_cg_data (&node, true);
5502 if (is_tm_safe (node->decl))
5503 ipa_tm_diagnose_tm_safe (node);
5504 else if (d->all_tm_regions)
5505 ipa_tm_diagnose_transaction (node, d->all_tm_regions);
5508 /* Create clones. Do those that are not irrevocable and have a
5509 positive call count. Do those publicly visible functions that
5510 the user directed us to clone. */
5511 for (i = 0; i < tm_callees.length (); ++i)
5515 node = tm_callees[i];
5516 if (node->cpp_implicit_alias)
5519 a = cgraph_function_body_availability (node);
5520 d = get_cg_data (&node, true);
5522 if (a <= AVAIL_NOT_AVAILABLE)
5523 doit = is_tm_callable (node->decl);
5524 else if (a <= AVAIL_AVAILABLE && is_tm_callable (node->decl))
5526 else if (!d->is_irrevocable
5527 && d->tm_callers_normal + d->tm_callers_clone > 0)
5531 ipa_tm_create_version (node);
5534 /* Redirect calls to the new clones, and insert irrevocable marks. */
5535 for (i = 0; i < tm_callees.length (); ++i)
5537 node = tm_callees[i];
5540 d = get_cg_data (&node, true);
5542 ipa_tm_transform_clone (node);
5545 FOR_EACH_DEFINED_FUNCTION (node)
5547 && cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
5549 d = get_cg_data (&node, true);
5550 if (d->all_tm_regions)
5551 ipa_tm_transform_transaction (node);
5554 /* Free and clear all data structures. */
5555 tm_callees.release ();
5556 irr_worklist.release ();
5557 bitmap_obstack_release (&tm_obstack);
5558 free_original_copy_tables ();
5560 FOR_EACH_FUNCTION (node)
5563 #ifdef ENABLE_CHECKING
5572 const pass_data pass_data_ipa_tm =
5574 SIMPLE_IPA_PASS, /* type */
5576 OPTGROUP_NONE, /* optinfo_flags */
5577 true, /* has_gate */
5578 true, /* has_execute */
5579 TV_TRANS_MEM, /* tv_id */
5580 ( PROP_ssa | PROP_cfg ), /* properties_required */
5581 0, /* properties_provided */
5582 0, /* properties_destroyed */
5583 0, /* todo_flags_start */
5584 0, /* todo_flags_finish */
5587 class pass_ipa_tm : public simple_ipa_opt_pass
5590 pass_ipa_tm (gcc::context *ctxt)
5591 : simple_ipa_opt_pass (pass_data_ipa_tm, ctxt)
5594 /* opt_pass methods: */
5595 bool gate () { return gate_tm (); }
5596 unsigned int execute () { return ipa_tm_execute (); }
5598 }; // class pass_ipa_tm
5602 simple_ipa_opt_pass *
5603 make_pass_ipa_tm (gcc::context *ctxt)
5605 return new pass_ipa_tm (ctxt);
5608 #include "gt-trans-mem.h"