19/n: trans-mem: compiler tree/gimple stuff

These are misc tree and gimple patches, which I consider front-ish-end 
changes.

require
@@ -487,6 +488,15 @@ struct GTY(()) gimple_statement_eh_filte
    gimple_seq failure;
  };

+/* GIMPLE_EH_ELSE */
+
+struct GTY(()) gimple_statement_eh_else {
+  /* [ WORD 1-4 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 5,6 ] */
+  gimple_seq n_body, e_body;
+};

  /* GIMPLE_EH_MUST_NOT_THROW */

@@ -757,6 +767,43 @@ struct GTY(()) gimple_statement_omp_atom
    tree val;
  };

+/* GIMPLE_TRANSACTION.  */
+
+/* Bits to be stored in the GIMPLE_TRANSACTION subcode.  */
+
+/* The __transaction_atomic was declared [[outer]] or it is
+   __transaction_relaxed.  */
+#define GTMA_IS_OUTER			(1u << 0)
+#define GTMA_IS_RELAXED			(1u << 1)
+#define GTMA_DECLARATION_MASK		(GTMA_IS_OUTER | GTMA_IS_RELAXED)
+
+/* The transaction is seen to not have an abort.  */
+#define GTMA_HAVE_ABORT			(1u << 2)
+/* The transaction is seen to have loads or stores.  */
+#define GTMA_HAVE_LOAD			(1u << 3)
+#define GTMA_HAVE_STORE			(1u << 4)
+/* The transaction MAY enter serial irrevocable mode in its dynamic 
scope.  */
+#define GTMA_MAY_ENTER_IRREVOCABLE	(1u << 5)
+/* The transaction WILL enter serial irrevocable mode.
+   An irrevocable block post-dominates the entire transaction, such
+   that all invocations of the transaction will go serial-irrevocable.
+   In such case, we don't bother instrumenting the transaction, and
+   tell the runtime that it should begin the transaction in
+   serial-irrevocable mode.  */
+#define GTMA_DOES_GO_IRREVOCABLE	(1u << 6)
+
+struct GTY(()) gimple_statement_transaction
+{
+  /* [ WORD 1-10 ]  */
+  struct gimple_statement_with_memory_ops_base gsbase;
+
+  /* [ WORD 11 ] */
+  gimple_seq body;
+
+  /* [ WORD 12 ] */
+  tree label;
+};
+
  #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP)	SYM,
  enum gimple_statement_structure_enum {
  #include "gsstruct.def"
@@ -779,6 +826,7 @@ union GTY ((desc ("gimple_statement_stru
    struct gimple_statement_catch GTY ((tag ("GSS_CATCH"))) gimple_catch;
    struct gimple_statement_eh_filter GTY ((tag ("GSS_EH_FILTER"))) 
gimple_eh_filter;
    struct gimple_statement_eh_mnt GTY ((tag ("GSS_EH_MNT"))) gimple_eh_mnt;
+  struct gimple_statement_eh_else GTY ((tag ("GSS_EH_ELSE"))) 
gimple_eh_else;
    struct gimple_statement_phi GTY ((tag ("GSS_PHI"))) gimple_phi;
    struct gimple_statement_eh_ctrl GTY ((tag ("GSS_EH_CTRL"))) 
gimple_eh_ctrl;
    struct gimple_statement_try GTY ((tag ("GSS_TRY"))) gimple_try;
@@ -793,6 +841,7 @@ union GTY ((desc ("gimple_statement_stru
    struct gimple_statement_omp_continue GTY ((tag 
("GSS_OMP_CONTINUE"))) gimple_omp_continue;
    struct gimple_statement_omp_atomic_load GTY ((tag 
("GSS_OMP_ATOMIC_LOAD"))) gimple_omp_atomic_load;
    struct gimple_statement_omp_atomic_store GTY ((tag 
("GSS_OMP_ATOMIC_STORE"))) gimple_omp_atomic_store;
+  struct gimple_statement_transaction GTY((tag ("GSS_TRANSACTION"))) 
gimple_transaction;
  };

  /* In gimple.c.  */
@@ -846,6 +895,7 @@ gimple gimple_build_asm_vec (const char
  gimple gimple_build_catch (tree, gimple_seq);
  gimple gimple_build_eh_filter (tree, gimple_seq);
  gimple gimple_build_eh_must_not_throw (tree);
+gimple gimple_build_eh_else (gimple_seq, gimple_seq);
  gimple gimple_build_try (gimple_seq, gimple_seq, enum gimple_try_flags);
  gimple gimple_build_wce (gimple_seq);
  gimple gimple_build_resx (int);
@@ -868,6 +918,7 @@ gimple gimple_build_omp_single (gimple_s
  gimple gimple_build_cdt (tree, tree);
  gimple gimple_build_omp_atomic_load (tree, tree);
  gimple gimple_build_omp_atomic_store (tree);
+gimple gimple_build_transaction (gimple_seq, tree);
  gimple gimple_build_predict (enum br_predictor, enum prediction);
  enum gimple_statement_structure_enum gss_for_assign (enum tree_code);
  void sort_case_labels (VEC(tree,heap) *);
@@ -986,6 +1037,7 @@ extern bool walk_stmt_load_store_ops (gi
  				      bool (*)(gimple, tree, void *),
  				      bool (*)(gimple, tree, void *));
  extern bool gimple_ior_addresses_taken (bitmap, gimple);
+extern const_tree strip_invariant_refs (const_tree);
  extern bool gimple_call_builtin_p (gimple, enum built_in_function);
  extern bool gimple_asm_clobbers_memory_p (const_gimple);

@@ -1077,6 +1129,9 @@ extern tree canonicalize_cond_expr_cond
  /* In omp-low.c.  */
  extern tree omp_reduction_init (tree, tree);

+/* In trans-mem.c.  */
+extern void diagnose_tm_safe_errors (tree);
+
  /* In tree-nested.c.  */
  extern void lower_nested_functions (tree);
  extern void insert_field_into_struct (tree, tree);
@@ -1135,6 +1190,7 @@ gimple_has_substatements (gimple g)
      case GIMPLE_BIND:
      case GIMPLE_CATCH:
      case GIMPLE_EH_FILTER:
+    case GIMPLE_EH_ELSE:
      case GIMPLE_TRY:
      case GIMPLE_OMP_FOR:
      case GIMPLE_OMP_MASTER:
@@ -1146,6 +1202,7 @@ gimple_has_substatements (gimple g)
      case GIMPLE_OMP_SINGLE:
      case GIMPLE_OMP_CRITICAL:
      case GIMPLE_WITH_CLEANUP_EXPR:
+    case GIMPLE_TRANSACTION:
        return true;

      default:
@@ -2436,6 +2493,22 @@ gimple_call_alloca_for_var_p (gimple s)
    return (s->gsbase.subcode & GF_CALL_ALLOCA_FOR_VAR) != 0;
  }

+/* Return true if S is a noinline call.  */
+
+static inline bool
+gimple_call_noinline_p (gimple s)
+{
+  GIMPLE_CHECK (s, GIMPLE_CALL);
+  return (s->gsbase.subcode & GF_CALL_NOINLINE) != 0;
+}
+
+static inline void
+gimple_call_set_noinline_p (gimple s)
+{
+  GIMPLE_CHECK (s, GIMPLE_CALL);
+  s->gsbase.subcode |= GF_CALL_NOINLINE;
+}
+
  /* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL.  */

  static inline void
@@ -3178,6 +3251,35 @@ gimple_eh_must_not_throw_set_fndecl (gim
    gs->gimple_eh_mnt.fndecl = decl;
  }

+/* GIMPLE_EH_ELSE accessors.  */
+
+static inline gimple_seq
+gimple_eh_else_n_body (gimple gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_EH_ELSE);
+  return gs->gimple_eh_else.n_body;
+}
+
+static inline gimple_seq
+gimple_eh_else_e_body (gimple gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_EH_ELSE);
+  return gs->gimple_eh_else.e_body;
+}
+
+static inline void
+gimple_eh_else_set_n_body (gimple gs, gimple_seq seq)
+{
+  GIMPLE_CHECK (gs, GIMPLE_EH_ELSE);
+  gs->gimple_eh_else.n_body = seq;
+}
+
+static inline void
+gimple_eh_else_set_e_body (gimple gs, gimple_seq seq)
+{
+  GIMPLE_CHECK (gs, GIMPLE_EH_ELSE);
+  gs->gimple_eh_else.e_body = seq;
+}

  /* GIMPLE_TRY accessors. */

@@ -4556,6 +4658,67 @@ gimple_omp_continue_set_control_use (gim
    g->gimple_omp_continue.control_use = use;
  }

+/* Return the body for the GIMPLE_TRANSACTION statement GS.  */
+
+static inline gimple_seq
+gimple_transaction_body (gimple gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_TRANSACTION);
+  return gs->gimple_transaction.body;
+}
+
+/* Return the label associated with a GIMPLE_TRANSACTION.  */
+
+static inline tree
+gimple_transaction_label (const_gimple gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_TRANSACTION);
+  return gs->gimple_transaction.label;
+}
+
+static inline tree *
+gimple_transaction_label_ptr (gimple gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_TRANSACTION);
+  return &gs->gimple_transaction.label;
+}
+
+/* Return the subcode associated with a GIMPLE_TRANSACTION.  */
+
+static inline unsigned int
+gimple_transaction_subcode (const_gimple gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_TRANSACTION);
+  return gs->gsbase.subcode;
+}
+
+/* Set BODY to be the body for the GIMPLE_TRANSACTION statement GS.  */
+
+static inline void
+gimple_transaction_set_body (gimple gs, gimple_seq body)
+{
+  GIMPLE_CHECK (gs, GIMPLE_TRANSACTION);
+  gs->gimple_transaction.body = body;
+}
+
+/* Set the label associated with a GIMPLE_TRANSACTION.  */
+
+static inline void
+gimple_transaction_set_label (gimple gs, tree label)
+{
+  GIMPLE_CHECK (gs, GIMPLE_TRANSACTION);
+  gs->gimple_transaction.label = label;
+}
+
+/* Set the subcode associated with a GIMPLE_TRANSACTION.  */
+
+static inline void
+gimple_transaction_set_subcode (gimple gs, unsigned int subcode)
+{
+  GIMPLE_CHECK (gs, GIMPLE_TRANSACTION);
+  gs->gsbase.subcode = subcode;
+}
+

  /* Return a pointer to the return value for GIMPLE_RETURN GS.  */

@@ -4982,6 +5145,12 @@ struct walk_stmt_info
       will be visited more than once.  */
    struct pointer_set_t *pset;

+  /* Operand returned by the callbacks.  This is set when calling
+     walk_gimple_seq.  If the walk_stmt_fn or walk_tree_fn callback
+     returns non-NULL, this field will contain the tree returned by
+     the last callback.  */
+  tree callback_result;
+
    /* Indicates whether the operand being examined may be replaced
       with something that matches is_gimple_val (if true) or something
       slightly more complicated (if false).  "Something" technically
@@ -4994,23 +5163,20 @@ struct walk_stmt_info
       statement 'foo (&var)', the flag VAL_ONLY will initially be set
       to true, however, when walking &var, the operand of that
       ADDR_EXPR does not need to be a GIMPLE value.  */
-  bool val_only;
+  BOOL_BITFIELD val_only : 1;

    /* True if we are currently walking the LHS of an assignment.  */
-  bool is_lhs;
+  BOOL_BITFIELD is_lhs : 1;

    /* Optional.  Set to true by the callback functions if they made any
       changes.  */
-  bool changed;
+  BOOL_BITFIELD changed : 1;

    /* True if we're interested in location information.  */
-  bool want_locations;
+  BOOL_BITFIELD want_locations : 1;

-  /* Operand returned by the callbacks.  This is set when calling
-     walk_gimple_seq.  If the walk_stmt_fn or walk_tree_fn callback
-     returns non-NULL, this field will contain the tree returned by
-     the last callback.  */
-  tree callback_result;
+  /* True if we've removed the statement that was processed.  */
+  BOOL_BITFIELD removed_stmt : 1;
  };

  /* Callback for walk_gimple_stmt.  Called for every statement found


19/n: trans-mem: compiler tree/gimple stuff

Commit Message

Comments

Patch